module: gtk-internal

define constant <gulong> = <integer>;

define constant <GType> = <gulong>;

define C-subtype <_GTypeClass> (<C-void*>) end;
define constant <GTypeClass> = <_GTypeClass>;

define C-subtype <_GTypeInstance> (<C-void*>) end;
define constant <GTypeInstance> = <_GTypeInstance>;

define constant <guint> = <integer>;

define C-subtype <_GData> (<C-void*>) end;
define constant <GData> = <_GData>;

define C-subtype <_GObject> (<GTypeInstance>) end;
define constant <GInitiallyUnowned> = <_GObject>;

define constant <guint32> = <integer>;

define C-subtype <_GtkObject> (<GObject>) end;
define constant <GtkObject> = <_GtkObject>;

define constant <guint16> = <integer>;

define constant <guint8> = <integer>;

define constant <gchar> = <integer>;

define C-pointer-type <c-string> => <gchar>;
define constant <GObject> = <_GObject>;

define C-subtype <_GdkColor> (<C-void*>) end;
define constant <GdkColor> = <_GdkColor>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkColor<@5>>"*/
define C-subtype <_PangoFontDescription> (<C-void*>) end;
define constant <PangoFontDescription> = <_PangoFontDescription>;

define constant <gint> = <integer>;

define constant <GdkVisualType> = limited(<integer>, min: 0, max: 5);
define constant $GDK-VISUAL-STATIC-GRAY :: <GdkVisualType> = 0;
define constant $GDK-VISUAL-GRAYSCALE :: <GdkVisualType> = 1;
define constant $GDK-VISUAL-STATIC-COLOR :: <GdkVisualType> = 2;
define constant $GDK-VISUAL-PSEUDO-COLOR :: <GdkVisualType> = 3;
define constant $GDK-VISUAL-TRUE-COLOR :: <GdkVisualType> = 4;
define constant $GDK-VISUAL-DIRECT-COLOR :: <GdkVisualType> = 5;

define constant <GdkByteOrder> = limited(<integer>, min: 0, max: 1);
define constant $GDK-LSB-FIRST :: <GdkByteOrder> = 0;
define constant $GDK-MSB-FIRST :: <GdkByteOrder> = 1;

define C-subtype <_GdkVisual> (<C-void*>) end;
define constant <GdkVisual> = <_GdkVisual>;

define constant <gpointer> = <machine-pointer>;

define C-subtype <_GdkColormap> (<C-void*>) end;
define constant <GdkColormap> = <_GdkColormap>;

define C-subtype <_GdkGC> (<C-void*>) end;
define constant <GdkGC> = <_GdkGC>;

define C-pointer-type <GdkGC*> => <GdkGC>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkGC<@5>>"*/
define C-subtype <_GdkDrawable> (<C-void*>) end;
define constant <GdkPixmap> = <_GdkDrawable>;

define C-pointer-type <GdkPixmap*> => <GdkPixmap>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkPixmap<@5>>"*/
define constant <GdkFontType> = limited(<integer>, min: 0, max: 1);
define constant $GDK-FONT-FONT :: <GdkFontType> = 0;
define constant $GDK-FONT-FONTSET :: <GdkFontType> = 1;

define C-subtype <_GdkFont> (<C-void*>) end;
define constant <GdkFont> = <_GdkFont>;

define C-pointer-type <gchar**> => <c-string>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar*<@5>>"*/
define constant <GtkRcFlags> = limited(<integer>, min: 1, max: 8);
define constant $GTK-RC-FG :: <GtkRcFlags> = 1;
define constant $GTK-RC-BG :: <GtkRcFlags> = 2;
define constant $GTK-RC-TEXT :: <GtkRcFlags> = 4;
define constant $GTK-RC-BASE :: <GtkRcFlags> = 8;

define C-pointer-type <GtkRcFlags*> => <GtkRcFlags>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<GtkRcFlags<@5>>"*/
define C-subtype <_GArray> (<C-void*>) end;
define constant <GArray> = <_GArray>;

define C-subtype <_GSList> (<C-void*>) end;
define constant <GSList> = <_GSList>;

define C-subtype <_GtkRcStyle> (<GObject>) end;
define constant <GtkRcStyle> = <_GtkRcStyle>;

define C-subtype <_GtkStyle> (<GObject>) end;
define constant <GtkStyle> = <_GtkStyle>;

define C-subtype <_GtkRequisition> (<C-void*>) end;
define constant <GtkRequisition> = <_GtkRequisition>;

define C-subtype <_GdkRectangle> (<C-void*>) end;
define constant <GdkRectangle> = <_GdkRectangle>;

define constant <GtkAllocation> = <GdkRectangle>;

define constant <GdkWindow> = <_GdkDrawable>;

define C-subtype <_GtkWidget> (<GtkObject>, <AtkImplementorIface>) end;
define constant <GtkWidget> = <_GtkWidget>;

define C-subtype <_GtkContainer> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkContainer> = <_GtkContainer>;

define C-subtype <_GtkBin> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkBin> = <_GtkBin>;

define constant <GtkWindow> = <_GtkWindow>;

define C-subtype <_GtkWindowGeometryInfo> (<C-void*>) end;
define constant <GtkWindowGeometryInfo> = <_GtkWindowGeometryInfo>;

define C-subtype <_GtkWindowGroup> (<GObject>) end;
define constant <GtkWindowGroup> = <_GtkWindowGroup>;

define constant <GdkModifierType> = limited(<integer>, min: 1, max: #ex000000005C001FFF);
define constant $GDK-SHIFT-MASK :: <GdkModifierType> = 1;
define constant $GDK-LOCK-MASK :: <GdkModifierType> = 2;
define constant $GDK-CONTROL-MASK :: <GdkModifierType> = 4;
define constant $GDK-MOD1-MASK :: <GdkModifierType> = 8;
define constant $GDK-MOD2-MASK :: <GdkModifierType> = 16;
define constant $GDK-MOD3-MASK :: <GdkModifierType> = 32;
define constant $GDK-MOD4-MASK :: <GdkModifierType> = 64;
define constant $GDK-MOD5-MASK :: <GdkModifierType> = 128;
define constant $GDK-BUTTON1-MASK :: <GdkModifierType> = 256;
define constant $GDK-BUTTON2-MASK :: <GdkModifierType> = 512;
define constant $GDK-BUTTON3-MASK :: <GdkModifierType> = 1024;
define constant $GDK-BUTTON4-MASK :: <GdkModifierType> = 2048;
define constant $GDK-BUTTON5-MASK :: <GdkModifierType> = 4096;
define constant $GDK-SUPER-MASK :: <GdkModifierType> = 67108864;
define constant $GDK-HYPER-MASK :: <GdkModifierType> = 134217728;
define constant $GDK-META-MASK :: <GdkModifierType> = 268435456;
define constant $GDK-RELEASE-MASK :: <GdkModifierType> = #ex0000000040000000;
define constant $GDK-MODIFIER-MASK :: <GdkModifierType> = #ex000000005C001FFF;

 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkGC<@32>>"*/
define C-subtype <_cairo-font-options> (<C-void*>) end;
define constant <cairo-font-options-t> = <_cairo-font-options>;

define C-subtype <_GdkScreen> (<C-void*>) end;
define constant <GdkScreen> = <_GdkScreen>;

define C-subtype <_GtkWindow> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GParamFlags> = limited(<integer>, min: 1, max: 128);
define constant $G-PARAM-READABLE :: <GParamFlags> = 1;
define constant $G-PARAM-WRITABLE :: <GParamFlags> = 2;
define constant $G-PARAM-CONSTRUCT :: <GParamFlags> = 4;
define constant $G-PARAM-CONSTRUCT-ONLY :: <GParamFlags> = 8;
define constant $G-PARAM-LAX-VALIDATION :: <GParamFlags> = 16;
define constant $G-PARAM-STATIC-NAME :: <GParamFlags> = 32;
define constant $G-PARAM-PRIVATE :: <GParamFlags> = 32;
define constant $G-PARAM-STATIC-NICK :: <GParamFlags> = 64;
define constant $G-PARAM-STATIC-BLURB :: <GParamFlags> = 128;

define C-subtype <_GParamSpec> (<C-void*>) end;
define constant <GParamSpec> = <_GParamSpec>;

define constant <glong> = <integer>;

define constant <gint64> = <double-integer>;

define constant <guint64> = <double-integer>;

define constant <gfloat> = <single-float>;

define constant <gdouble> = <double-float>;

 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-1507>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<anonymous-1507<@2>>"*/
define C-subtype <_GValue> (<C-void*>) end;
define constant <GValue> = <_GValue>;

define C-subtype <_GObjectConstructParam> (<C-void*>) end;
define constant <GObjectConstructParam> = <_GObjectConstructParam>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1653>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1654>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1655>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1656>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1657>"*/
define C-pointer-type <GParamSpec*> => <GParamSpec>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1658>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1659>"*/
define C-pointer-type <gpointer*> => <gpointer>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<gpointer<@8>>"*/
define C-subtype <_GObjectClass> (<C-void*>) end;
define constant <GInitiallyUnownedClass> = <_GObjectClass>;

define constant <GtkType> = <GType>;

define constant <guchar> = <integer>;

define constant <gboolean> = <gint>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3344>"*/
define constant <GtkSignalFunc> = <anonymous-3344>;

define C-subtype <anonymous-3345> (<C-void*>) end;
 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-3346>"*/
define C-subtype <_GtkArg> (<C-void*>) end;
define constant <GtkArg> = <_GtkArg>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3357>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3358>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3359>"*/
define C-subtype <_GtkObjectClass> (<C-void*>) end;
define constant <GtkObjectClass> = <_GtkObjectClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3634>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3635>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3636>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3637>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3638>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3639>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3640>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3641>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3642>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3643>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3644>"*/
define constant <GtkStateType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-STATE-NORMAL :: <GtkStateType> = 0;
define constant $GTK-STATE-ACTIVE :: <GtkStateType> = 1;
define constant $GTK-STATE-PRELIGHT :: <GtkStateType> = 2;
define constant $GTK-STATE-SELECTED :: <GtkStateType> = 3;
define constant $GTK-STATE-INSENSITIVE :: <GtkStateType> = 4;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3645>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3646>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3647>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3648>"*/
define constant <GtkTextDirection> = limited(<integer>, min: 0, max: 2);
define constant $GTK-TEXT-DIR-NONE :: <GtkTextDirection> = 0;
define constant $GTK-TEXT-DIR-LTR :: <GtkTextDirection> = 1;
define constant $GTK-TEXT-DIR-RTL :: <GtkTextDirection> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3649>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3650>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3651>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3652>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3653>"*/
define constant <GtkDirectionType> = limited(<integer>, min: 0, max: 5);
define constant $GTK-DIR-TAB-FORWARD :: <GtkDirectionType> = 0;
define constant $GTK-DIR-TAB-BACKWARD :: <GtkDirectionType> = 1;
define constant $GTK-DIR-UP :: <GtkDirectionType> = 2;
define constant $GTK-DIR-DOWN :: <GtkDirectionType> = 3;
define constant $GTK-DIR-LEFT :: <GtkDirectionType> = 4;
define constant $GTK-DIR-RIGHT :: <GtkDirectionType> = 5;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3654>"*/
define constant <GdkEventType> = limited(<integer>, min: -1, max: 35);
define constant $GDK-NOTHING :: <GdkEventType> = -1;
define constant $GDK-DELETE :: <GdkEventType> = 0;
define constant $GDK-DESTROY :: <GdkEventType> = 1;
define constant $GDK-EXPOSE :: <GdkEventType> = 2;
define constant $GDK-MOTION-NOTIFY :: <GdkEventType> = 3;
define constant $GDK-BUTTON-PRESS :: <GdkEventType> = 4;
define constant $GDK-2BUTTON-PRESS :: <GdkEventType> = 5;
define constant $GDK-3BUTTON-PRESS :: <GdkEventType> = 6;
define constant $GDK-BUTTON-RELEASE :: <GdkEventType> = 7;
define constant $GDK-KEY-PRESS :: <GdkEventType> = 8;
define constant $GDK-KEY-RELEASE :: <GdkEventType> = 9;
define constant $GDK-ENTER-NOTIFY :: <GdkEventType> = 10;
define constant $GDK-LEAVE-NOTIFY :: <GdkEventType> = 11;
define constant $GDK-FOCUS-CHANGE :: <GdkEventType> = 12;
define constant $GDK-CONFIGURE :: <GdkEventType> = 13;
define constant $GDK-MAP :: <GdkEventType> = 14;
define constant $GDK-UNMAP :: <GdkEventType> = 15;
define constant $GDK-PROPERTY-NOTIFY :: <GdkEventType> = 16;
define constant $GDK-SELECTION-CLEAR :: <GdkEventType> = 17;
define constant $GDK-SELECTION-REQUEST :: <GdkEventType> = 18;
define constant $GDK-SELECTION-NOTIFY :: <GdkEventType> = 19;
define constant $GDK-PROXIMITY-IN :: <GdkEventType> = 20;
define constant $GDK-PROXIMITY-OUT :: <GdkEventType> = 21;
define constant $GDK-DRAG-ENTER :: <GdkEventType> = 22;
define constant $GDK-DRAG-LEAVE :: <GdkEventType> = 23;
define constant $GDK-DRAG-MOTION :: <GdkEventType> = 24;
define constant $GDK-DRAG-STATUS :: <GdkEventType> = 25;
define constant $GDK-DROP-START :: <GdkEventType> = 26;
define constant $GDK-DROP-FINISHED :: <GdkEventType> = 27;
define constant $GDK-CLIENT-EVENT :: <GdkEventType> = 28;
define constant $GDK-VISIBILITY-NOTIFY :: <GdkEventType> = 29;
define constant $GDK-NO-EXPOSE :: <GdkEventType> = 30;
define constant $GDK-SCROLL :: <GdkEventType> = 31;
define constant $GDK-WINDOW-STATE :: <GdkEventType> = 32;
define constant $GDK-SETTING :: <GdkEventType> = 33;
define constant $GDK-OWNER-CHANGE :: <GdkEventType> = 34;
define constant $GDK-GRAB-BROKEN :: <GdkEventType> = 35;

define constant <gint8> = <integer>;

define C-subtype <_GdkEventAny> (<C-void*>) end;
define constant <GdkEventAny> = <_GdkEventAny>;

define C-subtype <_GdkRegion> (<C-void*>) end;
define constant <GdkRegion> = <_GdkRegion>;

define C-subtype <_GdkEventExpose> (<C-void*>) end;
define constant <GdkEventExpose> = <_GdkEventExpose>;

define C-subtype <_GdkEventNoExpose> (<C-void*>) end;
define constant <GdkEventNoExpose> = <_GdkEventNoExpose>;

define constant <GdkVisibilityState> = limited(<integer>, min: 0, max: 2);
define constant $GDK-VISIBILITY-UNOBSCURED :: <GdkVisibilityState> = 0;
define constant $GDK-VISIBILITY-PARTIAL :: <GdkVisibilityState> = 1;
define constant $GDK-VISIBILITY-FULLY-OBSCURED :: <GdkVisibilityState> = 2;

define C-subtype <_GdkEventVisibility> (<C-void*>) end;
define constant <GdkEventVisibility> = <_GdkEventVisibility>;

define C-pointer-type <gdouble*> => <gdouble>;
define constant <gint16> = <integer>;

define constant <GdkInputSource> = limited(<integer>, min: 0, max: 3);
define constant $GDK-SOURCE-MOUSE :: <GdkInputSource> = 0;
define constant $GDK-SOURCE-PEN :: <GdkInputSource> = 1;
define constant $GDK-SOURCE-ERASER :: <GdkInputSource> = 2;
define constant $GDK-SOURCE-CURSOR :: <GdkInputSource> = 3;

define constant <GdkInputMode> = limited(<integer>, min: 0, max: 2);
define constant $GDK-MODE-DISABLED :: <GdkInputMode> = 0;
define constant $GDK-MODE-SCREEN :: <GdkInputMode> = 1;
define constant $GDK-MODE-WINDOW :: <GdkInputMode> = 2;

define constant <GdkAxisUse> = limited(<integer>, min: 0, max: 7);
define constant $GDK-AXIS-IGNORE :: <GdkAxisUse> = 0;
define constant $GDK-AXIS-X :: <GdkAxisUse> = 1;
define constant $GDK-AXIS-Y :: <GdkAxisUse> = 2;
define constant $GDK-AXIS-PRESSURE :: <GdkAxisUse> = 3;
define constant $GDK-AXIS-XTILT :: <GdkAxisUse> = 4;
define constant $GDK-AXIS-YTILT :: <GdkAxisUse> = 5;
define constant $GDK-AXIS-WHEEL :: <GdkAxisUse> = 6;
define constant $GDK-AXIS-LAST :: <GdkAxisUse> = 7;

define C-subtype <_GdkDeviceAxis> (<C-void*>) end;
define constant <GdkDeviceAxis> = <_GdkDeviceAxis>;

define C-subtype <_GdkDeviceKey> (<C-void*>) end;
define constant <GdkDeviceKey> = <_GdkDeviceKey>;

define C-subtype <_GdkDevice> (<C-void*>) end;
define constant <GdkDevice> = <_GdkDevice>;

define C-subtype <_GdkEventMotion> (<C-void*>) end;
define constant <GdkEventMotion> = <_GdkEventMotion>;

define C-subtype <_GdkEventButton> (<C-void*>) end;
define constant <GdkEventButton> = <_GdkEventButton>;

define constant <GdkScrollDirection> = limited(<integer>, min: 0, max: 3);
define constant $GDK-SCROLL-UP :: <GdkScrollDirection> = 0;
define constant $GDK-SCROLL-DOWN :: <GdkScrollDirection> = 1;
define constant $GDK-SCROLL-LEFT :: <GdkScrollDirection> = 2;
define constant $GDK-SCROLL-RIGHT :: <GdkScrollDirection> = 3;

define C-subtype <_GdkEventScroll> (<C-void*>) end;
define constant <GdkEventScroll> = <_GdkEventScroll>;

define C-subtype <_GdkEventKey> (<C-void*>) end;
define constant <GdkEventKey> = <_GdkEventKey>;

define constant <GdkCrossingMode> = limited(<integer>, min: 0, max: 2);
define constant $GDK-CROSSING-NORMAL :: <GdkCrossingMode> = 0;
define constant $GDK-CROSSING-GRAB :: <GdkCrossingMode> = 1;
define constant $GDK-CROSSING-UNGRAB :: <GdkCrossingMode> = 2;

define constant <GdkNotifyType> = limited(<integer>, min: 0, max: 5);
define constant $GDK-NOTIFY-ANCESTOR :: <GdkNotifyType> = 0;
define constant $GDK-NOTIFY-VIRTUAL :: <GdkNotifyType> = 1;
define constant $GDK-NOTIFY-INFERIOR :: <GdkNotifyType> = 2;
define constant $GDK-NOTIFY-NONLINEAR :: <GdkNotifyType> = 3;
define constant $GDK-NOTIFY-NONLINEAR-VIRTUAL :: <GdkNotifyType> = 4;
define constant $GDK-NOTIFY-UNKNOWN :: <GdkNotifyType> = 5;

define C-subtype <_GdkEventCrossing> (<C-void*>) end;
define constant <GdkEventCrossing> = <_GdkEventCrossing>;

define C-subtype <_GdkEventFocus> (<C-void*>) end;
define constant <GdkEventFocus> = <_GdkEventFocus>;

define C-subtype <_GdkEventConfigure> (<C-void*>) end;
define constant <GdkEventConfigure> = <_GdkEventConfigure>;

define C-subtype <_GdkAtom> (<C-void*>) end;
define constant <GdkAtom> = <_GdkAtom>;

define C-subtype <_GdkEventProperty> (<C-void*>) end;
define constant <GdkEventProperty> = <_GdkEventProperty>;

define constant <GdkNativeWindow> = <guint32>;

define C-subtype <_GdkEventSelection> (<C-void*>) end;
define constant <GdkEventSelection> = <_GdkEventSelection>;

define constant <GdkOwnerChange> = limited(<integer>, min: 0, max: 2);
define constant $GDK-OWNER-CHANGE-NEW-OWNER :: <GdkOwnerChange> = 0;
define constant $GDK-OWNER-CHANGE-DESTROY :: <GdkOwnerChange> = 1;
define constant $GDK-OWNER-CHANGE-CLOSE :: <GdkOwnerChange> = 2;

define C-subtype <_GdkEventOwnerChange> (<C-void*>) end;
define constant <GdkEventOwnerChange> = <_GdkEventOwnerChange>;

define C-subtype <_GdkEventProximity> (<C-void*>) end;
define constant <GdkEventProximity> = <_GdkEventProximity>;

define constant <gushort> = <integer>;

define C-pointer-type <c-string> => <integer>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<char<@20>>"*/
define C-pointer-type <short*> => <integer>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<short<@10>>"*/
define C-pointer-type <long*> => <integer>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<long<@5>>"*/
 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-2545>"*/
define C-subtype <_GdkEventClient> (<C-void*>) end;
define constant <GdkEventClient> = <_GdkEventClient>;

define constant <GdkDragProtocol> = limited(<integer>, min: 0, max: 6);
define constant $GDK-DRAG-PROTO-MOTIF :: <GdkDragProtocol> = 0;
define constant $GDK-DRAG-PROTO-XDND :: <GdkDragProtocol> = 1;
define constant $GDK-DRAG-PROTO-ROOTWIN :: <GdkDragProtocol> = 2;
define constant $GDK-DRAG-PROTO-NONE :: <GdkDragProtocol> = 3;
define constant $GDK-DRAG-PROTO-WIN32-DROPFILES :: <GdkDragProtocol> = 4;
define constant $GDK-DRAG-PROTO-OLE2 :: <GdkDragProtocol> = 5;
define constant $GDK-DRAG-PROTO-LOCAL :: <GdkDragProtocol> = 6;

define C-subtype <_GList> (<C-void*>) end;
define constant <GList> = <_GList>;

define constant <GdkDragAction> = limited(<integer>, min: 1, max: 32);
define constant $GDK-ACTION-DEFAULT :: <GdkDragAction> = 1;
define constant $GDK-ACTION-COPY :: <GdkDragAction> = 2;
define constant $GDK-ACTION-MOVE :: <GdkDragAction> = 4;
define constant $GDK-ACTION-LINK :: <GdkDragAction> = 8;
define constant $GDK-ACTION-PRIVATE :: <GdkDragAction> = 16;
define constant $GDK-ACTION-ASK :: <GdkDragAction> = 32;

define C-subtype <_GdkDragContext> (<C-void*>) end;
define constant <GdkDragContext> = <_GdkDragContext>;

define constant <gshort> = <integer>;

define C-subtype <_GdkEventDND> (<C-void*>) end;
define constant <GdkEventDND> = <_GdkEventDND>;

define constant <GdkWindowState> = limited(<integer>, min: 1, max: 64);
define constant $GDK-WINDOW-STATE-WITHDRAWN :: <GdkWindowState> = 1;
define constant $GDK-WINDOW-STATE-ICONIFIED :: <GdkWindowState> = 2;
define constant $GDK-WINDOW-STATE-MAXIMIZED :: <GdkWindowState> = 4;
define constant $GDK-WINDOW-STATE-STICKY :: <GdkWindowState> = 8;
define constant $GDK-WINDOW-STATE-FULLSCREEN :: <GdkWindowState> = 16;
define constant $GDK-WINDOW-STATE-ABOVE :: <GdkWindowState> = 32;
define constant $GDK-WINDOW-STATE-BELOW :: <GdkWindowState> = 64;

define C-subtype <_GdkEventWindowState> (<C-void*>) end;
define constant <GdkEventWindowState> = <_GdkEventWindowState>;

define constant <GdkSettingAction> = limited(<integer>, min: 0, max: 2);
define constant $GDK-SETTING-ACTION-NEW :: <GdkSettingAction> = 0;
define constant $GDK-SETTING-ACTION-CHANGED :: <GdkSettingAction> = 1;
define constant $GDK-SETTING-ACTION-DELETED :: <GdkSettingAction> = 2;

define C-subtype <_GdkEventSetting> (<C-void*>) end;
define constant <GdkEventSetting> = <_GdkEventSetting>;

define C-subtype <_GdkEventGrabBroken> (<C-void*>) end;
define constant <GdkEventGrabBroken> = <_GdkEventGrabBroken>;

 /* Ignoring declaration for {instance of <union-declaration>} "<_GdkEvent>"*/
define constant <GdkEvent> = <_GdkEvent>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3655>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3656>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3657>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3658>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3659>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3660>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3661>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3662>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3663>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3664>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3665>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3666>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3667>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3668>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3669>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3670>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3671>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3672>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3673>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3674>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3675>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3676>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3677>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3678>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3679>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3680>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3681>"*/
define C-pointer-type <guchar*> => <guchar>;
define C-pointer-type <guint32*> => <guint32>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<guint32<@2>>"*/
define C-pointer-type <GdkWindow*> => <GdkWindow>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkWindow<@2>>"*/
define C-pointer-type <gint*> => <gint>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@2>>"*/
define C-pointer-type <GdkScreen*> => <GdkScreen>;
define C-pointer-type <GdkModifierType*> => <GdkModifierType>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2573>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2574>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2575>"*/
define C-subtype <_GdkDisplayPointerHooks> (<C-void*>) end;
define constant <GdkDisplayPointerHooks> = <_GdkDisplayPointerHooks>;

define C-subtype <_GdkDisplay> (<C-void*>) end;
define constant <GdkDisplay> = <_GdkDisplay>;

define C-subtype <_GtkSelectionData> (<C-void*>) end;
define constant <GtkSelectionData> = <_GtkSelectionData>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3682>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3683>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3684>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3685>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3686>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3687>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3688>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3689>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3690>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3691>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3692>"*/
define constant <GtkWidgetHelpType> = limited(<integer>, min: 0, max: 1);
define constant $GTK-WIDGET-HELP-TOOLTIP :: <GtkWidgetHelpType> = 0;
define constant $GTK-WIDGET-HELP-WHATS-THIS :: <GtkWidgetHelpType> = 1;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3693>"*/
define constant <AtkRole> = limited(<integer>, min: 0, max: 88);
define constant $ATK-ROLE-INVALID :: <AtkRole> = 0;
define constant $ATK-ROLE-ACCEL-LABEL :: <AtkRole> = 1;
define constant $ATK-ROLE-ALERT :: <AtkRole> = 2;
define constant $ATK-ROLE-ANIMATION :: <AtkRole> = 3;
define constant $ATK-ROLE-ARROW :: <AtkRole> = 4;
define constant $ATK-ROLE-CALENDAR :: <AtkRole> = 5;
define constant $ATK-ROLE-CANVAS :: <AtkRole> = 6;
define constant $ATK-ROLE-CHECK-BOX :: <AtkRole> = 7;
define constant $ATK-ROLE-CHECK-MENU-ITEM :: <AtkRole> = 8;
define constant $ATK-ROLE-COLOR-CHOOSER :: <AtkRole> = 9;
define constant $ATK-ROLE-COLUMN-HEADER :: <AtkRole> = 10;
define constant $ATK-ROLE-COMBO-BOX :: <AtkRole> = 11;
define constant $ATK-ROLE-DATE-EDITOR :: <AtkRole> = 12;
define constant $ATK-ROLE-DESKTOP-ICON :: <AtkRole> = 13;
define constant $ATK-ROLE-DESKTOP-FRAME :: <AtkRole> = 14;
define constant $ATK-ROLE-DIAL :: <AtkRole> = 15;
define constant $ATK-ROLE-DIALOG :: <AtkRole> = 16;
define constant $ATK-ROLE-DIRECTORY-PANE :: <AtkRole> = 17;
define constant $ATK-ROLE-DRAWING-AREA :: <AtkRole> = 18;
define constant $ATK-ROLE-FILE-CHOOSER :: <AtkRole> = 19;
define constant $ATK-ROLE-FILLER :: <AtkRole> = 20;
define constant $ATK-ROLE-FONT-CHOOSER :: <AtkRole> = 21;
define constant $ATK-ROLE-FRAME :: <AtkRole> = 22;
define constant $ATK-ROLE-GLASS-PANE :: <AtkRole> = 23;
define constant $ATK-ROLE-HTML-CONTAINER :: <AtkRole> = 24;
define constant $ATK-ROLE-ICON :: <AtkRole> = 25;
define constant $ATK-ROLE-IMAGE :: <AtkRole> = 26;
define constant $ATK-ROLE-INTERNAL-FRAME :: <AtkRole> = 27;
define constant $ATK-ROLE-LABEL :: <AtkRole> = 28;
define constant $ATK-ROLE-LAYERED-PANE :: <AtkRole> = 29;
define constant $ATK-ROLE-LIST :: <AtkRole> = 30;
define constant $ATK-ROLE-LIST-ITEM :: <AtkRole> = 31;
define constant $ATK-ROLE-MENU :: <AtkRole> = 32;
define constant $ATK-ROLE-MENU-BAR :: <AtkRole> = 33;
define constant $ATK-ROLE-MENU-ITEM :: <AtkRole> = 34;
define constant $ATK-ROLE-OPTION-PANE :: <AtkRole> = 35;
define constant $ATK-ROLE-PAGE-TAB :: <AtkRole> = 36;
define constant $ATK-ROLE-PAGE-TAB-LIST :: <AtkRole> = 37;
define constant $ATK-ROLE-PANEL :: <AtkRole> = 38;
define constant $ATK-ROLE-PASSWORD-TEXT :: <AtkRole> = 39;
define constant $ATK-ROLE-POPUP-MENU :: <AtkRole> = 40;
define constant $ATK-ROLE-PROGRESS-BAR :: <AtkRole> = 41;
define constant $ATK-ROLE-PUSH-BUTTON :: <AtkRole> = 42;
define constant $ATK-ROLE-RADIO-BUTTON :: <AtkRole> = 43;
define constant $ATK-ROLE-RADIO-MENU-ITEM :: <AtkRole> = 44;
define constant $ATK-ROLE-ROOT-PANE :: <AtkRole> = 45;
define constant $ATK-ROLE-ROW-HEADER :: <AtkRole> = 46;
define constant $ATK-ROLE-SCROLL-BAR :: <AtkRole> = 47;
define constant $ATK-ROLE-SCROLL-PANE :: <AtkRole> = 48;
define constant $ATK-ROLE-SEPARATOR :: <AtkRole> = 49;
define constant $ATK-ROLE-SLIDER :: <AtkRole> = 50;
define constant $ATK-ROLE-SPLIT-PANE :: <AtkRole> = 51;
define constant $ATK-ROLE-SPIN-BUTTON :: <AtkRole> = 52;
define constant $ATK-ROLE-STATUSBAR :: <AtkRole> = 53;
define constant $ATK-ROLE-TABLE :: <AtkRole> = 54;
define constant $ATK-ROLE-TABLE-CELL :: <AtkRole> = 55;
define constant $ATK-ROLE-TABLE-COLUMN-HEADER :: <AtkRole> = 56;
define constant $ATK-ROLE-TABLE-ROW-HEADER :: <AtkRole> = 57;
define constant $ATK-ROLE-TEAR-OFF-MENU-ITEM :: <AtkRole> = 58;
define constant $ATK-ROLE-TERMINAL :: <AtkRole> = 59;
define constant $ATK-ROLE-TEXT :: <AtkRole> = 60;
define constant $ATK-ROLE-TOGGLE-BUTTON :: <AtkRole> = 61;
define constant $ATK-ROLE-TOOL-BAR :: <AtkRole> = 62;
define constant $ATK-ROLE-TOOL-TIP :: <AtkRole> = 63;
define constant $ATK-ROLE-TREE :: <AtkRole> = 64;
define constant $ATK-ROLE-TREE-TABLE :: <AtkRole> = 65;
define constant $ATK-ROLE-UNKNOWN :: <AtkRole> = 66;
define constant $ATK-ROLE-VIEWPORT :: <AtkRole> = 67;
define constant $ATK-ROLE-WINDOW :: <AtkRole> = 68;
define constant $ATK-ROLE-HEADER :: <AtkRole> = 69;
define constant $ATK-ROLE-FOOTER :: <AtkRole> = 70;
define constant $ATK-ROLE-PARAGRAPH :: <AtkRole> = 71;
define constant $ATK-ROLE-RULER :: <AtkRole> = 72;
define constant $ATK-ROLE-APPLICATION :: <AtkRole> = 73;
define constant $ATK-ROLE-AUTOCOMPLETE :: <AtkRole> = 74;
define constant $ATK-ROLE-EDITBAR :: <AtkRole> = 75;
define constant $ATK-ROLE-EMBEDDED :: <AtkRole> = 76;
define constant $ATK-ROLE-ENTRY :: <AtkRole> = 77;
define constant $ATK-ROLE-CHART :: <AtkRole> = 78;
define constant $ATK-ROLE-CAPTION :: <AtkRole> = 79;
define constant $ATK-ROLE-DOCUMENT-FRAME :: <AtkRole> = 80;
define constant $ATK-ROLE-HEADING :: <AtkRole> = 81;
define constant $ATK-ROLE-PAGE :: <AtkRole> = 82;
define constant $ATK-ROLE-SECTION :: <AtkRole> = 83;
define constant $ATK-ROLE-REDUNDANT-OBJECT :: <AtkRole> = 84;
define constant $ATK-ROLE-FORM :: <AtkRole> = 85;
define constant $ATK-ROLE-LINK :: <AtkRole> = 86;
define constant $ATK-ROLE-INPUT-METHOD-WINDOW :: <AtkRole> = 87;
define constant $ATK-ROLE-LAST-DEFINED :: <AtkRole> = 88;

define C-subtype <_GPtrArray> (<C-void*>) end;
define constant <GPtrArray> = <_GPtrArray>;

define C-subtype <_AtkRelationSet> (<C-void*>) end;
define constant <AtkRelationSet> = <_AtkRelationSet>;

define constant <AtkLayer> = limited(<integer>, min: 0, max: 7);
define constant $ATK-LAYER-INVALID :: <AtkLayer> = 0;
define constant $ATK-LAYER-BACKGROUND :: <AtkLayer> = 1;
define constant $ATK-LAYER-CANVAS :: <AtkLayer> = 2;
define constant $ATK-LAYER-WIDGET :: <AtkLayer> = 3;
define constant $ATK-LAYER-MDI :: <AtkLayer> = 4;
define constant $ATK-LAYER-POPUP :: <AtkLayer> = 5;
define constant $ATK-LAYER-OVERLAY :: <AtkLayer> = 6;
define constant $ATK-LAYER-WINDOW :: <AtkLayer> = 7;

define C-subtype <_AtkObject> (<C-void*>) end;
define constant <AtkObject> = <_AtkObject>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3694>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3695>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3696>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3697>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3698>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3699>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3700>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3701>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3702>"*/
define C-subtype <_GtkWidgetClass> (<C-void*>) end;
define constant <GtkWidgetClass> = <_GtkWidgetClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3852>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3853>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3854>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3633>"*/
define constant <GtkCallback> = <anonymous-3633>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3855>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3856>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3857>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3858>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3859>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3860>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3861>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3862>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3863>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3864>"*/
define C-subtype <_GtkContainerClass> (<C-void*>) end;
define constant <GtkContainerClass> = <_GtkContainerClass>;

define C-subtype <_GtkBinClass> (<C-void*>) end;
define constant <GtkBinClass> = <_GtkBinClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3926>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3927>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3928>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3929>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3930>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3931>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3932>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3933>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3934>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3935>"*/
define C-subtype <_GtkWindowClass> (<C-void*>) end;
define constant <GtkWindowClass> = <_GtkWindowClass>;

define constant <GObjectClass> = <_GObjectClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3936>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3937>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3938>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3939>"*/
define C-subtype <_GtkWindowGroupClass> (<C-void*>) end;
define constant <GtkWindowGroupClass> = <_GtkWindowGroupClass>;

define C-function gtk-window-get-type
  result res :: <GType>;
  c-name: "gtk_window_get_type";
end;

define constant <GtkWindowType> = limited(<integer>, min: 0, max: 1);
define constant $GTK-WINDOW-TOPLEVEL :: <GtkWindowType> = 0;
define constant $GTK-WINDOW-POPUP :: <GtkWindowType> = 1;

define C-function gtk-window-new
  input parameter type :: <GtkWindowType>;
  result res :: <GtkWidget>;
  c-name: "gtk_window_new";
end;

define C-function gtk-window-set-title
  input parameter window :: <GtkWindow>;
  input parameter title :: <c-string>;
  c-name: "gtk_window_set_title";
end;

define C-function gtk-window-get-title
  input parameter window :: <GtkWindow>;
  result res :: <c-string>;
  c-name: "gtk_window_get_title";
end;

define C-function gtk-window-set-wmclass
  input parameter window :: <GtkWindow>;
  input parameter wmclass_name :: <c-string>;
  input parameter wmclass_class :: <c-string>;
  c-name: "gtk_window_set_wmclass";
end;

define C-function gtk-window-set-role
  input parameter window :: <GtkWindow>;
  input parameter role :: <c-string>;
  c-name: "gtk_window_set_role";
end;

define C-function gtk-window-get-role
  input parameter window :: <GtkWindow>;
  result res :: <c-string>;
  c-name: "gtk_window_get_role";
end;

define C-subtype <_GtkAccelKey> (<C-void*>) end;
define constant <GtkAccelKey> = <_GtkAccelKey>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1573>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1561>"*/
define constant <GClosureNotify> = <anonymous-1561>;

define C-subtype <_GClosureNotifyData> (<C-void*>) end;
define constant <GClosureNotifyData> = <_GClosureNotifyData>;

define C-subtype <_GClosure> (<C-void*>) end;
define constant <GClosure> = <_GClosure>;

define constant <GQuark> = <guint32>;

define C-subtype <_GtkAccelGroupEntry> (<C-void*>) end;
define constant <GtkAccelGroupEntry> = <_GtkAccelGroupEntry>;

define C-subtype <_GtkAccelGroup> (<GObject>) end;
define constant <GtkAccelGroup> = <_GtkAccelGroup>;

define C-function gtk-window-add-accel-group
  input parameter window :: <GtkWindow>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_window_add_accel_group";
end;

define C-function gtk-window-remove-accel-group
  input parameter window :: <GtkWindow>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_window_remove_accel_group";
end;

define constant <GtkWindowPosition> = limited(<integer>, min: 0, max: 4);
define constant $GTK-WIN-POS-NONE :: <GtkWindowPosition> = 0;
define constant $GTK-WIN-POS-CENTER :: <GtkWindowPosition> = 1;
define constant $GTK-WIN-POS-MOUSE :: <GtkWindowPosition> = 2;
define constant $GTK-WIN-POS-CENTER-ALWAYS :: <GtkWindowPosition> = 3;
define constant $GTK-WIN-POS-CENTER-ON-PARENT :: <GtkWindowPosition> = 4;

define C-function gtk-window-set-position
  input parameter window :: <GtkWindow>;
  input parameter position :: <GtkWindowPosition>;
  c-name: "gtk_window_set_position";
end;

define C-function gtk-window-activate-focus
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_activate_focus";
end;

define C-function gtk-window-set-focus
  input parameter window :: <GtkWindow>;
  input parameter focus :: <GtkWidget>;
  c-name: "gtk_window_set_focus";
end;

define C-function gtk-window-get-focus
  input parameter window :: <GtkWindow>;
  result res :: <GtkWidget>;
  c-name: "gtk_window_get_focus";
end;

define C-function gtk-window-set-default
  input parameter window :: <GtkWindow>;
  input parameter default_widget :: <GtkWidget>;
  c-name: "gtk_window_set_default";
end;

define C-function gtk-window-activate-default
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_activate_default";
end;

define C-function gtk-window-set-transient-for
  input parameter window :: <GtkWindow>;
  input parameter parent :: <GtkWindow>;
  c-name: "gtk_window_set_transient_for";
end;

define C-function gtk-window-get-transient-for
  input parameter window :: <GtkWindow>;
  result res :: <GtkWindow>;
  c-name: "gtk_window_get_transient_for";
end;

define constant <GdkWindowTypeHint> = limited(<integer>, min: 0, max: 13);
define constant $GDK-WINDOW-TYPE-HINT-NORMAL :: <GdkWindowTypeHint> = 0;
define constant $GDK-WINDOW-TYPE-HINT-DIALOG :: <GdkWindowTypeHint> = 1;
define constant $GDK-WINDOW-TYPE-HINT-MENU :: <GdkWindowTypeHint> = 2;
define constant $GDK-WINDOW-TYPE-HINT-TOOLBAR :: <GdkWindowTypeHint> = 3;
define constant $GDK-WINDOW-TYPE-HINT-SPLASHSCREEN :: <GdkWindowTypeHint> = 4;
define constant $GDK-WINDOW-TYPE-HINT-UTILITY :: <GdkWindowTypeHint> = 5;
define constant $GDK-WINDOW-TYPE-HINT-DOCK :: <GdkWindowTypeHint> = 6;
define constant $GDK-WINDOW-TYPE-HINT-DESKTOP :: <GdkWindowTypeHint> = 7;
define constant $GDK-WINDOW-TYPE-HINT-DROPDOWN-MENU :: <GdkWindowTypeHint> = 8;
define constant $GDK-WINDOW-TYPE-HINT-POPUP-MENU :: <GdkWindowTypeHint> = 9;
define constant $GDK-WINDOW-TYPE-HINT-TOOLTIP :: <GdkWindowTypeHint> = 10;
define constant $GDK-WINDOW-TYPE-HINT-NOTIFICATION :: <GdkWindowTypeHint> = 11;
define constant $GDK-WINDOW-TYPE-HINT-COMBO :: <GdkWindowTypeHint> = 12;
define constant $GDK-WINDOW-TYPE-HINT-DND :: <GdkWindowTypeHint> = 13;

define C-function gtk-window-set-type-hint
  input parameter window :: <GtkWindow>;
  input parameter hint :: <GdkWindowTypeHint>;
  c-name: "gtk_window_set_type_hint";
end;

define C-function gtk-window-get-type-hint
  input parameter window :: <GtkWindow>;
  result res :: <GdkWindowTypeHint>;
  c-name: "gtk_window_get_type_hint";
end;

define C-function gtk-window-set-skip-taskbar-hint
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_skip_taskbar_hint";
end;

define C-function gtk-window-get-skip-taskbar-hint
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_skip_taskbar_hint";
end;

define C-function gtk-window-set-skip-pager-hint
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_skip_pager_hint";
end;

define C-function gtk-window-get-skip-pager-hint
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_skip_pager_hint";
end;

define C-function gtk-window-set-urgency-hint
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_urgency_hint";
end;

define C-function gtk-window-get-urgency-hint
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_urgency_hint";
end;

define C-function gtk-window-set-accept-focus
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_accept_focus";
end;

define C-function gtk-window-get-accept-focus
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_accept_focus";
end;

define C-function gtk-window-set-focus-on-map
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_focus_on_map";
end;

define C-function gtk-window-get-focus-on-map
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_focus_on_map";
end;

define C-function gtk-window-set-destroy-with-parent
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_destroy_with_parent";
end;

define C-function gtk-window-get-destroy-with-parent
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_destroy_with_parent";
end;

define C-function gtk-window-set-resizable
  input parameter window :: <GtkWindow>;
  input parameter resizable :: <gboolean>;
  c-name: "gtk_window_set_resizable";
end;

define C-function gtk-window-get-resizable
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_resizable";
end;

define constant <GdkGravity> = limited(<integer>, min: 1, max: 10);
define constant $GDK-GRAVITY-NORTH-WEST :: <GdkGravity> = 1;
define constant $GDK-GRAVITY-NORTH :: <GdkGravity> = 2;
define constant $GDK-GRAVITY-NORTH-EAST :: <GdkGravity> = 3;
define constant $GDK-GRAVITY-WEST :: <GdkGravity> = 4;
define constant $GDK-GRAVITY-CENTER :: <GdkGravity> = 5;
define constant $GDK-GRAVITY-EAST :: <GdkGravity> = 6;
define constant $GDK-GRAVITY-SOUTH-WEST :: <GdkGravity> = 7;
define constant $GDK-GRAVITY-SOUTH :: <GdkGravity> = 8;
define constant $GDK-GRAVITY-SOUTH-EAST :: <GdkGravity> = 9;
define constant $GDK-GRAVITY-STATIC :: <GdkGravity> = 10;

define C-function gtk-window-set-gravity
  input parameter window :: <GtkWindow>;
  input parameter gravity :: <GdkGravity>;
  c-name: "gtk_window_set_gravity";
end;

define C-function gtk-window-get-gravity
  input parameter window :: <GtkWindow>;
  result res :: <GdkGravity>;
  c-name: "gtk_window_get_gravity";
end;

define C-subtype <_GdkGeometry> (<C-void*>) end;
define constant <GdkGeometry> = <_GdkGeometry>;

define constant <GdkWindowHints> = limited(<integer>, min: 1, max: 256);
define constant $GDK-HINT-POS :: <GdkWindowHints> = 1;
define constant $GDK-HINT-MIN-SIZE :: <GdkWindowHints> = 2;
define constant $GDK-HINT-MAX-SIZE :: <GdkWindowHints> = 4;
define constant $GDK-HINT-BASE-SIZE :: <GdkWindowHints> = 8;
define constant $GDK-HINT-ASPECT :: <GdkWindowHints> = 16;
define constant $GDK-HINT-RESIZE-INC :: <GdkWindowHints> = 32;
define constant $GDK-HINT-WIN-GRAVITY :: <GdkWindowHints> = 64;
define constant $GDK-HINT-USER-POS :: <GdkWindowHints> = 128;
define constant $GDK-HINT-USER-SIZE :: <GdkWindowHints> = 256;

define C-function gtk-window-set-geometry-hints
  input parameter window :: <GtkWindow>;
  input parameter geometry_widget :: <GtkWidget>;
  input parameter geometry :: <GdkGeometry>;
  input parameter geom_mask :: <GdkWindowHints>;
  c-name: "gtk_window_set_geometry_hints";
end;

define C-function gtk-window-set-screen
  input parameter window :: <GtkWindow>;
  input parameter screen :: <GdkScreen>;
  c-name: "gtk_window_set_screen";
end;

define C-function gtk-window-get-screen
  input parameter window :: <GtkWindow>;
  result res :: <GdkScreen>;
  c-name: "gtk_window_get_screen";
end;

define C-function gtk-window-is-active
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_is_active";
end;

define C-function gtk-window-has-toplevel-focus
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_has_toplevel_focus";
end;

define C-function gtk-window-set-has-frame
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_has_frame";
end;

define C-function gtk-window-get-has-frame
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_has_frame";
end;

define C-function gtk-window-set-frame-dimensions
  input parameter window :: <GtkWindow>;
  input parameter left :: <gint>;
  input parameter top :: <gint>;
  input parameter right :: <gint>;
  input parameter bottom :: <gint>;
  c-name: "gtk_window_set_frame_dimensions";
end;

define C-function gtk-window-get-frame-dimensions
  input parameter window :: <GtkWindow>;
  input parameter left :: <gint*>;
  input parameter top :: <gint*>;
  input parameter right :: <gint*>;
  input parameter bottom :: <gint*>;
  c-name: "gtk_window_get_frame_dimensions";
end;

define C-function gtk-window-set-decorated
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_decorated";
end;

define C-function gtk-window-get-decorated
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_decorated";
end;

define C-function gtk-window-set-deletable
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_deletable";
end;

define C-function gtk-window-get-deletable
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_deletable";
end;

define C-function gtk-window-set-icon-list
  input parameter window :: <GtkWindow>;
  input parameter list :: <GList>;
  c-name: "gtk_window_set_icon_list";
end;

define C-function gtk-window-get-icon-list
  input parameter window :: <GtkWindow>;
  result res :: <GList>;
  c-name: "gtk_window_get_icon_list";
end;

define C-subtype <_GdkPixbuf> (<C-void*>) end;
define constant <GdkPixbuf> = <_GdkPixbuf>;

define C-function gtk-window-set-icon
  input parameter window :: <GtkWindow>;
  input parameter icon :: <GdkPixbuf>;
  c-name: "gtk_window_set_icon";
end;

define C-function gtk-window-set-icon-name
  input parameter window :: <GtkWindow>;
  input parameter name :: <c-string>;
  c-name: "gtk_window_set_icon_name";
end;

define C-subtype <_GError> (<C-void*>) end;
define constant <GError> = <_GError>;

define C-pointer-type <GError*> => <GError>;
define C-function gtk-window-set-icon-from-file-utf8
  input parameter window :: <GtkWindow>;
  input parameter filename :: <c-string>;
  input parameter err :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_window_set_icon_from_file_utf8";
end;

define C-function gtk-window-get-icon
  input parameter window :: <GtkWindow>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_window_get_icon";
end;

define C-function gtk-window-get-icon-name
  input parameter window :: <GtkWindow>;
  result res :: <c-string>;
  c-name: "gtk_window_get_icon_name";
end;

define C-function gtk-window-set-default-icon-list
  input parameter list :: <GList>;
  c-name: "gtk_window_set_default_icon_list";
end;

define C-function gtk-window-get-default-icon-list
  result res :: <GList>;
  c-name: "gtk_window_get_default_icon_list";
end;

define C-function gtk-window-set-default-icon
  input parameter icon :: <GdkPixbuf>;
  c-name: "gtk_window_set_default_icon";
end;

define C-function gtk-window-set-default-icon-name
  input parameter name :: <c-string>;
  c-name: "gtk_window_set_default_icon_name";
end;

define C-function gtk-window-set-default-icon-from-file-utf8
  input parameter filename :: <c-string>;
  input parameter err :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_window_set_default_icon_from_file_utf8";
end;

define C-function gtk-window-set-auto-startup-notification
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_auto_startup_notification";
end;

define C-function gtk-window-set-modal
  input parameter window :: <GtkWindow>;
  input parameter modal :: <gboolean>;
  c-name: "gtk_window_set_modal";
end;

define C-function gtk-window-get-modal
  input parameter window :: <GtkWindow>;
  result res :: <gboolean>;
  c-name: "gtk_window_get_modal";
end;

define C-function gtk-window-list-toplevels
  result res :: <GList>;
  c-name: "gtk_window_list_toplevels";
end;

define C-function gtk-window-add-mnemonic
  input parameter window :: <GtkWindow>;
  input parameter keyval :: <guint>;
  input parameter target :: <GtkWidget>;
  c-name: "gtk_window_add_mnemonic";
end;

define C-function gtk-window-remove-mnemonic
  input parameter window :: <GtkWindow>;
  input parameter keyval :: <guint>;
  input parameter target :: <GtkWidget>;
  c-name: "gtk_window_remove_mnemonic";
end;

define C-function gtk-window-mnemonic-activate
  input parameter window :: <GtkWindow>;
  input parameter keyval :: <guint>;
  input parameter modifier :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_window_mnemonic_activate";
end;

define C-function gtk-window-set-mnemonic-modifier
  input parameter window :: <GtkWindow>;
  input parameter modifier :: <GdkModifierType>;
  c-name: "gtk_window_set_mnemonic_modifier";
end;

define C-function gtk-window-get-mnemonic-modifier
  input parameter window :: <GtkWindow>;
  result res :: <GdkModifierType>;
  c-name: "gtk_window_get_mnemonic_modifier";
end;

define C-function gtk-window-activate-key
  input parameter window :: <GtkWindow>;
  input parameter event :: <GdkEventKey>;
  result res :: <gboolean>;
  c-name: "gtk_window_activate_key";
end;

define C-function gtk-window-propagate-key-event
  input parameter window :: <GtkWindow>;
  input parameter event :: <GdkEventKey>;
  result res :: <gboolean>;
  c-name: "gtk_window_propagate_key_event";
end;

define C-function gtk-window-present
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_present";
end;

define C-function gtk-window-present-with-time
  input parameter window :: <GtkWindow>;
  input parameter timestamp :: <guint32>;
  c-name: "gtk_window_present_with_time";
end;

define C-function gtk-window-iconify
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_iconify";
end;

define C-function gtk-window-deiconify
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_deiconify";
end;

define C-function gtk-window-stick
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_stick";
end;

define C-function gtk-window-unstick
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_unstick";
end;

define C-function gtk-window-maximize
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_maximize";
end;

define C-function gtk-window-unmaximize
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_unmaximize";
end;

define C-function gtk-window-fullscreen
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_fullscreen";
end;

define C-function gtk-window-unfullscreen
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_unfullscreen";
end;

define C-function gtk-window-set-keep-above
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_keep_above";
end;

define C-function gtk-window-set-keep-below
  input parameter window :: <GtkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_window_set_keep_below";
end;

define constant <GdkWindowEdge> = limited(<integer>, min: 0, max: 7);
define constant $GDK-WINDOW-EDGE-NORTH-WEST :: <GdkWindowEdge> = 0;
define constant $GDK-WINDOW-EDGE-NORTH :: <GdkWindowEdge> = 1;
define constant $GDK-WINDOW-EDGE-NORTH-EAST :: <GdkWindowEdge> = 2;
define constant $GDK-WINDOW-EDGE-WEST :: <GdkWindowEdge> = 3;
define constant $GDK-WINDOW-EDGE-EAST :: <GdkWindowEdge> = 4;
define constant $GDK-WINDOW-EDGE-SOUTH-WEST :: <GdkWindowEdge> = 5;
define constant $GDK-WINDOW-EDGE-SOUTH :: <GdkWindowEdge> = 6;
define constant $GDK-WINDOW-EDGE-SOUTH-EAST :: <GdkWindowEdge> = 7;

define C-function gtk-window-begin-resize-drag
  input parameter window :: <GtkWindow>;
  input parameter edge :: <GdkWindowEdge>;
  input parameter button :: <gint>;
  input parameter root_x :: <gint>;
  input parameter root_y :: <gint>;
  input parameter timestamp :: <guint32>;
  c-name: "gtk_window_begin_resize_drag";
end;

define C-function gtk-window-begin-move-drag
  input parameter window :: <GtkWindow>;
  input parameter button :: <gint>;
  input parameter root_x :: <gint>;
  input parameter root_y :: <gint>;
  input parameter timestamp :: <guint32>;
  c-name: "gtk_window_begin_move_drag";
end;

define C-function gtk-window-set-policy
  input parameter window :: <GtkWindow>;
  input parameter allow_shrink :: <gint>;
  input parameter allow_grow :: <gint>;
  input parameter auto_shrink :: <gint>;
  c-name: "gtk_window_set_policy";
end;

define C-function gtk-window-set-default-size
  input parameter window :: <GtkWindow>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_window_set_default_size";
end;

define C-function gtk-window-get-default-size
  input parameter window :: <GtkWindow>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_window_get_default_size";
end;

define C-function gtk-window-resize
  input parameter window :: <GtkWindow>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_window_resize";
end;

define C-function gtk-window-get-size
  input parameter window :: <GtkWindow>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_window_get_size";
end;

define C-function gtk-window-move
  input parameter window :: <GtkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_window_move";
end;

define C-function gtk-window-get-position
  input parameter window :: <GtkWindow>;
  input parameter root_x :: <gint*>;
  input parameter root_y :: <gint*>;
  c-name: "gtk_window_get_position";
end;

define C-function gtk-window-parse-geometry
  input parameter window :: <GtkWindow>;
  input parameter geometry :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_window_parse_geometry";
end;

define C-function gtk-window-get-group
  input parameter window :: <GtkWindow>;
  result res :: <GtkWindowGroup>;
  c-name: "gtk_window_get_group";
end;

define C-function gtk-window-reshow-with-initial-size
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_reshow_with_initial_size";
end;

define C-function gtk-window-group-get-type
  result res :: <GType>;
  c-name: "gtk_window_group_get_type";
end;

define C-function gtk-window-group-new
  result res :: <GtkWindowGroup>;
  c-name: "gtk_window_group_new";
end;

define C-function gtk-window-group-add-window
  input parameter window_group :: <GtkWindowGroup>;
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_group_add_window";
end;

define C-function gtk-window-group-remove-window
  input parameter window_group :: <GtkWindowGroup>;
  input parameter window :: <GtkWindow>;
  c-name: "gtk_window_group_remove_window";
end;

define C-function _gtk-window-internal-set-focus
  input parameter window :: <GtkWindow>;
  input parameter focus :: <GtkWidget>;
  c-name: "_gtk_window_internal_set_focus";
end;

define C-function gtk-window-remove-embedded-xid
  input parameter window :: <GtkWindow>;
  input parameter xid :: <guint>;
  c-name: "gtk_window_remove_embedded_xid";
end;

define C-function gtk-window-add-embedded-xid
  input parameter window :: <GtkWindow>;
  input parameter xid :: <guint>;
  c-name: "gtk_window_add_embedded_xid";
end;

define C-function _gtk-window-reposition
  input parameter window :: <GtkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "_gtk_window_reposition";
end;

define C-function _gtk-window-constrain-size
  input parameter window :: <GtkWindow>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter new_width :: <gint*>;
  input parameter new_height :: <gint*>;
  c-name: "_gtk_window_constrain_size";
end;

define C-function _gtk-window-group-get-current-grab
  input parameter window_group :: <GtkWindowGroup>;
  result res :: <GtkWidget>;
  c-name: "_gtk_window_group_get_current_grab";
end;

define C-function _gtk-window-set-has-toplevel-focus
  input parameter window :: <GtkWindow>;
  input parameter has_toplevel_focus :: <gboolean>;
  c-name: "_gtk_window_set_has_toplevel_focus";
end;

define C-function _gtk-window-unset-focus-and-default
  input parameter window :: <GtkWindow>;
  input parameter widget :: <GtkWidget>;
  c-name: "_gtk_window_unset_focus_and_default";
end;

define C-function _gtk-window-set-is-active
  input parameter window :: <GtkWindow>;
  input parameter is_active :: <gboolean>;
  c-name: "_gtk_window_set_is_active";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4048>"*/
define constant <GtkWindowKeysForeachFunc> = <anonymous-4048>;

define C-function _gtk-window-keys-foreach
  input parameter window :: <GtkWindow>;
  input parameter func :: <GtkWindowKeysForeachFunc>;
  input parameter func_data :: <gpointer>;
  c-name: "_gtk_window_keys_foreach";
end;

define C-function _gtk-window-query-nonaccels
  input parameter window :: <GtkWindow>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "_gtk_window_query_nonaccels";
end;

define constant gtk-window-set-icon-from-file = gtk-window-set-icon-from-file-utf8;

define constant gtk-window-set-default-icon-from-file = gtk-window-set-default-icon-from-file-utf8;

define constant gtk-window-position = gtk-window-set-position;

define constant <GtkWidgetFlags> = limited(<integer>, min: 16, max: 4194304);
define constant $GTK-TOPLEVEL :: <GtkWidgetFlags> = 16;
define constant $GTK-NO-WINDOW :: <GtkWidgetFlags> = 32;
define constant $GTK-REALIZED :: <GtkWidgetFlags> = 64;
define constant $GTK-MAPPED :: <GtkWidgetFlags> = 128;
define constant $GTK-VISIBLE :: <GtkWidgetFlags> = 256;
define constant $GTK-SENSITIVE :: <GtkWidgetFlags> = 512;
define constant $GTK-PARENT-SENSITIVE :: <GtkWidgetFlags> = 1024;
define constant $GTK-CAN-FOCUS :: <GtkWidgetFlags> = 2048;
define constant $GTK-HAS-FOCUS :: <GtkWidgetFlags> = 4096;
define constant $GTK-CAN-DEFAULT :: <GtkWidgetFlags> = 8192;
define constant $GTK-HAS-DEFAULT :: <GtkWidgetFlags> = 16384;
define constant $GTK-HAS-GRAB :: <GtkWidgetFlags> = 32768;
define constant $GTK-RC-STYLE :: <GtkWidgetFlags> = 65536;
define constant $GTK-COMPOSITE-CHILD :: <GtkWidgetFlags> = 131072;
define constant $GTK-NO-REPARENT :: <GtkWidgetFlags> = 262144;
define constant $GTK-APP-PAINTABLE :: <GtkWidgetFlags> = 524288;
define constant $GTK-RECEIVES-DEFAULT :: <GtkWidgetFlags> = 1048576;
define constant $GTK-DOUBLE-BUFFERED :: <GtkWidgetFlags> = 2097152;
define constant $GTK-NO-SHOW-ALL :: <GtkWidgetFlags> = 4194304;

define C-subtype <_GtkWidgetAuxInfo> (<C-void*>) end;
define constant <GtkWidgetAuxInfo> = <_GtkWidgetAuxInfo>;

define constant <GdkBitmap> = <_GdkDrawable>;

define C-subtype <_GtkWidgetShapeInfo> (<C-void*>) end;
define constant <GtkWidgetShapeInfo> = <_GtkWidgetShapeInfo>;

define C-subtype <_GtkClipboard> (<C-void*>) end;
define constant <GtkClipboard> = <_GtkClipboard>;

define C-function gtk-widget-get-type
  result res :: <GType>;
  c-name: "gtk_widget_get_type";
end;

define C-function gtk-widget-new
  input parameter type :: <GType>;
  input parameter first_property_name :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_widget_new";
end;

define C-function gtk-widget-ref
  input parameter widget :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_widget_ref";
end;

define C-function gtk-widget-unref
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_unref";
end;

define C-function gtk-widget-destroy
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_destroy";
end;

define C-pointer-type <GtkWidget*> => <GtkWidget>;
define C-function gtk-widget-destroyed
  input parameter widget :: <GtkWidget>;
  input parameter widget_pointer :: <GtkWidget*>;
  c-name: "gtk_widget_destroyed";
end;

define C-function gtk-widget-set
  input parameter widget :: <GtkWidget>;
  input parameter first_property_name :: <c-string>;
  c-name: "gtk_widget_set";
end;

define C-function gtk-widget-unparent
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_unparent";
end;

define C-function gtk-widget-show
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_show";
end;

define C-function gtk-widget-show-now
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_show_now";
end;

define C-function gtk-widget-hide
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_hide";
end;

define C-function gtk-widget-show-all
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_show_all";
end;

define C-function gtk-widget-hide-all
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_hide_all";
end;

define C-function gtk-widget-set-no-show-all
  input parameter widget :: <GtkWidget>;
  input parameter no_show_all :: <gboolean>;
  c-name: "gtk_widget_set_no_show_all";
end;

define C-function gtk-widget-get-no-show-all
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_get_no_show_all";
end;

define C-function gtk-widget-map
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_map";
end;

define C-function gtk-widget-unmap
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_unmap";
end;

define C-function gtk-widget-realize
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_realize";
end;

define C-function gtk-widget-unrealize
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_unrealize";
end;

define C-function gtk-widget-queue-draw
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_queue_draw";
end;

define C-function gtk-widget-queue-draw-area
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_widget_queue_draw_area";
end;

define C-function gtk-widget-queue-clear
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_queue_clear";
end;

define C-function gtk-widget-queue-clear-area
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_widget_queue_clear_area";
end;

define C-function gtk-widget-queue-resize
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_queue_resize";
end;

define C-function gtk-widget-queue-resize-no-redraw
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_queue_resize_no_redraw";
end;

define C-function gtk-widget-draw
  input parameter widget :: <GtkWidget>;
  input parameter area :: <GdkRectangle>;
  c-name: "gtk_widget_draw";
end;

define C-function gtk-widget-size-request
  input parameter widget :: <GtkWidget>;
  input parameter requisition :: <GtkRequisition>;
  c-name: "gtk_widget_size_request";
end;

define C-function gtk-widget-size-allocate
  input parameter widget :: <GtkWidget>;
  input parameter allocation :: <GtkAllocation>;
  c-name: "gtk_widget_size_allocate";
end;

define C-function gtk-widget-get-child-requisition
  input parameter widget :: <GtkWidget>;
  input parameter requisition :: <GtkRequisition>;
  c-name: "gtk_widget_get_child_requisition";
end;

define constant <GtkAccelFlags> = limited(<integer>, min: 1, max: 7);
define constant $GTK-ACCEL-VISIBLE :: <GtkAccelFlags> = 1;
define constant $GTK-ACCEL-LOCKED :: <GtkAccelFlags> = 2;
define constant $GTK-ACCEL-MASK :: <GtkAccelFlags> = 7;

define C-function gtk-widget-add-accelerator
  input parameter widget :: <GtkWidget>;
  input parameter accel_signal :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  input parameter accel_flags :: <GtkAccelFlags>;
  c-name: "gtk_widget_add_accelerator";
end;

define C-function gtk-widget-remove-accelerator
  input parameter widget :: <GtkWidget>;
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_widget_remove_accelerator";
end;

define C-function gtk-widget-set-accel-path
  input parameter widget :: <GtkWidget>;
  input parameter accel_path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_widget_set_accel_path";
end;

define C-pointer-type <gboolean*> => <gboolean>;
define C-function _gtk-widget-get-accel-path
  input parameter widget :: <GtkWidget>;
  input parameter locked :: <gboolean*>;
  result res :: <c-string>;
  c-name: "_gtk_widget_get_accel_path";
end;

define C-function gtk-widget-list-accel-closures
  input parameter widget :: <GtkWidget>;
  result res :: <GList>;
  c-name: "gtk_widget_list_accel_closures";
end;

define C-function gtk-widget-can-activate-accel
  input parameter widget :: <GtkWidget>;
  input parameter signal_id :: <guint>;
  result res :: <gboolean>;
  c-name: "gtk_widget_can_activate_accel";
end;

define C-function gtk-widget-mnemonic-activate
  input parameter widget :: <GtkWidget>;
  input parameter group_cycling :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_widget_mnemonic_activate";
end;

define C-function gtk-widget-event
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEvent>;
  result res :: <gboolean>;
  c-name: "gtk_widget_event";
end;

define C-function gtk-widget-send-expose
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEvent>;
  result res :: <gint>;
  c-name: "gtk_widget_send_expose";
end;

define C-function gtk-widget-activate
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_activate";
end;

define C-subtype <_GtkAdjustment> (<GtkObject>) end;
define constant <GtkAdjustment> = <_GtkAdjustment>;

define C-function gtk-widget-set-scroll-adjustments
  input parameter widget :: <GtkWidget>;
  input parameter hadjustment :: <GtkAdjustment>;
  input parameter vadjustment :: <GtkAdjustment>;
  result res :: <gboolean>;
  c-name: "gtk_widget_set_scroll_adjustments";
end;

define C-function gtk-widget-reparent
  input parameter widget :: <GtkWidget>;
  input parameter new_parent :: <GtkWidget>;
  c-name: "gtk_widget_reparent";
end;

define C-function gtk-widget-intersect
  input parameter widget :: <GtkWidget>;
  input parameter area :: <GdkRectangle>;
  input parameter intersection :: <GdkRectangle>;
  result res :: <gboolean>;
  c-name: "gtk_widget_intersect";
end;

define C-function gtk-widget-region-intersect
  input parameter widget :: <GtkWidget>;
  input parameter region :: <GdkRegion>;
  result res :: <GdkRegion>;
  c-name: "gtk_widget_region_intersect";
end;

define C-function gtk-widget-freeze-child-notify
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_freeze_child_notify";
end;

define C-function gtk-widget-child-notify
  input parameter widget :: <GtkWidget>;
  input parameter child_property :: <c-string>;
  c-name: "gtk_widget_child_notify";
end;

define C-function gtk-widget-thaw-child-notify
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_thaw_child_notify";
end;

define C-function gtk-widget-is-focus
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_is_focus";
end;

define C-function gtk-widget-grab-focus
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_grab_focus";
end;

define C-function gtk-widget-grab-default
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_grab_default";
end;

define C-function gtk-widget-set-name
  input parameter widget :: <GtkWidget>;
  input parameter name :: <c-string>;
  c-name: "gtk_widget_set_name";
end;

define C-function gtk-widget-get-name
  input parameter widget :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_widget_get_name";
end;

define C-function gtk-widget-set-state
  input parameter widget :: <GtkWidget>;
  input parameter state :: <GtkStateType>;
  c-name: "gtk_widget_set_state";
end;

define C-function gtk-widget-set-sensitive
  input parameter widget :: <GtkWidget>;
  input parameter sensitive :: <gboolean>;
  c-name: "gtk_widget_set_sensitive";
end;

define C-function gtk-widget-set-app-paintable
  input parameter widget :: <GtkWidget>;
  input parameter app_paintable :: <gboolean>;
  c-name: "gtk_widget_set_app_paintable";
end;

define C-function gtk-widget-set-double-buffered
  input parameter widget :: <GtkWidget>;
  input parameter double_buffered :: <gboolean>;
  c-name: "gtk_widget_set_double_buffered";
end;

define C-function gtk-widget-set-redraw-on-allocate
  input parameter widget :: <GtkWidget>;
  input parameter redraw_on_allocate :: <gboolean>;
  c-name: "gtk_widget_set_redraw_on_allocate";
end;

define C-function gtk-widget-set-parent
  input parameter widget :: <GtkWidget>;
  input parameter parent :: <GtkWidget>;
  c-name: "gtk_widget_set_parent";
end;

define C-function gtk-widget-set-parent-window
  input parameter widget :: <GtkWidget>;
  input parameter parent_window :: <GdkWindow>;
  c-name: "gtk_widget_set_parent_window";
end;

define C-function gtk-widget-set-child-visible
  input parameter widget :: <GtkWidget>;
  input parameter is_visible :: <gboolean>;
  c-name: "gtk_widget_set_child_visible";
end;

define C-function gtk-widget-get-child-visible
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_get_child_visible";
end;

define C-function gtk-widget-get-parent
  input parameter widget :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_widget_get_parent";
end;

define C-function gtk-widget-get-parent-window
  input parameter widget :: <GtkWidget>;
  result res :: <GdkWindow>;
  c-name: "gtk_widget_get_parent_window";
end;

define C-function gtk-widget-child-focus
  input parameter widget :: <GtkWidget>;
  input parameter direction :: <GtkDirectionType>;
  result res :: <gboolean>;
  c-name: "gtk_widget_child_focus";
end;

define C-function gtk-widget-set-size-request
  input parameter widget :: <GtkWidget>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_widget_set_size_request";
end;

define C-function gtk-widget-get-size-request
  input parameter widget :: <GtkWidget>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_widget_get_size_request";
end;

define C-function gtk-widget-set-uposition
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_widget_set_uposition";
end;

define C-function gtk-widget-set-usize
  input parameter widget :: <GtkWidget>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_widget_set_usize";
end;

define C-function gtk-widget-set-events
  input parameter widget :: <GtkWidget>;
  input parameter events :: <gint>;
  c-name: "gtk_widget_set_events";
end;

define C-function gtk-widget-add-events
  input parameter widget :: <GtkWidget>;
  input parameter events :: <gint>;
  c-name: "gtk_widget_add_events";
end;

define constant <GdkExtensionMode> = limited(<integer>, min: 0, max: 2);
define constant $GDK-EXTENSION-EVENTS-NONE :: <GdkExtensionMode> = 0;
define constant $GDK-EXTENSION-EVENTS-ALL :: <GdkExtensionMode> = 1;
define constant $GDK-EXTENSION-EVENTS-CURSOR :: <GdkExtensionMode> = 2;

define C-function gtk-widget-set-extension-events
  input parameter widget :: <GtkWidget>;
  input parameter mode :: <GdkExtensionMode>;
  c-name: "gtk_widget_set_extension_events";
end;

define C-function gtk-widget-get-extension-events
  input parameter widget :: <GtkWidget>;
  result res :: <GdkExtensionMode>;
  c-name: "gtk_widget_get_extension_events";
end;

define C-function gtk-widget-get-toplevel
  input parameter widget :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_widget_get_toplevel";
end;

define C-function gtk-widget-get-ancestor
  input parameter widget :: <GtkWidget>;
  input parameter widget_type :: <GType>;
  result res :: <GtkWidget>;
  c-name: "gtk_widget_get_ancestor";
end;

define C-function gtk-widget-get-colormap
  input parameter widget :: <GtkWidget>;
  result res :: <GdkColormap>;
  c-name: "gtk_widget_get_colormap";
end;

define C-function gtk-widget-get-visual
  input parameter widget :: <GtkWidget>;
  result res :: <GdkVisual>;
  c-name: "gtk_widget_get_visual";
end;

define C-function gtk-widget-get-screen
  input parameter widget :: <GtkWidget>;
  result res :: <GdkScreen>;
  c-name: "gtk_widget_get_screen";
end;

define C-function gtk-widget-has-screen
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_has_screen";
end;

define C-function gtk-widget-get-display
  input parameter widget :: <GtkWidget>;
  result res :: <GdkDisplay>;
  c-name: "gtk_widget_get_display";
end;

define C-function gtk-widget-get-root-window
  input parameter widget :: <GtkWidget>;
  result res :: <GdkWindow>;
  c-name: "gtk_widget_get_root_window";
end;

define C-subtype <_GtkSettingsPropertyValue> (<C-void*>) end;
define constant <GtkSettingsPropertyValue> = <_GtkSettingsPropertyValue>;

define C-subtype <_GtkRcContext> (<C-void*>) end;
define constant <GtkRcContext> = <_GtkRcContext>;

define C-subtype <_GtkSettings> (<GObject>) end;
define constant <GtkSettings> = <_GtkSettings>;

define C-function gtk-widget-get-settings
  input parameter widget :: <GtkWidget>;
  result res :: <GtkSettings>;
  c-name: "gtk_widget_get_settings";
end;

define C-function gtk-widget-get-clipboard
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  result res :: <GtkClipboard>;
  c-name: "gtk_widget_get_clipboard";
end;

define C-function gtk-widget-get-accessible
  input parameter widget :: <GtkWidget>;
  result res :: <AtkObject>;
  c-name: "gtk_widget_get_accessible";
end;

define C-function gtk-widget-set-colormap
  input parameter widget :: <GtkWidget>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gtk_widget_set_colormap";
end;

define C-function gtk-widget-get-events
  input parameter widget :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_widget_get_events";
end;

define C-function gtk-widget-get-pointer
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gtk_widget_get_pointer";
end;

define C-function gtk-widget-is-ancestor
  input parameter widget :: <GtkWidget>;
  input parameter ancestor :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_is_ancestor";
end;

define C-function gtk-widget-translate-coordinates
  input parameter src_widget :: <GtkWidget>;
  input parameter dest_widget :: <GtkWidget>;
  input parameter src_x :: <gint>;
  input parameter src_y :: <gint>;
  input parameter dest_x :: <gint*>;
  input parameter dest_y :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_widget_translate_coordinates";
end;

define C-function gtk-widget-hide-on-delete
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_hide_on_delete";
end;

define C-function gtk-widget-set-style
  input parameter widget :: <GtkWidget>;
  input parameter style :: <GtkStyle>;
  c-name: "gtk_widget_set_style";
end;

define C-function gtk-widget-ensure-style
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_ensure_style";
end;

define C-function gtk-widget-get-style
  input parameter widget :: <GtkWidget>;
  result res :: <GtkStyle>;
  c-name: "gtk_widget_get_style";
end;

define C-function gtk-widget-modify-style
  input parameter widget :: <GtkWidget>;
  input parameter style :: <GtkRcStyle>;
  c-name: "gtk_widget_modify_style";
end;

define C-function gtk-widget-get-modifier-style
  input parameter widget :: <GtkWidget>;
  result res :: <GtkRcStyle>;
  c-name: "gtk_widget_get_modifier_style";
end;

define C-function gtk-widget-modify-fg
  input parameter widget :: <GtkWidget>;
  input parameter state :: <GtkStateType>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_widget_modify_fg";
end;

define C-function gtk-widget-modify-bg
  input parameter widget :: <GtkWidget>;
  input parameter state :: <GtkStateType>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_widget_modify_bg";
end;

define C-function gtk-widget-modify-text
  input parameter widget :: <GtkWidget>;
  input parameter state :: <GtkStateType>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_widget_modify_text";
end;

define C-function gtk-widget-modify-base
  input parameter widget :: <GtkWidget>;
  input parameter state :: <GtkStateType>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_widget_modify_base";
end;

define C-function gtk-widget-modify-font
  input parameter widget :: <GtkWidget>;
  input parameter font_desc :: <PangoFontDescription>;
  c-name: "gtk_widget_modify_font";
end;

define C-subtype <_PangoContext> (<C-void*>) end;
define constant <PangoContext> = <_PangoContext>;

define C-function gtk-widget-create-pango-context
  input parameter widget :: <GtkWidget>;
  result res :: <PangoContext>;
  c-name: "gtk_widget_create_pango_context";
end;

define C-function gtk-widget-get-pango-context
  input parameter widget :: <GtkWidget>;
  result res :: <PangoContext>;
  c-name: "gtk_widget_get_pango_context";
end;

define C-subtype <_PangoLayout> (<C-void*>) end;
define constant <PangoLayout> = <_PangoLayout>;

define C-function gtk-widget-create-pango-layout
  input parameter widget :: <GtkWidget>;
  input parameter text :: <c-string>;
  result res :: <PangoLayout>;
  c-name: "gtk_widget_create_pango_layout";
end;

define constant <GtkIconSize> = limited(<integer>, min: 0, max: 6);
define constant $GTK-ICON-SIZE-INVALID :: <GtkIconSize> = 0;
define constant $GTK-ICON-SIZE-MENU :: <GtkIconSize> = 1;
define constant $GTK-ICON-SIZE-SMALL-TOOLBAR :: <GtkIconSize> = 2;
define constant $GTK-ICON-SIZE-LARGE-TOOLBAR :: <GtkIconSize> = 3;
define constant $GTK-ICON-SIZE-BUTTON :: <GtkIconSize> = 4;
define constant $GTK-ICON-SIZE-DND :: <GtkIconSize> = 5;
define constant $GTK-ICON-SIZE-DIALOG :: <GtkIconSize> = 6;

define C-function gtk-widget-render-icon
  input parameter widget :: <GtkWidget>;
  input parameter stock_id :: <c-string>;
  input parameter size :: <GtkIconSize>;
  input parameter detail :: <c-string>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_widget_render_icon";
end;

define C-function gtk-widget-set-composite-name
  input parameter widget :: <GtkWidget>;
  input parameter name :: <c-string>;
  c-name: "gtk_widget_set_composite_name";
end;

define C-function gtk-widget-get-composite-name
  input parameter widget :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_widget_get_composite_name";
end;

define C-function gtk-widget-reset-rc-styles
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_reset_rc_styles";
end;

define C-function gtk-widget-push-colormap
  input parameter cmap :: <GdkColormap>;
  c-name: "gtk_widget_push_colormap";
end;

define C-function gtk-widget-push-composite-child
  c-name: "gtk_widget_push_composite_child";
end;

define C-function gtk-widget-pop-composite-child
  c-name: "gtk_widget_pop_composite_child";
end;

define C-function gtk-widget-pop-colormap
  c-name: "gtk_widget_pop_colormap";
end;

define C-function gtk-widget-class-install-style-property
  input parameter klass :: <GtkWidgetClass>;
  input parameter pspec :: <GParamSpec>;
  c-name: "gtk_widget_class_install_style_property";
end;

define constant <gsize> = <integer>;

define C-subtype <_GString> (<C-void*>) end;
define constant <GString> = <_GString>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3397>"*/
define constant <GtkRcPropertyParser> = <anonymous-3397>;

define C-function gtk-widget-class-install-style-property-parser
  input parameter klass :: <GtkWidgetClass>;
  input parameter pspec :: <GParamSpec>;
  input parameter parser :: <GtkRcPropertyParser>;
  c-name: "gtk_widget_class_install_style_property_parser";
end;

define C-function gtk-widget-class-find-style-property
  input parameter klass :: <GtkWidgetClass>;
  input parameter property_name :: <c-string>;
  result res :: <GParamSpec>;
  c-name: "gtk_widget_class_find_style_property";
end;

define C-pointer-type <guint*> => <guint>;
define C-function gtk-widget-class-list-style-properties
  input parameter klass :: <GtkWidgetClass>;
  input parameter n_properties :: <guint*>;
  result res :: <GParamSpec*>;
  c-name: "gtk_widget_class_list_style_properties";
end;

define C-function gtk-widget-style-get-property
  input parameter widget :: <GtkWidget>;
  input parameter property_name :: <c-string>;
  input parameter value :: <GValue>;
  c-name: "gtk_widget_style_get_property";
end;

define constant <va-list> = <c-string>;

define C-function gtk-widget-style-get-valist
  input parameter widget :: <GtkWidget>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_widget_style_get_valist";
end;

define C-function gtk-widget-style-get
  input parameter widget :: <GtkWidget>;
  input parameter first_property_name :: <c-string>;
  c-name: "gtk_widget_style_get";
end;

define C-function gtk-widget-set-default-colormap
  input parameter colormap :: <GdkColormap>;
  c-name: "gtk_widget_set_default_colormap";
end;

define C-function gtk-widget-get-default-style
  result res :: <GtkStyle>;
  c-name: "gtk_widget_get_default_style";
end;

define C-function gtk-widget-get-default-colormap
  result res :: <GdkColormap>;
  c-name: "gtk_widget_get_default_colormap";
end;

define C-function gtk-widget-get-default-visual
  result res :: <GdkVisual>;
  c-name: "gtk_widget_get_default_visual";
end;

define C-function gtk-widget-set-direction
  input parameter widget :: <GtkWidget>;
  input parameter dir :: <GtkTextDirection>;
  c-name: "gtk_widget_set_direction";
end;

define C-function gtk-widget-get-direction
  input parameter widget :: <GtkWidget>;
  result res :: <GtkTextDirection>;
  c-name: "gtk_widget_get_direction";
end;

define C-function gtk-widget-set-default-direction
  input parameter dir :: <GtkTextDirection>;
  c-name: "gtk_widget_set_default_direction";
end;

define C-function gtk-widget-get-default-direction
  result res :: <GtkTextDirection>;
  c-name: "gtk_widget_get_default_direction";
end;

define C-function gtk-widget-is-composited
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_widget_is_composited";
end;

define C-function gtk-widget-shape-combine-mask
  input parameter widget :: <GtkWidget>;
  input parameter shape_mask :: <GdkBitmap>;
  input parameter offset_x :: <gint>;
  input parameter offset_y :: <gint>;
  c-name: "gtk_widget_shape_combine_mask";
end;

define C-function gtk-widget-input-shape-combine-mask
  input parameter widget :: <GtkWidget>;
  input parameter shape_mask :: <GdkBitmap>;
  input parameter offset_x :: <gint>;
  input parameter offset_y :: <gint>;
  c-name: "gtk_widget_input_shape_combine_mask";
end;

define C-function gtk-widget-reset-shapes
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_widget_reset_shapes";
end;

define C-function gtk-widget-path
  input parameter widget :: <GtkWidget>;
  input parameter path_length :: <guint*>;
  input parameter path :: <gchar**>;
  input parameter path_reversed :: <gchar**>;
  c-name: "gtk_widget_path";
end;

define C-function gtk-widget-class-path
  input parameter widget :: <GtkWidget>;
  input parameter path_length :: <guint*>;
  input parameter path :: <gchar**>;
  input parameter path_reversed :: <gchar**>;
  c-name: "gtk_widget_class_path";
end;

define C-function gtk-widget-list-mnemonic-labels
  input parameter widget :: <GtkWidget>;
  result res :: <GList>;
  c-name: "gtk_widget_list_mnemonic_labels";
end;

define C-function gtk-widget-add-mnemonic-label
  input parameter widget :: <GtkWidget>;
  input parameter label :: <GtkWidget>;
  c-name: "gtk_widget_add_mnemonic_label";
end;

define C-function gtk-widget-remove-mnemonic-label
  input parameter widget :: <GtkWidget>;
  input parameter label :: <GtkWidget>;
  c-name: "gtk_widget_remove_mnemonic_label";
end;

define C-function gtk-requisition-get-type
  result res :: <GType>;
  c-name: "gtk_requisition_get_type";
end;

define C-function gtk-requisition-copy
  input parameter requisition :: <GtkRequisition>;
  result res :: <GtkRequisition>;
  c-name: "gtk_requisition_copy";
end;

define C-function gtk-requisition-free
  input parameter requisition :: <GtkRequisition>;
  c-name: "gtk_requisition_free";
end;

define C-function _gtk-widget-grab-notify
  input parameter widget :: <GtkWidget>;
  input parameter was_grabbed :: <gboolean>;
  c-name: "_gtk_widget_grab_notify";
end;

define C-function _gtk-widget-get-aux-info
  input parameter widget :: <GtkWidget>;
  input parameter create :: <gboolean>;
  result res :: <GtkWidgetAuxInfo>;
  c-name: "_gtk_widget_get_aux_info";
end;

define C-function _gtk-widget-propagate-hierarchy-changed
  input parameter widget :: <GtkWidget>;
  input parameter previous_toplevel :: <GtkWidget>;
  c-name: "_gtk_widget_propagate_hierarchy_changed";
end;

define C-function _gtk-widget-propagate-screen-changed
  input parameter widget :: <GtkWidget>;
  input parameter previous_screen :: <GdkScreen>;
  c-name: "_gtk_widget_propagate_screen_changed";
end;

define C-function _gtk-widget-propagate-composited-changed
  input parameter widget :: <GtkWidget>;
  c-name: "_gtk_widget_propagate_composited_changed";
end;

define C-function _gtk-widget-peek-colormap
  result res :: <GdkColormap>;
  c-name: "_gtk_widget_peek_colormap";
end;

define C-function atk-role-register
  input parameter name :: <c-string>;
  result res :: <AtkRole>;
  c-name: "atk_role_register";
end;

define constant <AtkAttributeSet> = <GSList>;

define C-subtype <_AtkAttribute> (<C-void*>) end;
define constant <AtkAttribute> = <_AtkAttribute>;

define C-subtype <_AtkImplementor> (<C-void*>) end;
define constant <AtkImplementor> = <_AtkImplementor>;

define C-subtype <_GTypeInterface> (<C-void*>) end;
define constant <GTypeInterface> = <_GTypeInterface>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3603>"*/
define C-subtype <_AtkImplementorIface> (<C-void*>) end;
define constant <AtkImplementorIface> = <_AtkImplementorIface>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3577>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3578>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3579>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3580>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3581>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3582>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3583>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3584>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3585>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3586>"*/
define C-subtype <_AtkStateSet> (<C-void*>) end;
define constant <AtkStateSet> = <_AtkStateSet>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3587>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3588>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3589>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3590>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3591>"*/
define C-subtype <_AtkPropertyValues> (<C-void*>) end;
define constant <AtkPropertyValues> = <_AtkPropertyValues>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3576>"*/
define constant <AtkPropertyChangeHandler> = <anonymous-3576>;

define C-pointer-type <AtkPropertyChangeHandler*> => <AtkPropertyChangeHandler>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3592>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3593>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3594>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3595>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3596>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3597>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3598>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3599>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3600>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3601>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3575>"*/
define constant <AtkFunction> = <anonymous-3575>;

define C-subtype <_AtkObjectClass> (<C-void*>) end;
define constant <AtkObjectClass> = <_AtkObjectClass>;

define C-function atk-object-get-type
  result res :: <GType>;
  c-name: "atk_object_get_type";
end;

define C-function atk-implementor-get-type
  result res :: <GType>;
  c-name: "atk_implementor_get_type";
end;

define C-function atk-implementor-ref-accessible
  input parameter implementor :: <AtkImplementor>;
  result res :: <AtkObject>;
  c-name: "atk_implementor_ref_accessible";
end;

define C-function atk-object-get-name
  input parameter accessible :: <AtkObject>;
  result res :: <c-string>;
  c-name: "atk_object_get_name";
end;

define C-function atk-object-get-description
  input parameter accessible :: <AtkObject>;
  result res :: <c-string>;
  c-name: "atk_object_get_description";
end;

define C-function atk-object-get-parent
  input parameter accessible :: <AtkObject>;
  result res :: <AtkObject>;
  c-name: "atk_object_get_parent";
end;

define C-function atk-object-get-n-accessible-children
  input parameter accessible :: <AtkObject>;
  result res :: <gint>;
  c-name: "atk_object_get_n_accessible_children";
end;

define C-function atk-object-ref-accessible-child
  input parameter accessible :: <AtkObject>;
  input parameter i :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_object_ref_accessible_child";
end;

define C-function atk-object-ref-relation-set
  input parameter accessible :: <AtkObject>;
  result res :: <AtkRelationSet>;
  c-name: "atk_object_ref_relation_set";
end;

define C-function atk-object-get-role
  input parameter accessible :: <AtkObject>;
  result res :: <AtkRole>;
  c-name: "atk_object_get_role";
end;

define C-function atk-object-get-layer
  input parameter accessible :: <AtkObject>;
  result res :: <AtkLayer>;
  c-name: "atk_object_get_layer";
end;

define C-function atk-object-get-mdi-zorder
  input parameter accessible :: <AtkObject>;
  result res :: <gint>;
  c-name: "atk_object_get_mdi_zorder";
end;

define C-function atk-object-get-attributes
  input parameter accessible :: <AtkObject>;
  result res :: <AtkAttributeSet>;
  c-name: "atk_object_get_attributes";
end;

define C-function atk-object-ref-state-set
  input parameter accessible :: <AtkObject>;
  result res :: <AtkStateSet>;
  c-name: "atk_object_ref_state_set";
end;

define C-function atk-object-get-index-in-parent
  input parameter accessible :: <AtkObject>;
  result res :: <gint>;
  c-name: "atk_object_get_index_in_parent";
end;

define C-function atk-object-set-name
  input parameter accessible :: <AtkObject>;
  input parameter name :: <c-string>;
  c-name: "atk_object_set_name";
end;

define C-function atk-object-set-description
  input parameter accessible :: <AtkObject>;
  input parameter description :: <c-string>;
  c-name: "atk_object_set_description";
end;

define C-function atk-object-set-parent
  input parameter accessible :: <AtkObject>;
  input parameter parent :: <AtkObject>;
  c-name: "atk_object_set_parent";
end;

define C-function atk-object-set-role
  input parameter accessible :: <AtkObject>;
  input parameter role :: <AtkRole>;
  c-name: "atk_object_set_role";
end;

define C-function atk-object-connect-property-change-handler
  input parameter accessible :: <AtkObject>;
  input parameter handler :: <AtkPropertyChangeHandler*>;
  result res :: <guint>;
  c-name: "atk_object_connect_property_change_handler";
end;

define C-function atk-object-remove-property-change-handler
  input parameter accessible :: <AtkObject>;
  input parameter handler_id :: <guint>;
  c-name: "atk_object_remove_property_change_handler";
end;

define constant <AtkState> = <guint64>;

define C-function atk-object-notify-state-change
  input parameter accessible :: <AtkObject>;
  input parameter state :: <AtkState>;
  input parameter value :: <gboolean>;
  c-name: "atk_object_notify_state_change";
end;

define C-function atk-object-initialize
  input parameter accessible :: <AtkObject>;
  input parameter data :: <gpointer>;
  c-name: "atk_object_initialize";
end;

define C-function atk-role-get-name
  input parameter role :: <AtkRole>;
  result res :: <c-string>;
  c-name: "atk_role_get_name";
end;

define C-function atk-role-for-name
  input parameter name :: <c-string>;
  result res :: <AtkRole>;
  c-name: "atk_role_for_name";
end;

define constant <AtkRelationType> = limited(<integer>, min: 0, max: 16);
define constant $ATK-RELATION-NULL :: <AtkRelationType> = 0;
define constant $ATK-RELATION-CONTROLLED-BY :: <AtkRelationType> = 1;
define constant $ATK-RELATION-CONTROLLER-FOR :: <AtkRelationType> = 2;
define constant $ATK-RELATION-LABEL-FOR :: <AtkRelationType> = 3;
define constant $ATK-RELATION-LABELLED-BY :: <AtkRelationType> = 4;
define constant $ATK-RELATION-MEMBER-OF :: <AtkRelationType> = 5;
define constant $ATK-RELATION-NODE-CHILD-OF :: <AtkRelationType> = 6;
define constant $ATK-RELATION-FLOWS-TO :: <AtkRelationType> = 7;
define constant $ATK-RELATION-FLOWS-FROM :: <AtkRelationType> = 8;
define constant $ATK-RELATION-SUBWINDOW-OF :: <AtkRelationType> = 9;
define constant $ATK-RELATION-EMBEDS :: <AtkRelationType> = 10;
define constant $ATK-RELATION-EMBEDDED-BY :: <AtkRelationType> = 11;
define constant $ATK-RELATION-POPUP-FOR :: <AtkRelationType> = 12;
define constant $ATK-RELATION-PARENT-WINDOW-OF :: <AtkRelationType> = 13;
define constant $ATK-RELATION-DESCRIBED-BY :: <AtkRelationType> = 14;
define constant $ATK-RELATION-DESCRIPTION-FOR :: <AtkRelationType> = 15;
define constant $ATK-RELATION-LAST-DEFINED :: <AtkRelationType> = 16;

define C-function atk-object-add-relationship
  input parameter object :: <AtkObject>;
  input parameter relationship :: <AtkRelationType>;
  input parameter target :: <AtkObject>;
  result res :: <gboolean>;
  c-name: "atk_object_add_relationship";
end;

define C-function atk-object-remove-relationship
  input parameter object :: <AtkObject>;
  input parameter relationship :: <AtkRelationType>;
  input parameter target :: <AtkObject>;
  result res :: <gboolean>;
  c-name: "atk_object_remove_relationship";
end;

define C-function atk-role-get-localized-name
  input parameter role :: <AtkRole>;
  result res :: <c-string>;
  c-name: "atk_role_get_localized_name";
end;

define constant <AtkStateType> = limited(<integer>, min: 0, max: 39);
define constant $ATK-STATE-INVALID :: <AtkStateType> = 0;
define constant $ATK-STATE-ACTIVE :: <AtkStateType> = 1;
define constant $ATK-STATE-ARMED :: <AtkStateType> = 2;
define constant $ATK-STATE-BUSY :: <AtkStateType> = 3;
define constant $ATK-STATE-CHECKED :: <AtkStateType> = 4;
define constant $ATK-STATE-DEFUNCT :: <AtkStateType> = 5;
define constant $ATK-STATE-EDITABLE :: <AtkStateType> = 6;
define constant $ATK-STATE-ENABLED :: <AtkStateType> = 7;
define constant $ATK-STATE-EXPANDABLE :: <AtkStateType> = 8;
define constant $ATK-STATE-EXPANDED :: <AtkStateType> = 9;
define constant $ATK-STATE-FOCUSABLE :: <AtkStateType> = 10;
define constant $ATK-STATE-FOCUSED :: <AtkStateType> = 11;
define constant $ATK-STATE-HORIZONTAL :: <AtkStateType> = 12;
define constant $ATK-STATE-ICONIFIED :: <AtkStateType> = 13;
define constant $ATK-STATE-MODAL :: <AtkStateType> = 14;
define constant $ATK-STATE-MULTI-LINE :: <AtkStateType> = 15;
define constant $ATK-STATE-MULTISELECTABLE :: <AtkStateType> = 16;
define constant $ATK-STATE-OPAQUE :: <AtkStateType> = 17;
define constant $ATK-STATE-PRESSED :: <AtkStateType> = 18;
define constant $ATK-STATE-RESIZABLE :: <AtkStateType> = 19;
define constant $ATK-STATE-SELECTABLE :: <AtkStateType> = 20;
define constant $ATK-STATE-SELECTED :: <AtkStateType> = 21;
define constant $ATK-STATE-SENSITIVE :: <AtkStateType> = 22;
define constant $ATK-STATE-SHOWING :: <AtkStateType> = 23;
define constant $ATK-STATE-SINGLE-LINE :: <AtkStateType> = 24;
define constant $ATK-STATE-STALE :: <AtkStateType> = 25;
define constant $ATK-STATE-TRANSIENT :: <AtkStateType> = 26;
define constant $ATK-STATE-VERTICAL :: <AtkStateType> = 27;
define constant $ATK-STATE-VISIBLE :: <AtkStateType> = 28;
define constant $ATK-STATE-MANAGES-DESCENDANTS :: <AtkStateType> = 29;
define constant $ATK-STATE-INDETERMINATE :: <AtkStateType> = 30;
define constant $ATK-STATE-TRUNCATED :: <AtkStateType> = 31;
define constant $ATK-STATE-REQUIRED :: <AtkStateType> = 32;
define constant $ATK-STATE-INVALID-ENTRY :: <AtkStateType> = 33;
define constant $ATK-STATE-SUPPORTS-AUTOCOMPLETION :: <AtkStateType> = 34;
define constant $ATK-STATE-SELECTABLE-TEXT :: <AtkStateType> = 35;
define constant $ATK-STATE-DEFAULT :: <AtkStateType> = 36;
define constant $ATK-STATE-ANIMATED :: <AtkStateType> = 37;
define constant $ATK-STATE-VISITED :: <AtkStateType> = 38;
define constant $ATK-STATE-LAST-DEFINED :: <AtkStateType> = 39;

define C-function atk-state-type-register
  input parameter name :: <c-string>;
  result res :: <AtkStateType>;
  c-name: "atk_state_type_register";
end;

define C-function atk-state-type-get-name
  input parameter type :: <AtkStateType>;
  result res :: <c-string>;
  c-name: "atk_state_type_get_name";
end;

define C-function atk-state-type-for-name
  input parameter name :: <c-string>;
  result res :: <AtkStateType>;
  c-name: "atk_state_type_for_name";
end;

define C-function g-value-set-char
  input parameter value :: <GValue>;
  input parameter v_char :: <gchar>;
  c-name: "g_value_set_char";
end;

define C-function g-value-get-char
  input parameter value :: <GValue>;
  result res :: <gchar>;
  c-name: "g_value_get_char";
end;

define C-function g-value-set-uchar
  input parameter value :: <GValue>;
  input parameter v_uchar :: <guchar>;
  c-name: "g_value_set_uchar";
end;

define C-function g-value-get-uchar
  input parameter value :: <GValue>;
  result res :: <guchar>;
  c-name: "g_value_get_uchar";
end;

define C-function g-value-set-boolean
  input parameter value :: <GValue>;
  input parameter v_boolean :: <gboolean>;
  c-name: "g_value_set_boolean";
end;

define C-function g-value-get-boolean
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_value_get_boolean";
end;

define C-function g-value-set-int
  input parameter value :: <GValue>;
  input parameter v_int :: <gint>;
  c-name: "g_value_set_int";
end;

define C-function g-value-get-int
  input parameter value :: <GValue>;
  result res :: <gint>;
  c-name: "g_value_get_int";
end;

define C-function g-value-set-uint
  input parameter value :: <GValue>;
  input parameter v_uint :: <guint>;
  c-name: "g_value_set_uint";
end;

define C-function g-value-get-uint
  input parameter value :: <GValue>;
  result res :: <guint>;
  c-name: "g_value_get_uint";
end;

define C-function g-value-set-long
  input parameter value :: <GValue>;
  input parameter v_long :: <glong>;
  c-name: "g_value_set_long";
end;

define C-function g-value-get-long
  input parameter value :: <GValue>;
  result res :: <glong>;
  c-name: "g_value_get_long";
end;

define C-function g-value-set-ulong
  input parameter value :: <GValue>;
  input parameter v_ulong :: <gulong>;
  c-name: "g_value_set_ulong";
end;

define C-function g-value-get-ulong
  input parameter value :: <GValue>;
  result res :: <gulong>;
  c-name: "g_value_get_ulong";
end;

define C-function g-value-set-int64
  input parameter value :: <GValue>;
  input parameter v_int64 :: <gint64>;
  c-name: "g_value_set_int64";
end;

define C-function g-value-get-int64
  input parameter value :: <GValue>;
  result res :: <gint64>;
  c-name: "g_value_get_int64";
end;

define C-function g-value-set-uint64
  input parameter value :: <GValue>;
  input parameter v_uint64 :: <guint64>;
  c-name: "g_value_set_uint64";
end;

define C-function g-value-get-uint64
  input parameter value :: <GValue>;
  result res :: <guint64>;
  c-name: "g_value_get_uint64";
end;

define C-function g-value-set-float
  input parameter value :: <GValue>;
  input parameter v_float :: <gfloat>;
  c-name: "g_value_set_float";
end;

define C-function g-value-get-float
  input parameter value :: <GValue>;
  result res :: <gfloat>;
  c-name: "g_value_get_float";
end;

define C-function g-value-set-double
  input parameter value :: <GValue>;
  input parameter v_double :: <gdouble>;
  c-name: "g_value_set_double";
end;

define C-function g-value-get-double
  input parameter value :: <GValue>;
  result res :: <gdouble>;
  c-name: "g_value_get_double";
end;

define C-function g-value-set-string
  input parameter value :: <GValue>;
  input parameter v_string :: <c-string>;
  c-name: "g_value_set_string";
end;

define C-function g-value-set-static-string
  input parameter value :: <GValue>;
  input parameter v_string :: <c-string>;
  c-name: "g_value_set_static_string";
end;

define C-function g-value-get-string
  input parameter value :: <GValue>;
  result res :: <c-string>;
  c-name: "g_value_get_string";
end;

define C-function g-value-dup-string
  input parameter value :: <GValue>;
  result res :: <c-string>;
  c-name: "g_value_dup_string";
end;

define C-function g-value-set-pointer
  input parameter value :: <GValue>;
  input parameter v_pointer :: <gpointer>;
  c-name: "g_value_set_pointer";
end;

define C-function g-value-get-pointer
  input parameter value :: <GValue>;
  result res :: <gpointer>;
  c-name: "g_value_get_pointer";
end;

define C-function g-gtype-get-type
  result res :: <GType>;
  c-name: "g_gtype_get_type";
end;

define C-function g-value-set-gtype
  input parameter value :: <GValue>;
  input parameter v_gtype :: <GType>;
  c-name: "g_value_set_gtype";
end;

define C-function g-value-get-gtype
  input parameter value :: <GValue>;
  result res :: <GType>;
  c-name: "g_value_get_gtype";
end;

define C-function g-pointer-type-register-static
  input parameter name :: <c-string>;
  result res :: <GType>;
  c-name: "g_pointer_type_register_static";
end;

define C-function g-strdup-value-contents
  input parameter value :: <GValue>;
  result res :: <c-string>;
  c-name: "g_strdup_value_contents";
end;

define C-function g-value-take-string
  input parameter value :: <GValue>;
  input parameter v_string :: <c-string>;
  c-name: "g_value_take_string";
end;

define C-function g-value-set-string-take-ownership
  input parameter value :: <GValue>;
  input parameter v_string :: <c-string>;
  c-name: "g_value_set_string_take_ownership";
end;

define constant <gchararray> = <c-string>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1506>"*/
define constant <GValueTransform> = <anonymous-1506>;

define C-function g-value-init
  input parameter value :: <GValue>;
  input parameter g_type :: <GType>;
  result res :: <GValue>;
  c-name: "g_value_init";
end;

define C-function g-value-copy
  input parameter src_value :: <GValue>;
  input parameter dest_value :: <GValue>;
  c-name: "g_value_copy";
end;

define C-function g-value-reset
  input parameter value :: <GValue>;
  result res :: <GValue>;
  c-name: "g_value_reset";
end;

define C-function g-value-unset
  input parameter value :: <GValue>;
  c-name: "g_value_unset";
end;

define C-function g-value-set-instance
  input parameter value :: <GValue>;
  input parameter instance :: <gpointer>;
  c-name: "g_value_set_instance";
end;

define C-function g-value-fits-pointer
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_value_fits_pointer";
end;

define C-function g-value-peek-pointer
  input parameter value :: <GValue>;
  result res :: <gpointer>;
  c-name: "g_value_peek_pointer";
end;

define C-function g-value-type-compatible
  input parameter src_type :: <GType>;
  input parameter dest_type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_value_type_compatible";
end;

define C-function g-value-type-transformable
  input parameter src_type :: <GType>;
  input parameter dest_type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_value_type_transformable";
end;

define C-function g-value-transform
  input parameter src_value :: <GValue>;
  input parameter dest_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_value_transform";
end;

define C-function g-value-register-transform-func
  input parameter src_type :: <GType>;
  input parameter dest_type :: <GType>;
  input parameter transform_func :: <GValueTransform>;
  c-name: "g_value_register_transform_func";
end;

define constant $G-VALUE-NOCOPY-CONTENTS = 134217728;

 /* Ignoring declaration for {instance of <union-declaration>} "<_GTypeCValue>"*/
define constant <GTypeCValue> = <_GTypeCValue>;

define C-subtype <_GTypePlugin> (<C-void*>) end;
define constant <GTypePlugin> = <_GTypePlugin>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1415>"*/
define constant <GBaseInitFunc> = <anonymous-1415>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1416>"*/
define constant <GBaseFinalizeFunc> = <anonymous-1416>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1417>"*/
define constant <GClassInitFunc> = <anonymous-1417>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1418>"*/
define constant <GClassFinalizeFunc> = <anonymous-1418>;

define constant <gconstpointer> = <machine-pointer>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1419>"*/
define constant <GInstanceInitFunc> = <anonymous-1419>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1426>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1427>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1428>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1429>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1430>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1431>"*/
define C-subtype <_GTypeValueTable> (<C-void*>) end;
define constant <GTypeValueTable> = <_GTypeValueTable>;

define C-subtype <_GTypeInfo> (<C-void*>) end;
define constant <GTypeInfo> = <_GTypeInfo>;

define constant <GTypeFundamentalFlags> = limited(<integer>, min: 1, max: 8);
define constant $G-TYPE-FLAG-CLASSED :: <GTypeFundamentalFlags> = 1;
define constant $G-TYPE-FLAG-INSTANTIATABLE :: <GTypeFundamentalFlags> = 2;
define constant $G-TYPE-FLAG-DERIVABLE :: <GTypeFundamentalFlags> = 4;
define constant $G-TYPE-FLAG-DEEP-DERIVABLE :: <GTypeFundamentalFlags> = 8;

define C-subtype <_GTypeFundamentalInfo> (<C-void*>) end;
define constant <GTypeFundamentalInfo> = <_GTypeFundamentalInfo>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1420>"*/
define constant <GInterfaceInitFunc> = <anonymous-1420>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1421>"*/
define constant <GInterfaceFinalizeFunc> = <anonymous-1421>;

define C-subtype <_GInterfaceInfo> (<C-void*>) end;
define constant <GInterfaceInfo> = <_GInterfaceInfo>;

define C-subtype <_GTypeQuery> (<C-void*>) end;
define constant <GTypeQuery> = <_GTypeQuery>;

define constant <GTypeDebugFlags> = limited(<integer>, min: 0, max: 3);
define constant $G-TYPE-DEBUG-NONE :: <GTypeDebugFlags> = 0;
define constant $G-TYPE-DEBUG-OBJECTS :: <GTypeDebugFlags> = 1;
define constant $G-TYPE-DEBUG-SIGNALS :: <GTypeDebugFlags> = 2;
define constant $G-TYPE-DEBUG-MASK :: <GTypeDebugFlags> = 3;

define C-function g-type-init
  c-name: "g_type_init";
end;

define C-function g-type-init-with-debug-flags
  input parameter debug_flags :: <GTypeDebugFlags>;
  c-name: "g_type_init_with_debug_flags";
end;

define C-function g-type-name
  input parameter type :: <GType>;
  result res :: <c-string>;
  c-name: "g_type_name";
end;

define C-function g-type-qname
  input parameter type :: <GType>;
  result res :: <GQuark>;
  c-name: "g_type_qname";
end;

define C-function g-type-from-name
  input parameter name :: <c-string>;
  result res :: <GType>;
  c-name: "g_type_from_name";
end;

define C-function g-type-parent
  input parameter type :: <GType>;
  result res :: <GType>;
  c-name: "g_type_parent";
end;

define C-function g-type-depth
  input parameter type :: <GType>;
  result res :: <guint>;
  c-name: "g_type_depth";
end;

define C-function g-type-next-base
  input parameter leaf_type :: <GType>;
  input parameter root_type :: <GType>;
  result res :: <GType>;
  c-name: "g_type_next_base";
end;

define C-function g-type-is-a
  input parameter type :: <GType>;
  input parameter is_a_type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_type_is_a";
end;

define C-function g-type-class-ref
  input parameter type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_class_ref";
end;

define C-function g-type-class-peek
  input parameter type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_class_peek";
end;

define C-function g-type-class-peek-static
  input parameter type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_class_peek_static";
end;

define C-function g-type-class-unref
  input parameter g_class :: <gpointer>;
  c-name: "g_type_class_unref";
end;

define C-function g-type-class-peek-parent
  input parameter g_class :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_type_class_peek_parent";
end;

define C-function g-type-interface-peek
  input parameter instance_class :: <gpointer>;
  input parameter iface_type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_interface_peek";
end;

define C-function g-type-interface-peek-parent
  input parameter g_iface :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_type_interface_peek_parent";
end;

define C-function g-type-default-interface-ref
  input parameter g_type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_default_interface_ref";
end;

define C-function g-type-default-interface-peek
  input parameter g_type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_default_interface_peek";
end;

define C-function g-type-default-interface-unref
  input parameter g_iface :: <gpointer>;
  c-name: "g_type_default_interface_unref";
end;

define C-pointer-type <GType*> => <GType>;
define C-function g-type-children
  input parameter type :: <GType>;
  input parameter n_children :: <guint*>;
  result res :: <GType*>;
  c-name: "g_type_children";
end;

define C-function g-type-interfaces
  input parameter type :: <GType>;
  input parameter n_interfaces :: <guint*>;
  result res :: <GType*>;
  c-name: "g_type_interfaces";
end;

define C-function g-type-set-qdata
  input parameter type :: <GType>;
  input parameter quark :: <GQuark>;
  input parameter data :: <gpointer>;
  c-name: "g_type_set_qdata";
end;

define C-function g-type-get-qdata
  input parameter type :: <GType>;
  input parameter quark :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_type_get_qdata";
end;

define C-function g-type-query
  input parameter type :: <GType>;
  input parameter query :: <GTypeQuery>;
  c-name: "g_type_query";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1422>"*/
define constant <GTypeClassCacheFunc> = <anonymous-1422>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1423>"*/
define constant <GTypeInterfaceCheckFunc> = <anonymous-1423>;

define constant <GTypeFlags> = limited(<integer>, min: 16, max: 32);
define constant $G-TYPE-FLAG-ABSTRACT :: <GTypeFlags> = 16;
define constant $G-TYPE-FLAG-VALUE-ABSTRACT :: <GTypeFlags> = 32;

define C-function g-type-register-static
  input parameter parent_type :: <GType>;
  input parameter type_name :: <c-string>;
  input parameter info :: <GTypeInfo>;
  input parameter flags :: <GTypeFlags>;
  result res :: <GType>;
  c-name: "g_type_register_static";
end;

define C-function g-type-register-static-simple
  input parameter parent_type :: <GType>;
  input parameter type_name :: <c-string>;
  input parameter class_size :: <guint>;
  input parameter class_init :: <GClassInitFunc>;
  input parameter instance_size :: <guint>;
  input parameter instance_init :: <GInstanceInitFunc>;
  input parameter flags :: <GTypeFlags>;
  result res :: <GType>;
  c-name: "g_type_register_static_simple";
end;

define C-function g-type-register-dynamic
  input parameter parent_type :: <GType>;
  input parameter type_name :: <c-string>;
  input parameter plugin :: <GTypePlugin>;
  input parameter flags :: <GTypeFlags>;
  result res :: <GType>;
  c-name: "g_type_register_dynamic";
end;

define C-function g-type-register-fundamental
  input parameter type_id :: <GType>;
  input parameter type_name :: <c-string>;
  input parameter info :: <GTypeInfo>;
  input parameter finfo :: <GTypeFundamentalInfo>;
  input parameter flags :: <GTypeFlags>;
  result res :: <GType>;
  c-name: "g_type_register_fundamental";
end;

define C-function g-type-add-interface-static
  input parameter instance_type :: <GType>;
  input parameter interface_type :: <GType>;
  input parameter info :: <GInterfaceInfo>;
  c-name: "g_type_add_interface_static";
end;

define C-function g-type-add-interface-dynamic
  input parameter instance_type :: <GType>;
  input parameter interface_type :: <GType>;
  input parameter plugin :: <GTypePlugin>;
  c-name: "g_type_add_interface_dynamic";
end;

define C-function g-type-interface-add-prerequisite
  input parameter interface_type :: <GType>;
  input parameter prerequisite_type :: <GType>;
  c-name: "g_type_interface_add_prerequisite";
end;

define C-function g-type-interface-prerequisites
  input parameter interface_type :: <GType>;
  input parameter n_prerequisites :: <guint*>;
  result res :: <GType*>;
  c-name: "g_type_interface_prerequisites";
end;

define C-function g-type-class-add-private
  input parameter g_class :: <gpointer>;
  input parameter private_size :: <gsize>;
  c-name: "g_type_class_add_private";
end;

define C-function g-type-instance-get-private
  input parameter instance :: <GTypeInstance>;
  input parameter private_type :: <GType>;
  result res :: <gpointer>;
  c-name: "g_type_instance_get_private";
end;

define C-function g-type-get-plugin
  input parameter type :: <GType>;
  result res :: <GTypePlugin>;
  c-name: "g_type_get_plugin";
end;

define C-function g-type-interface-get-plugin
  input parameter instance_type :: <GType>;
  input parameter interface_type :: <GType>;
  result res :: <GTypePlugin>;
  c-name: "g_type_interface_get_plugin";
end;

define C-function g-type-fundamental-next
  result res :: <GType>;
  c-name: "g_type_fundamental_next";
end;

define C-function g-type-fundamental
  input parameter type_id :: <GType>;
  result res :: <GType>;
  c-name: "g_type_fundamental";
end;

define C-function g-type-create-instance
  input parameter type :: <GType>;
  result res :: <GTypeInstance>;
  c-name: "g_type_create_instance";
end;

define C-function g-type-free-instance
  input parameter instance :: <GTypeInstance>;
  c-name: "g_type_free_instance";
end;

define C-function g-type-add-class-cache-func
  input parameter cache_data :: <gpointer>;
  input parameter cache_func :: <GTypeClassCacheFunc>;
  c-name: "g_type_add_class_cache_func";
end;

define C-function g-type-remove-class-cache-func
  input parameter cache_data :: <gpointer>;
  input parameter cache_func :: <GTypeClassCacheFunc>;
  c-name: "g_type_remove_class_cache_func";
end;

define C-function g-type-class-unref-uncached
  input parameter g_class :: <gpointer>;
  c-name: "g_type_class_unref_uncached";
end;

define C-function g-type-add-interface-check
  input parameter check_data :: <gpointer>;
  input parameter check_func :: <GTypeInterfaceCheckFunc>;
  c-name: "g_type_add_interface_check";
end;

define C-function g-type-remove-interface-check
  input parameter check_data :: <gpointer>;
  input parameter check_func :: <GTypeInterfaceCheckFunc>;
  c-name: "g_type_remove_interface_check";
end;

define C-function g-type-value-table-peek
  input parameter type :: <GType>;
  result res :: <GTypeValueTable>;
  c-name: "g_type_value_table_peek";
end;

define C-function g-type-check-instance
  input parameter instance :: <GTypeInstance>;
  result res :: <gboolean>;
  c-name: "g_type_check_instance";
end;

define C-function g-type-check-instance-cast
  input parameter instance :: <GTypeInstance>;
  input parameter iface_type :: <GType>;
  result res :: <GTypeInstance>;
  c-name: "g_type_check_instance_cast";
end;

define C-function g-type-check-instance-is-a
  input parameter instance :: <GTypeInstance>;
  input parameter iface_type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_type_check_instance_is_a";
end;

define C-function g-type-check-class-cast
  input parameter g_class :: <GTypeClass>;
  input parameter is_a_type :: <GType>;
  result res :: <GTypeClass>;
  c-name: "g_type_check_class_cast";
end;

define C-function g-type-check-class-is-a
  input parameter g_class :: <GTypeClass>;
  input parameter is_a_type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_type_check_class_is_a";
end;

define C-function g-type-check-is-value-type
  input parameter type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_type_check_is_value_type";
end;

define C-function g-type-check-value
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_type_check_value";
end;

define C-function g-type-check-value-holds
  input parameter value :: <GValue>;
  input parameter type :: <GType>;
  result res :: <gboolean>;
  c-name: "g_type_check_value_holds";
end;

define C-function g-type-test-flags
  input parameter type :: <GType>;
  input parameter flags :: <guint>;
  result res :: <gboolean>;
  c-name: "g_type_test_flags";
end;

define C-function g-type-name-from-instance
  input parameter instance :: <GTypeInstance>;
  result res :: <c-string>;
  c-name: "g_type_name_from_instance";
end;

define C-function g-type-name-from-class
  input parameter g_class :: <GTypeClass>;
  result res :: <c-string>;
  c-name: "g_type_name_from_class";
end;

define C-function g-value-c-init
  c-name: "g_value_c_init";
end;

define C-function g-value-types-init
  c-name: "g_value_types_init";
end;

define C-function g-enum-types-init
  c-name: "g_enum_types_init";
end;

define C-function g-param-type-init
  c-name: "g_param_type_init";
end;

define C-function g-boxed-type-init
  c-name: "g_boxed_type_init";
end;

define C-function g-object-type-init
  c-name: "g_object_type_init";
end;

define C-function g-param-spec-types-init
  c-name: "g_param_spec_types_init";
end;

define C-function g-value-transforms-init
  c-name: "g_value_transforms_init";
end;

define C-function g-signal-init
  c-name: "g_signal_init";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "_g-type-debug-flags"*/
define constant $G-TYPE-FUNDAMENTAL-MAX = 1020;

define constant $G-TYPE-INVALID = 0;

define constant $G-TYPE-NONE = 4;

define constant $G-TYPE-INTERFACE = 8;

define constant $G-TYPE-CHAR = 12;

define constant $G-TYPE-UCHAR = 16;

define constant $G-TYPE-BOOLEAN = 20;

define constant $G-TYPE-INT = 24;

define constant $G-TYPE-UINT = 28;

define constant $G-TYPE-LONG = 32;

define constant $G-TYPE-ULONG = 36;

define constant $G-TYPE-INT64 = 40;

define constant $G-TYPE-UINT64 = 44;

define constant $G-TYPE-ENUM = 48;

define constant $G-TYPE-FLAGS = 52;

define constant $G-TYPE-FLOAT = 56;

define constant $G-TYPE-DOUBLE = 60;

define constant $G-TYPE-STRING = 64;

define constant $G-TYPE-POINTER = 68;

define constant $G-TYPE-BOXED = 72;

define constant $G-TYPE-PARAM = 76;

define constant $G-TYPE-OBJECT = 80;

define constant $G-TYPE-FUNDAMENTAL-SHIFT = 2;

define constant $G-TYPE-RESERVED-GLIB-FIRST = 21;

define constant $G-TYPE-RESERVED-GLIB-LAST = 31;

define constant $G-TYPE-RESERVED-BSE-FIRST = 32;

define constant $G-TYPE-RESERVED-BSE-LAST = 48;

define constant $G-TYPE-RESERVED-USER-FIRST = 49;

define constant $G-TYPE-FLAG-RESERVED-ID-BIT = 1;

define C-function g-win32-ftruncate
  input parameter f :: <gint>;
  input parameter size :: <guint>;
  result res :: <gint>;
  c-name: "g_win32_ftruncate";
end;

define C-function g-win32-getlocale
  result res :: <c-string>;
  c-name: "g_win32_getlocale";
end;

define C-function g-win32-error-message
  input parameter error :: <gint>;
  result res :: <c-string>;
  c-name: "g_win32_error_message";
end;

define C-function g-win32-get-package-installation-directory-utf8
  input parameter package :: <c-string>;
  input parameter dll_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_win32_get_package_installation_directory_utf8";
end;

define C-function g-win32-get-package-installation-subdirectory-utf8
  input parameter package :: <c-string>;
  input parameter dll_name :: <c-string>;
  input parameter subdir :: <c-string>;
  result res :: <c-string>;
  c-name: "g_win32_get_package_installation_subdirectory_utf8";
end;

define C-function g-win32-get-windows-version
  result res :: <guint>;
  c-name: "g_win32_get_windows_version";
end;

define C-function g-win32-locale-filename-from-utf8
  input parameter utf8filename :: <c-string>;
  result res :: <c-string>;
  c-name: "g_win32_locale_filename_from_utf8";
end;

define constant $MAXPATHLEN = 1024;

define constant g-win32-get-package-installation-directory = g-win32-get-package-installation-directory-utf8;

define constant g-win32-get-package-installation-subdirectory = g-win32-get-package-installation-subdirectory-utf8;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-209>"*/
define constant <GCompareFunc> = <anonymous-209>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-210>"*/
define constant <GCompareDataFunc> = <anonymous-210>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-211>"*/
define constant <GEqualFunc> = <anonymous-211>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-212>"*/
define constant <GDestroyNotify> = <anonymous-212>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-213>"*/
define constant <GFunc> = <anonymous-213>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-214>"*/
define constant <GHashFunc> = <anonymous-214>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-215>"*/
define constant <GHFunc> = <anonymous-215>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-216>"*/
define constant <GFreeFunc> = <anonymous-216>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-217>"*/
define constant <GTranslateFunc> = <anonymous-217>;

define C-subtype <anonymous-226> (<C-void*>) end;
 /* Ignoring declaration for {instance of <union-declaration>} "<_GDoubleIEEE754>"*/
define constant <GDoubleIEEE754> = <_GDoubleIEEE754>;

define C-subtype <anonymous-221> (<C-void*>) end;
 /* Ignoring declaration for {instance of <union-declaration>} "<_GFloatIEEE754>"*/
define constant <GFloatIEEE754> = <_GFloatIEEE754>;

define C-subtype <_GTimeVal> (<C-void*>) end;
define constant <GTimeVal> = <_GTimeVal>;

define constant $G-MAXUINT8 = 255;

define constant $G-MAXUINT16 = 65535;

define constant $G-MAXUINT32 = #ex00000000FFFFFFFF;

define constant $G-MAXINT64 = #ex7FFFFFFFFFFFFFFF;

define constant $G-LITTLE-ENDIAN = 1234;

define constant $G-BIG-ENDIAN = 4321;

define constant $G-PDP-ENDIAN = 3412;

define constant $G-IEEE754-FLOAT-BIAS = 127;

define constant $G-IEEE754-DOUBLE-BIAS = 1023;

define constant <gint32> = <integer>;

define constant <gssize> = <integer>;

define C-subtype <_GMutex> (<C-void*>) end;
define constant <GStaticMutex> = <_GMutex>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<char<@4>>"*/
 /* Ignoring declaration for {instance of <union-declaration>} "<_GSystemThread>"*/
define constant <GSystemThread> = <_GSystemThread>;

define constant <GPid> = <machine-pointer>;

define constant $G-MINSHORT = -32768;

define constant $G-MAXSHORT = 32767;

define constant $G-MAXUSHORT = 65535;

define constant $G-MININT = #exFFFFFFFF80000000;

define constant $G-MAXINT = #ex000000007FFFFFFF;

define constant $G-MAXUINT = #ex00000000FFFFFFFF;

define constant $G-MINLONG = #exFFFFFFFF80000000;

define constant $G-MAXLONG = #ex000000007FFFFFFF;

define constant $G-MAXULONG = #ex00000000FFFFFFFF;

define constant $G-GINT16-MODIFIER = "h";

define constant $G-GINT16-FORMAT = "hi";

define constant $G-GUINT16-FORMAT = "hu";

define constant $G-GINT32-MODIFIER = "";

define constant $G-GINT32-FORMAT = "i";

define constant $G-GUINT32-FORMAT = "u";

define constant $G-HAVE-GINT64 = 1;

define constant $G-GINT64-MODIFIER = "I64";

define constant $G-GINT64-FORMAT = "I64i";

define constant $G-GUINT64-FORMAT = "I64u";

define constant $GLIB-SIZEOF-VOID-P = 4;

define constant $GLIB-SIZEOF-LONG = 4;

define constant $GLIB-SIZEOF-SIZE-T = 4;

define constant $G-GSIZE-MODIFIER = "";

define constant $G-GSSIZE-FORMAT = "i";

define constant $G-GSIZE-FORMAT = "u";

define constant $G-MAXSIZE = #ex00000000FFFFFFFF;

define constant $GLIB-MAJOR-VERSION = 2;

define constant $GLIB-MINOR-VERSION = 12;

define constant $GLIB-MICRO-VERSION = 11;

define constant $G-HAVE---INLINE = 1;

define constant $G-HAVE-GROWING-STACK = 0;

define constant $G-MODULE-SUFFIX = "dll";

define C-function _clearfp
  result res :: <integer>;
  c-name: "_clearfp";
end;

define C-function _controlfp
  input parameter  :: <integer>;
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "_controlfp";
end;

define C-function _statusfp
  result res :: <integer>;
  c-name: "_statusfp";
end;

define C-function _fpreset
  c-name: "_fpreset";
end;

define C-function _control87
  input parameter  :: <integer>;
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "_control87";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "_fpecode"*/
define C-function _copysign
  input parameter  :: <double-float>;
  input parameter  :: <double-float>;
  result res :: <double-float>;
  c-name: "_copysign";
end;

define C-function _chgsign
  input parameter  :: <double-float>;
  result res :: <double-float>;
  c-name: "_chgsign";
end;

define C-function _scalb
  input parameter  :: <double-float>;
  input parameter  :: <integer>;
  result res :: <double-float>;
  c-name: "_scalb";
end;

define C-function _logb
  input parameter  :: <double-float>;
  result res :: <double-float>;
  c-name: "_logb";
end;

define C-function _nextafter
  input parameter  :: <double-float>;
  input parameter  :: <double-float>;
  result res :: <double-float>;
  c-name: "_nextafter";
end;

define C-function _finite
  input parameter  :: <double-float>;
  result res :: <integer>;
  c-name: "_finite";
end;

define C-function _isnan
  input parameter  :: <double-float>;
  result res :: <integer>;
  c-name: "_isnan";
end;

define C-function _fpclass
  input parameter  :: <double-float>;
  result res :: <integer>;
  c-name: "_fpclass";
end;

define constant $DBL-DIG = 15;

define constant $DBL-MANT-DIG = 53;

define constant $DBL-MAX-10-EXP = 308;

define constant $DBL-MAX-EXP = 1024;

define constant $DBL-MIN-10-EXP = -307;

define constant $DBL-MIN-EXP = -1021;

define constant $_DBL-RADIX = 2;

define constant $_DBL-ROUNDS = 1;

define constant $FLT-DIG = 6;

define constant $FLT-GUARD = 0;

define constant $FLT-MANT-DIG = 24;

define constant $FLT-MAX-10-EXP = 38;

define constant $FLT-MAX-EXP = 128;

define constant $FLT-MIN-10-EXP = -37;

define constant $FLT-MIN-EXP = -125;

define constant $FLT-NORMALIZE = 0;

define constant $FLT-RADIX = 2;

define constant $FLT-ROUNDS = 1;

define constant $LDBL-DIG = 15;

define constant $LDBL-MANT-DIG = 53;

define constant $LDBL-MAX-10-EXP = 308;

define constant $LDBL-MAX-EXP = 1024;

define constant $LDBL-MIN-10-EXP = -307;

define constant $LDBL-MIN-EXP = -1021;

define constant _clear87 = _clearfp;

define constant _status87 = _statusfp;

define constant $_MCW-EM = 524319;

define constant $_EM-INEXACT = 1;

define constant $_EM-UNDERFLOW = 2;

define constant $_EM-OVERFLOW = 4;

define constant $_EM-ZERODIVIDE = 8;

define constant $_EM-INVALID = 16;

define constant $_MCW-RC = 768;

define constant $_RC-NEAR = 0;

define constant $_RC-DOWN = 256;

define constant $_RC-UP = 512;

define constant $_RC-CHOP = 768;

define constant $_SW-INEXACT = 1;

define constant $_SW-UNDERFLOW = 2;

define constant $_SW-OVERFLOW = 4;

define constant $_SW-ZERODIVIDE = 8;

define constant $_SW-INVALID = 16;

define constant $_MCW-PC = 196608;

define constant $_PC-64 = 0;

define constant $_PC-53 = 65536;

define constant $_PC-24 = 131072;

define constant $_MCW-IC = 262144;

define constant $_IC-AFFINE = 262144;

define constant $_IC-PROJECTIVE = 0;

define constant $_EM-DENORMAL = 524288;

define constant $_SW-DENORMAL = 524288;

define constant $_MCW-DN = 50331648;

define constant $_DN-SAVE = 0;

define constant $_DN-FLUSH = 16777216;

define constant $_DN-FLUSH-OPERANDS-SAVE-RESULTS = 33554432;

define constant $_DN-SAVE-OPERANDS-FLUSH-RESULTS = 50331648;

define constant $_CW-DEFAULT = 589855;

define constant $_SW-UNEMULATED = 64;

define constant $_SW-SQRTNEG = 128;

define constant $_SW-STACKOVERFLOW = 512;

define constant $_SW-STACKUNDERFLOW = 1024;

define constant $_FPE-INVALID = 129;

define constant $_FPE-DENORMAL = 130;

define constant $_FPE-ZERODIVIDE = 131;

define constant $_FPE-OVERFLOW = 132;

define constant $_FPE-UNDERFLOW = 133;

define constant $_FPE-INEXACT = 134;

define constant $_FPE-UNEMULATED = 135;

define constant $_FPE-SQRTNEG = 136;

define constant $_FPE-STACKOVERFLOW = 138;

define constant $_FPE-STACKUNDERFLOW = 139;

define constant $_FPE-EXPLICITGEN = 140;

define constant $_FPCLASS-SNAN = 1;

define constant $_FPCLASS-QNAN = 2;

define constant $_FPCLASS-NINF = 4;

define constant $_FPCLASS-NN = 8;

define constant $_FPCLASS-ND = 16;

define constant $_FPCLASS-NZ = 32;

define constant $_FPCLASS-PZ = 64;

define constant $_FPCLASS-PD = 128;

define constant $_FPCLASS-PN = 256;

define constant $_FPCLASS-PINF = 512;

define constant $CHAR-BIT = 8;

define constant $SCHAR-MIN = -128;

define constant $SCHAR-MAX = 127;

define constant $UCHAR-MAX = 255;

define constant $CHAR-MIN = -128;

define constant $CHAR-MAX = 127;

define constant $MB-LEN-MAX = 2;

define constant $SHRT-MIN = -32768;

define constant $SHRT-MAX = 32767;

define constant $USHRT-MAX = 65535;

define constant $INT-MIN = #exFFFFFFFF80000000;

define constant $INT-MAX = #ex000000007FFFFFFF;

define constant $UINT-MAX = #ex00000000FFFFFFFF;

define constant $LONG-MIN = #exFFFFFFFF80000000;

define constant $LONG-MAX = #ex000000007FFFFFFF;

define constant $ULONG-MAX = #ex00000000FFFFFFFF;

define constant $_POSIX-ARG-MAX = 4096;

define constant $_POSIX-CHILD-MAX = 6;

define constant $_POSIX-LINK-MAX = 8;

define constant $_POSIX-MAX-CANON = 255;

define constant $_POSIX-MAX-INPUT = 255;

define constant $_POSIX-NAME-MAX = 14;

define constant $_POSIX-NGROUPS-MAX = 0;

define constant $_POSIX-OPEN-MAX = 16;

define constant $_POSIX-PATH-MAX = 255;

define constant $_POSIX-PIPE-BUF = 512;

define constant $_POSIX-SSIZE-MAX = 32767;

define constant $_POSIX-STREAM-MAX = 8;

define constant $_POSIX-TZNAME-MAX = 3;

define constant $ARG-MAX = 14500;

define constant $LINK-MAX = 1024;

define constant $MAX-CANON = 255;

define constant $MAX-INPUT = 255;

define constant $NAME-MAX = 255;

define constant $NGROUPS-MAX = 16;

define constant $OPEN-MAX = 32;

define constant $PATH-MAX = 512;

define constant $PIPE-BUF = 512;

define constant $SSIZE-MAX = 32767;

define constant $STREAM-MAX = 20;

define constant $TZNAME-MAX = 10;

define constant $G-GNUC-FUNCTION = "";

define constant $G-GNUC-PRETTY-FUNCTION = "";

define constant $FALSE = 0;

define constant $TRUE = 1;

 /* Ignoring declaration for {instance of <variable-declaration>} "errno"*/
define constant <ptrdiff-t> = <integer>;

define constant <size-t> = <integer>;

define constant <wchar-t> = <integer>;

define C-function g-get-user-name-utf8
  result res :: <c-string>;
  c-name: "g_get_user_name_utf8";
end;

define C-function g-get-real-name-utf8
  result res :: <c-string>;
  c-name: "g_get_real_name_utf8";
end;

define C-function g-get-home-dir-utf8
  result res :: <c-string>;
  c-name: "g_get_home_dir_utf8";
end;

define C-function g-get-tmp-dir-utf8
  result res :: <c-string>;
  c-name: "g_get_tmp_dir_utf8";
end;

define C-function g-get-host-name
  result res :: <c-string>;
  c-name: "g_get_host_name";
end;

define C-function g-get-prgname
  result res :: <c-string>;
  c-name: "g_get_prgname";
end;

define C-function g-set-prgname
  input parameter prgname :: <c-string>;
  c-name: "g_set_prgname";
end;

define C-function g-get-application-name
  result res :: <c-string>;
  c-name: "g_get_application_name";
end;

define C-function g-set-application-name
  input parameter application_name :: <c-string>;
  c-name: "g_set_application_name";
end;

define C-function g-get-user-data-dir
  result res :: <c-string>;
  c-name: "g_get_user_data_dir";
end;

define C-function g-get-user-config-dir
  result res :: <c-string>;
  c-name: "g_get_user_config_dir";
end;

define C-function g-get-user-cache-dir
  result res :: <c-string>;
  c-name: "g_get_user_cache_dir";
end;

define C-function g-get-system-data-dirs
  result res :: <gchar**>;
  c-name: "g_get_system_data_dirs";
end;

define C-function g-win32-get-system-data-dirs-for-module
  input parameter address :: <gconstpointer>;
  result res :: <gchar**>;
  c-name: "g_win32_get_system_data_dirs_for_module";
end;

define C-function g-get-system-config-dirs
  result res :: <gchar**>;
  c-name: "g_get_system_config_dirs";
end;

define C-function g-get-language-names
  result res :: <gchar**>;
  c-name: "g_get_language_names";
end;

define C-subtype <_GDebugKey> (<C-void*>) end;
define constant <GDebugKey> = <_GDebugKey>;

define C-function g-parse-debug-string
  input parameter string :: <c-string>;
  input parameter keys :: <GDebugKey>;
  input parameter nkeys :: <guint>;
  result res :: <guint>;
  c-name: "g_parse_debug_string";
end;

define C-function g-snprintf
  input parameter string :: <c-string>;
  input parameter n :: <gulong>;
  input parameter format :: <c-string>;
  result res :: <gint>;
  c-name: "g_snprintf";
end;

define C-function g-vsnprintf
  input parameter string :: <c-string>;
  input parameter n :: <gulong>;
  input parameter format :: <c-string>;
  input parameter args :: <va-list>;
  result res :: <gint>;
  c-name: "g_vsnprintf";
end;

define C-function g-path-is-absolute
  input parameter file_name :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_path_is_absolute";
end;

define C-function g-path-skip-root
  input parameter file_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_path_skip_root";
end;

define C-function g-basename
  input parameter file_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_basename";
end;

define C-function g-get-current-dir-utf8
  result res :: <c-string>;
  c-name: "g_get_current_dir_utf8";
end;

define C-function g-path-get-basename
  input parameter file_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_path_get_basename";
end;

define C-function g-path-get-dirname
  input parameter file_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_path_get_dirname";
end;

define C-function g-nullify-pointer
  input parameter nullify_location :: <gpointer*>;
  c-name: "g_nullify_pointer";
end;

define C-function g-getenv-utf8
  input parameter variable :: <c-string>;
  result res :: <c-string>;
  c-name: "g_getenv_utf8";
end;

define C-function g-setenv-utf8
  input parameter variable :: <c-string>;
  input parameter value :: <c-string>;
  input parameter overwrite :: <gboolean>;
  result res :: <gboolean>;
  c-name: "g_setenv_utf8";
end;

define C-function g-unsetenv-utf8
  input parameter variable :: <c-string>;
  c-name: "g_unsetenv_utf8";
end;

define C-function g-listenv
  result res :: <gchar**>;
  c-name: "g_listenv";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar<@1024>>"*/
define C-function _g-getenv-nomalloc
  input parameter variable :: <c-string>;
  input parameter buffer :: <gchar<@1024>>;
  result res :: <c-string>;
  c-name: "_g_getenv_nomalloc";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-884>"*/
define constant <GVoidFunc> = <anonymous-884>;

define C-function g-atexit
  input parameter func :: <GVoidFunc>;
  c-name: "g_atexit";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-886>"*/
define C-function atexit
  input parameter  :: <anonymous-886>;
  result res :: <integer>;
  c-name: "atexit";
end;

define C-function g-find-program-in-path-utf8
  input parameter program :: <c-string>;
  result res :: <c-string>;
  c-name: "g_find_program_in_path_utf8";
end;

define C-function g-bit-nth-lsf
  input parameter mask :: <gulong>;
  input parameter nth_bit :: <gint>;
  result res :: <gint>;
  c-name: "g_bit_nth_lsf";
end;

define C-function g-bit-nth-msf
  input parameter mask :: <gulong>;
  input parameter nth_bit :: <gint>;
  result res :: <gint>;
  c-name: "g_bit_nth_msf";
end;

define C-function g-bit-storage
  input parameter number :: <gulong>;
  result res :: <guint>;
  c-name: "g_bit_storage";
end;

define constant <GTrashStack> = <_GTrashStack>;

define C-subtype <_GTrashStack> (<C-void*>) end;
define C-pointer-type <GTrashStack*> => <GTrashStack>;
define C-function g-trash-stack-push
  input parameter stack_p :: <GTrashStack*>;
  input parameter data_p :: <gpointer>;
  c-name: "g_trash_stack_push";
end;

define C-function g-trash-stack-pop
  input parameter stack_p :: <GTrashStack*>;
  result res :: <gpointer>;
  c-name: "g_trash_stack_pop";
end;

define C-function g-trash-stack-peek
  input parameter stack_p :: <GTrashStack*>;
  result res :: <gpointer>;
  c-name: "g_trash_stack_peek";
end;

define C-function g-trash-stack-height
  input parameter stack_p :: <GTrashStack*>;
  result res :: <guint>;
  c-name: "g_trash_stack_height";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "glib-major-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "glib-minor-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "glib-micro-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "glib-interface-age"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "glib-binary-age"*/
define C-function glib-check-version
  input parameter required_major :: <guint>;
  input parameter required_minor :: <guint>;
  input parameter required_micro :: <guint>;
  result res :: <c-string>;
  c-name: "glib_check_version";
end;

define constant $G-DIR-SEPARATOR = 1;

define constant $G-DIR-SEPARATOR-S = "\\";

define constant $G-SEARCHPATH-SEPARATOR = 1;

define constant $G-SEARCHPATH-SEPARATOR-S = ";";

define constant g-get-user-name = g-get-user-name-utf8;

define constant g-get-real-name = g-get-real-name-utf8;

define constant g-get-home-dir = g-get-home-dir-utf8;

define constant g-get-tmp-dir = g-get-tmp-dir-utf8;

define constant g-dirname = g-path-get-dirname;

define constant g-get-current-dir = g-get-current-dir-utf8;

define constant g-getenv = g-getenv-utf8;

define constant g-setenv = g-setenv-utf8;

define constant g-unsetenv = g-unsetenv-utf8;

define constant g-find-program-in-path = g-find-program-in-path-utf8;

define constant <gunichar> = <guint32>;

define constant <gunichar2> = <guint16>;

define constant <GUnicodeType> = limited(<integer>, min: 0, max: 29);
define constant $G-UNICODE-CONTROL :: <GUnicodeType> = 0;
define constant $G-UNICODE-FORMAT :: <GUnicodeType> = 1;
define constant $G-UNICODE-UNASSIGNED :: <GUnicodeType> = 2;
define constant $G-UNICODE-PRIVATE-USE :: <GUnicodeType> = 3;
define constant $G-UNICODE-SURROGATE :: <GUnicodeType> = 4;
define constant $G-UNICODE-LOWERCASE-LETTER :: <GUnicodeType> = 5;
define constant $G-UNICODE-MODIFIER-LETTER :: <GUnicodeType> = 6;
define constant $G-UNICODE-OTHER-LETTER :: <GUnicodeType> = 7;
define constant $G-UNICODE-TITLECASE-LETTER :: <GUnicodeType> = 8;
define constant $G-UNICODE-UPPERCASE-LETTER :: <GUnicodeType> = 9;
define constant $G-UNICODE-COMBINING-MARK :: <GUnicodeType> = 10;
define constant $G-UNICODE-ENCLOSING-MARK :: <GUnicodeType> = 11;
define constant $G-UNICODE-NON-SPACING-MARK :: <GUnicodeType> = 12;
define constant $G-UNICODE-DECIMAL-NUMBER :: <GUnicodeType> = 13;
define constant $G-UNICODE-LETTER-NUMBER :: <GUnicodeType> = 14;
define constant $G-UNICODE-OTHER-NUMBER :: <GUnicodeType> = 15;
define constant $G-UNICODE-CONNECT-PUNCTUATION :: <GUnicodeType> = 16;
define constant $G-UNICODE-DASH-PUNCTUATION :: <GUnicodeType> = 17;
define constant $G-UNICODE-CLOSE-PUNCTUATION :: <GUnicodeType> = 18;
define constant $G-UNICODE-FINAL-PUNCTUATION :: <GUnicodeType> = 19;
define constant $G-UNICODE-INITIAL-PUNCTUATION :: <GUnicodeType> = 20;
define constant $G-UNICODE-OTHER-PUNCTUATION :: <GUnicodeType> = 21;
define constant $G-UNICODE-OPEN-PUNCTUATION :: <GUnicodeType> = 22;
define constant $G-UNICODE-CURRENCY-SYMBOL :: <GUnicodeType> = 23;
define constant $G-UNICODE-MODIFIER-SYMBOL :: <GUnicodeType> = 24;
define constant $G-UNICODE-MATH-SYMBOL :: <GUnicodeType> = 25;
define constant $G-UNICODE-OTHER-SYMBOL :: <GUnicodeType> = 26;
define constant $G-UNICODE-LINE-SEPARATOR :: <GUnicodeType> = 27;
define constant $G-UNICODE-PARAGRAPH-SEPARATOR :: <GUnicodeType> = 28;
define constant $G-UNICODE-SPACE-SEPARATOR :: <GUnicodeType> = 29;

define constant <GUnicodeBreakType> = limited(<integer>, min: 0, max: 35);
define constant $G-UNICODE-BREAK-MANDATORY :: <GUnicodeBreakType> = 0;
define constant $G-UNICODE-BREAK-CARRIAGE-RETURN :: <GUnicodeBreakType> = 1;
define constant $G-UNICODE-BREAK-LINE-FEED :: <GUnicodeBreakType> = 2;
define constant $G-UNICODE-BREAK-COMBINING-MARK :: <GUnicodeBreakType> = 3;
define constant $G-UNICODE-BREAK-SURROGATE :: <GUnicodeBreakType> = 4;
define constant $G-UNICODE-BREAK-ZERO-WIDTH-SPACE :: <GUnicodeBreakType> = 5;
define constant $G-UNICODE-BREAK-INSEPARABLE :: <GUnicodeBreakType> = 6;
define constant $G-UNICODE-BREAK-NON-BREAKING-GLUE :: <GUnicodeBreakType> = 7;
define constant $G-UNICODE-BREAK-CONTINGENT :: <GUnicodeBreakType> = 8;
define constant $G-UNICODE-BREAK-SPACE :: <GUnicodeBreakType> = 9;
define constant $G-UNICODE-BREAK-AFTER :: <GUnicodeBreakType> = 10;
define constant $G-UNICODE-BREAK-BEFORE :: <GUnicodeBreakType> = 11;
define constant $G-UNICODE-BREAK-BEFORE-AND-AFTER :: <GUnicodeBreakType> = 12;
define constant $G-UNICODE-BREAK-HYPHEN :: <GUnicodeBreakType> = 13;
define constant $G-UNICODE-BREAK-NON-STARTER :: <GUnicodeBreakType> = 14;
define constant $G-UNICODE-BREAK-OPEN-PUNCTUATION :: <GUnicodeBreakType> = 15;
define constant $G-UNICODE-BREAK-CLOSE-PUNCTUATION :: <GUnicodeBreakType> = 16;
define constant $G-UNICODE-BREAK-QUOTATION :: <GUnicodeBreakType> = 17;
define constant $G-UNICODE-BREAK-EXCLAMATION :: <GUnicodeBreakType> = 18;
define constant $G-UNICODE-BREAK-IDEOGRAPHIC :: <GUnicodeBreakType> = 19;
define constant $G-UNICODE-BREAK-NUMERIC :: <GUnicodeBreakType> = 20;
define constant $G-UNICODE-BREAK-INFIX-SEPARATOR :: <GUnicodeBreakType> = 21;
define constant $G-UNICODE-BREAK-SYMBOL :: <GUnicodeBreakType> = 22;
define constant $G-UNICODE-BREAK-ALPHABETIC :: <GUnicodeBreakType> = 23;
define constant $G-UNICODE-BREAK-PREFIX :: <GUnicodeBreakType> = 24;
define constant $G-UNICODE-BREAK-POSTFIX :: <GUnicodeBreakType> = 25;
define constant $G-UNICODE-BREAK-COMPLEX-CONTEXT :: <GUnicodeBreakType> = 26;
define constant $G-UNICODE-BREAK-AMBIGUOUS :: <GUnicodeBreakType> = 27;
define constant $G-UNICODE-BREAK-UNKNOWN :: <GUnicodeBreakType> = 28;
define constant $G-UNICODE-BREAK-NEXT-LINE :: <GUnicodeBreakType> = 29;
define constant $G-UNICODE-BREAK-WORD-JOINER :: <GUnicodeBreakType> = 30;
define constant $G-UNICODE-BREAK-HANGUL-L-JAMO :: <GUnicodeBreakType> = 31;
define constant $G-UNICODE-BREAK-HANGUL-V-JAMO :: <GUnicodeBreakType> = 32;
define constant $G-UNICODE-BREAK-HANGUL-T-JAMO :: <GUnicodeBreakType> = 33;
define constant $G-UNICODE-BREAK-HANGUL-LV-SYLLABLE :: <GUnicodeBreakType> = 34;
define constant $G-UNICODE-BREAK-HANGUL-LVT-SYLLABLE :: <GUnicodeBreakType> = 35;

define C-pointer-type <c-string-vector> => <c-string>;
define C-function g-get-charset
  input parameter charset :: <c-string-vector>;
  result res :: <gboolean>;
  c-name: "g_get_charset";
end;

define C-function g-unichar-isalnum
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isalnum";
end;

define C-function g-unichar-isalpha
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isalpha";
end;

define C-function g-unichar-iscntrl
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_iscntrl";
end;

define C-function g-unichar-isdigit
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isdigit";
end;

define C-function g-unichar-isgraph
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isgraph";
end;

define C-function g-unichar-islower
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_islower";
end;

define C-function g-unichar-isprint
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isprint";
end;

define C-function g-unichar-ispunct
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_ispunct";
end;

define C-function g-unichar-isspace
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isspace";
end;

define C-function g-unichar-isupper
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isupper";
end;

define C-function g-unichar-isxdigit
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isxdigit";
end;

define C-function g-unichar-istitle
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_istitle";
end;

define C-function g-unichar-isdefined
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_isdefined";
end;

define C-function g-unichar-iswide
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_iswide";
end;

define C-function g-unichar-iswide-cjk
  input parameter c :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_iswide_cjk";
end;

define C-function g-unichar-toupper
  input parameter c :: <gunichar>;
  result res :: <gunichar>;
  c-name: "g_unichar_toupper";
end;

define C-function g-unichar-tolower
  input parameter c :: <gunichar>;
  result res :: <gunichar>;
  c-name: "g_unichar_tolower";
end;

define C-function g-unichar-totitle
  input parameter c :: <gunichar>;
  result res :: <gunichar>;
  c-name: "g_unichar_totitle";
end;

define C-function g-unichar-digit-value
  input parameter c :: <gunichar>;
  result res :: <gint>;
  c-name: "g_unichar_digit_value";
end;

define C-function g-unichar-xdigit-value
  input parameter c :: <gunichar>;
  result res :: <gint>;
  c-name: "g_unichar_xdigit_value";
end;

define C-function g-unichar-type
  input parameter c :: <gunichar>;
  result res :: <GUnicodeType>;
  c-name: "g_unichar_type";
end;

define C-function g-unichar-break-type
  input parameter c :: <gunichar>;
  result res :: <GUnicodeBreakType>;
  c-name: "g_unichar_break_type";
end;

define C-pointer-type <gunichar*> => <gunichar>;
define C-function g-unicode-canonical-ordering
  input parameter string :: <gunichar*>;
  input parameter len :: <gsize>;
  c-name: "g_unicode_canonical_ordering";
end;

define C-pointer-type <gsize*> => <gsize>;
define C-function g-unicode-canonical-decomposition
  input parameter ch :: <gunichar>;
  input parameter result_len :: <gsize*>;
  result res :: <gunichar*>;
  c-name: "g_unicode_canonical_decomposition";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-utf8-skip"*/
define C-function g-utf8-get-char
  input parameter p :: <c-string>;
  result res :: <gunichar>;
  c-name: "g_utf8_get_char";
end;

define C-function g-utf8-get-char-validated
  input parameter p :: <c-string>;
  input parameter max_len :: <gssize>;
  result res :: <gunichar>;
  c-name: "g_utf8_get_char_validated";
end;

define C-function g-utf8-offset-to-pointer
  input parameter str :: <c-string>;
  input parameter offset :: <glong>;
  result res :: <c-string>;
  c-name: "g_utf8_offset_to_pointer";
end;

define C-function g-utf8-pointer-to-offset
  input parameter str :: <c-string>;
  input parameter pos :: <c-string>;
  result res :: <glong>;
  c-name: "g_utf8_pointer_to_offset";
end;

define C-function g-utf8-prev-char
  input parameter p :: <c-string>;
  result res :: <c-string>;
  c-name: "g_utf8_prev_char";
end;

define C-function g-utf8-find-next-char
  input parameter p :: <c-string>;
  input parameter end :: <c-string>;
  result res :: <c-string>;
  c-name: "g_utf8_find_next_char";
end;

define C-function g-utf8-find-prev-char
  input parameter str :: <c-string>;
  input parameter p :: <c-string>;
  result res :: <c-string>;
  c-name: "g_utf8_find_prev_char";
end;

define C-function g-utf8-strlen
  input parameter p :: <c-string>;
  input parameter max :: <gssize>;
  result res :: <glong>;
  c-name: "g_utf8_strlen";
end;

define C-function g-utf8-strncpy
  input parameter dest :: <c-string>;
  input parameter src :: <c-string>;
  input parameter n :: <gsize>;
  result res :: <c-string>;
  c-name: "g_utf8_strncpy";
end;

define C-function g-utf8-strchr
  input parameter p :: <c-string>;
  input parameter len :: <gssize>;
  input parameter c :: <gunichar>;
  result res :: <c-string>;
  c-name: "g_utf8_strchr";
end;

define C-function g-utf8-strrchr
  input parameter p :: <c-string>;
  input parameter len :: <gssize>;
  input parameter c :: <gunichar>;
  result res :: <c-string>;
  c-name: "g_utf8_strrchr";
end;

define C-function g-utf8-strreverse
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_strreverse";
end;

define C-pointer-type <gunichar2*> => <gunichar2>;
define C-pointer-type <glong*> => <glong>;
define C-function g-utf8-to-utf16
  input parameter str :: <c-string>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <gunichar2*>;
  c-name: "g_utf8_to_utf16";
end;

define C-function g-utf8-to-ucs4
  input parameter str :: <c-string>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <gunichar*>;
  c-name: "g_utf8_to_ucs4";
end;

define C-function g-utf8-to-ucs4-fast
  input parameter str :: <c-string>;
  input parameter len :: <glong>;
  input parameter items_written :: <glong*>;
  result res :: <gunichar*>;
  c-name: "g_utf8_to_ucs4_fast";
end;

define C-function g-utf16-to-ucs4
  input parameter str :: <gunichar2*>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <gunichar*>;
  c-name: "g_utf16_to_ucs4";
end;

define C-function g-utf16-to-utf8
  input parameter str :: <gunichar2*>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_utf16_to_utf8";
end;

define C-function g-ucs4-to-utf16
  input parameter str :: <gunichar*>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <gunichar2*>;
  c-name: "g_ucs4_to_utf16";
end;

define C-function g-ucs4-to-utf8
  input parameter str :: <gunichar*>;
  input parameter len :: <glong>;
  input parameter items_read :: <glong*>;
  input parameter items_written :: <glong*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_ucs4_to_utf8";
end;

define C-function g-unichar-to-utf8
  input parameter c :: <gunichar>;
  input parameter outbuf :: <c-string>;
  result res :: <gint>;
  c-name: "g_unichar_to_utf8";
end;

define C-function g-utf8-validate
  input parameter str :: <c-string>;
  input parameter max_len :: <gssize>;
  input parameter end :: <gchar**>;
  result res :: <gboolean>;
  c-name: "g_utf8_validate";
end;

define C-function g-unichar-validate
  input parameter ch :: <gunichar>;
  result res :: <gboolean>;
  c-name: "g_unichar_validate";
end;

define C-function g-utf8-strup
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_strup";
end;

define C-function g-utf8-strdown
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_strdown";
end;

define C-function g-utf8-casefold
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_casefold";
end;

define constant <GNormalizeMode> = limited(<integer>, min: 0, max: 3);
define constant $G-NORMALIZE-DEFAULT :: <GNormalizeMode> = 0;
define constant $G-NORMALIZE-NFD :: <GNormalizeMode> = 0;
define constant $G-NORMALIZE-DEFAULT-COMPOSE :: <GNormalizeMode> = 1;
define constant $G-NORMALIZE-NFC :: <GNormalizeMode> = 1;
define constant $G-NORMALIZE-ALL :: <GNormalizeMode> = 2;
define constant $G-NORMALIZE-NFKD :: <GNormalizeMode> = 2;
define constant $G-NORMALIZE-ALL-COMPOSE :: <GNormalizeMode> = 3;
define constant $G-NORMALIZE-NFKC :: <GNormalizeMode> = 3;

define C-function g-utf8-normalize
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  input parameter mode :: <GNormalizeMode>;
  result res :: <c-string>;
  c-name: "g_utf8_normalize";
end;

define C-function g-utf8-collate
  input parameter str1 :: <c-string>;
  input parameter str2 :: <c-string>;
  result res :: <gint>;
  c-name: "g_utf8_collate";
end;

define C-function g-utf8-collate-key
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_collate_key";
end;

define C-function g-utf8-collate-key-for-filename
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_utf8_collate_key_for_filename";
end;

define C-function g-unichar-get-mirror-char
  input parameter ch :: <gunichar>;
  input parameter mirrored_ch :: <gunichar*>;
  result res :: <gboolean>;
  c-name: "g_unichar_get_mirror_char";
end;

define C-function _g-utf8-make-valid
  input parameter name :: <c-string>;
  result res :: <c-string>;
  c-name: "_g_utf8_make_valid";
end;

define C-function g-error-new
  input parameter domain :: <GQuark>;
  input parameter code :: <gint>;
  input parameter format :: <c-string>;
  result res :: <GError>;
  c-name: "g_error_new";
end;

define C-function g-error-new-literal
  input parameter domain :: <GQuark>;
  input parameter code :: <gint>;
  input parameter message :: <c-string>;
  result res :: <GError>;
  c-name: "g_error_new_literal";
end;

define C-function g-error-free
  input parameter error :: <GError>;
  c-name: "g_error_free";
end;

define C-function g-error-copy
  input parameter error :: <GError>;
  result res :: <GError>;
  c-name: "g_error_copy";
end;

define C-function g-error-matches
  input parameter error :: <GError>;
  input parameter domain :: <GQuark>;
  input parameter code :: <gint>;
  result res :: <gboolean>;
  c-name: "g_error_matches";
end;

define C-function g-set-error
  input parameter err :: <GError*>;
  input parameter domain :: <GQuark>;
  input parameter code :: <gint>;
  input parameter format :: <c-string>;
  c-name: "g_set_error";
end;

define C-function g-propagate-error
  input parameter dest :: <GError*>;
  input parameter src :: <GError>;
  c-name: "g_propagate_error";
end;

define C-function g-clear-error
  input parameter err :: <GError*>;
  c-name: "g_clear_error";
end;

define C-function g-quark-try-string
  input parameter string :: <c-string>;
  result res :: <GQuark>;
  c-name: "g_quark_try_string";
end;

define C-function g-quark-from-static-string
  input parameter string :: <c-string>;
  result res :: <GQuark>;
  c-name: "g_quark_from_static_string";
end;

define C-function g-quark-from-string
  input parameter string :: <c-string>;
  result res :: <GQuark>;
  c-name: "g_quark_from_string";
end;

define C-function g-quark-to-string
  input parameter quark :: <GQuark>;
  result res :: <c-string>;
  c-name: "g_quark_to_string";
end;

define C-function g-intern-string
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_intern_string";
end;

define C-function g-intern-static-string
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_intern_static_string";
end;

define C-subtype <_GTree> (<C-void*>) end;
define constant <GTree> = <_GTree>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1357>"*/
define constant <GTraverseFunc> = <anonymous-1357>;

define C-function g-tree-new
  input parameter key_compare_func :: <GCompareFunc>;
  result res :: <GTree>;
  c-name: "g_tree_new";
end;

define C-function g-tree-new-with-data
  input parameter key_compare_func :: <GCompareDataFunc>;
  input parameter key_compare_data :: <gpointer>;
  result res :: <GTree>;
  c-name: "g_tree_new_with_data";
end;

define C-function g-tree-new-full
  input parameter key_compare_func :: <GCompareDataFunc>;
  input parameter key_compare_data :: <gpointer>;
  input parameter key_destroy_func :: <GDestroyNotify>;
  input parameter value_destroy_func :: <GDestroyNotify>;
  result res :: <GTree>;
  c-name: "g_tree_new_full";
end;

define C-function g-tree-destroy
  input parameter tree :: <GTree>;
  c-name: "g_tree_destroy";
end;

define C-function g-tree-insert
  input parameter tree :: <GTree>;
  input parameter key :: <gpointer>;
  input parameter value :: <gpointer>;
  c-name: "g_tree_insert";
end;

define C-function g-tree-replace
  input parameter tree :: <GTree>;
  input parameter key :: <gpointer>;
  input parameter value :: <gpointer>;
  c-name: "g_tree_replace";
end;

define C-function g-tree-remove
  input parameter tree :: <GTree>;
  input parameter key :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_tree_remove";
end;

define C-function g-tree-steal
  input parameter tree :: <GTree>;
  input parameter key :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_tree_steal";
end;

define C-function g-tree-lookup
  input parameter tree :: <GTree>;
  input parameter key :: <gconstpointer>;
  result res :: <gpointer>;
  c-name: "g_tree_lookup";
end;

define C-function g-tree-lookup-extended
  input parameter tree :: <GTree>;
  input parameter lookup_key :: <gconstpointer>;
  input parameter orig_key :: <gpointer*>;
  input parameter value :: <gpointer*>;
  result res :: <gboolean>;
  c-name: "g_tree_lookup_extended";
end;

define C-function g-tree-foreach
  input parameter tree :: <GTree>;
  input parameter func :: <GTraverseFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_tree_foreach";
end;

define constant <GTraverseType> = limited(<integer>, min: 0, max: 3);
define constant $G-IN-ORDER :: <GTraverseType> = 0;
define constant $G-PRE-ORDER :: <GTraverseType> = 1;
define constant $G-POST-ORDER :: <GTraverseType> = 2;
define constant $G-LEVEL-ORDER :: <GTraverseType> = 3;

define C-function g-tree-traverse
  input parameter tree :: <GTree>;
  input parameter traverse_func :: <GTraverseFunc>;
  input parameter traverse_type :: <GTraverseType>;
  input parameter user_data :: <gpointer>;
  c-name: "g_tree_traverse";
end;

define C-function g-tree-search
  input parameter tree :: <GTree>;
  input parameter search_func :: <GCompareFunc>;
  input parameter user_data :: <gconstpointer>;
  result res :: <gpointer>;
  c-name: "g_tree_search";
end;

define C-function g-tree-height
  input parameter tree :: <GTree>;
  result res :: <gint>;
  c-name: "g_tree_height";
end;

define C-function g-tree-nnodes
  input parameter tree :: <GTree>;
  result res :: <gint>;
  c-name: "g_tree_nnodes";
end;

define constant <GNode> = <_GNode>;

define C-subtype <_GNode> (<C-void*>) end;
define constant <GTraverseFlags> = limited(<integer>, min: 1, max: 3);
define constant $G-TRAVERSE-LEAVES :: <GTraverseFlags> = 1;
define constant $G-TRAVERSE-NON-LEAVES :: <GTraverseFlags> = 2;
define constant $G-TRAVERSE-ALL :: <GTraverseFlags> = 3;
define constant $G-TRAVERSE-MASK :: <GTraverseFlags> = 3;
define constant $G-TRAVERSE-LEAFS :: <GTraverseFlags> = 1;
define constant $G-TRAVERSE-NON-LEAFS :: <GTraverseFlags> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1084>"*/
define constant <GNodeTraverseFunc> = <anonymous-1084>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1085>"*/
define constant <GNodeForeachFunc> = <anonymous-1085>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1086>"*/
define constant <GCopyFunc> = <anonymous-1086>;

define C-function g-node-new
  input parameter data :: <gpointer>;
  result res :: <GNode>;
  c-name: "g_node_new";
end;

define C-function g-node-destroy
  input parameter root :: <GNode>;
  c-name: "g_node_destroy";
end;

define C-function g-node-unlink
  input parameter node :: <GNode>;
  c-name: "g_node_unlink";
end;

define C-function g-node-copy-deep
  input parameter node :: <GNode>;
  input parameter copy_func :: <GCopyFunc>;
  input parameter data :: <gpointer>;
  result res :: <GNode>;
  c-name: "g_node_copy_deep";
end;

define C-function g-node-copy
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_copy";
end;

define C-function g-node-insert
  input parameter parent :: <GNode>;
  input parameter position :: <gint>;
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_insert";
end;

define C-function g-node-insert-before
  input parameter parent :: <GNode>;
  input parameter sibling :: <GNode>;
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_insert_before";
end;

define C-function g-node-insert-after
  input parameter parent :: <GNode>;
  input parameter sibling :: <GNode>;
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_insert_after";
end;

define C-function g-node-prepend
  input parameter parent :: <GNode>;
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_prepend";
end;

define C-function g-node-n-nodes
  input parameter root :: <GNode>;
  input parameter flags :: <GTraverseFlags>;
  result res :: <guint>;
  c-name: "g_node_n_nodes";
end;

define C-function g-node-get-root
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_get_root";
end;

define C-function g-node-is-ancestor
  input parameter node :: <GNode>;
  input parameter descendant :: <GNode>;
  result res :: <gboolean>;
  c-name: "g_node_is_ancestor";
end;

define C-function g-node-depth
  input parameter node :: <GNode>;
  result res :: <guint>;
  c-name: "g_node_depth";
end;

define C-function g-node-find
  input parameter root :: <GNode>;
  input parameter order :: <GTraverseType>;
  input parameter flags :: <GTraverseFlags>;
  input parameter data :: <gpointer>;
  result res :: <GNode>;
  c-name: "g_node_find";
end;

define C-function g-node-traverse
  input parameter root :: <GNode>;
  input parameter order :: <GTraverseType>;
  input parameter flags :: <GTraverseFlags>;
  input parameter max_depth :: <gint>;
  input parameter func :: <GNodeTraverseFunc>;
  input parameter data :: <gpointer>;
  c-name: "g_node_traverse";
end;

define C-function g-node-max-height
  input parameter root :: <GNode>;
  result res :: <guint>;
  c-name: "g_node_max_height";
end;

define C-function g-node-children-foreach
  input parameter node :: <GNode>;
  input parameter flags :: <GTraverseFlags>;
  input parameter func :: <GNodeForeachFunc>;
  input parameter data :: <gpointer>;
  c-name: "g_node_children_foreach";
end;

define C-function g-node-reverse-children
  input parameter node :: <GNode>;
  c-name: "g_node_reverse_children";
end;

define C-function g-node-n-children
  input parameter node :: <GNode>;
  result res :: <guint>;
  c-name: "g_node_n_children";
end;

define C-function g-node-nth-child
  input parameter node :: <GNode>;
  input parameter n :: <guint>;
  result res :: <GNode>;
  c-name: "g_node_nth_child";
end;

define C-function g-node-last-child
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_last_child";
end;

define C-function g-node-find-child
  input parameter node :: <GNode>;
  input parameter flags :: <GTraverseFlags>;
  input parameter data :: <gpointer>;
  result res :: <GNode>;
  c-name: "g_node_find_child";
end;

define C-function g-node-child-position
  input parameter node :: <GNode>;
  input parameter child :: <GNode>;
  result res :: <gint>;
  c-name: "g_node_child_position";
end;

define C-function g-node-child-index
  input parameter node :: <GNode>;
  input parameter data :: <gpointer>;
  result res :: <gint>;
  c-name: "g_node_child_index";
end;

define C-function g-node-first-sibling
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_first_sibling";
end;

define C-function g-node-last-sibling
  input parameter node :: <GNode>;
  result res :: <GNode>;
  c-name: "g_node_last_sibling";
end;

define C-function g-node-push-allocator
  input parameter dummy :: <gpointer>;
  c-name: "g_node_push_allocator";
end;

define C-function g-node-pop-allocator
  c-name: "g_node_pop_allocator";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-453>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-454>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-455>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-456>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-457>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-458>"*/
define C-subtype <_GMemVTable> (<C-void*>) end;
define constant <GMemVTable> = <_GMemVTable>;

define C-function g-malloc
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_malloc";
end;

define C-function g-malloc0
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_malloc0";
end;

define C-function g-realloc
  input parameter mem :: <gpointer>;
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_realloc";
end;

define C-function g-free
  input parameter mem :: <gpointer>;
  c-name: "g_free";
end;

define C-function g-try-malloc
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_try_malloc";
end;

define C-function g-try-malloc0
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_try_malloc0";
end;

define C-function g-try-realloc
  input parameter mem :: <gpointer>;
  input parameter n_bytes :: <gulong>;
  result res :: <gpointer>;
  c-name: "g_try_realloc";
end;

define C-function g-mem-set-vtable
  input parameter vtable :: <GMemVTable>;
  c-name: "g_mem_set_vtable";
end;

define C-function g-mem-is-system-malloc
  result res :: <gboolean>;
  c-name: "g_mem_is_system_malloc";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-mem-gc-friendly"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "glib-mem-profiler-table"*/
define C-function g-mem-profile
  c-name: "g_mem_profile";
end;

define C-subtype <_GAllocator> (<C-void*>) end;
define constant <GAllocator> = <_GAllocator>;

define C-subtype <_GMemChunk> (<C-void*>) end;
define constant <GMemChunk> = <_GMemChunk>;

define C-function g-mem-chunk-new
  input parameter name :: <c-string>;
  input parameter atom_size :: <gint>;
  input parameter area_size :: <gulong>;
  input parameter type :: <gint>;
  result res :: <GMemChunk>;
  c-name: "g_mem_chunk_new";
end;

define C-function g-mem-chunk-destroy
  input parameter mem_chunk :: <GMemChunk>;
  c-name: "g_mem_chunk_destroy";
end;

define C-function g-mem-chunk-alloc
  input parameter mem_chunk :: <GMemChunk>;
  result res :: <gpointer>;
  c-name: "g_mem_chunk_alloc";
end;

define C-function g-mem-chunk-alloc0
  input parameter mem_chunk :: <GMemChunk>;
  result res :: <gpointer>;
  c-name: "g_mem_chunk_alloc0";
end;

define C-function g-mem-chunk-free
  input parameter mem_chunk :: <GMemChunk>;
  input parameter mem :: <gpointer>;
  c-name: "g_mem_chunk_free";
end;

define C-function g-mem-chunk-clean
  input parameter mem_chunk :: <GMemChunk>;
  c-name: "g_mem_chunk_clean";
end;

define C-function g-mem-chunk-reset
  input parameter mem_chunk :: <GMemChunk>;
  c-name: "g_mem_chunk_reset";
end;

define C-function g-mem-chunk-print
  input parameter mem_chunk :: <GMemChunk>;
  c-name: "g_mem_chunk_print";
end;

define C-function g-mem-chunk-info
  c-name: "g_mem_chunk_info";
end;

define C-function g-blow-chunks
  c-name: "g_blow_chunks";
end;

define C-function g-allocator-new
  input parameter name :: <c-string>;
  input parameter n_preallocs :: <guint>;
  result res :: <GAllocator>;
  c-name: "g_allocator_new";
end;

define C-function g-allocator-free
  input parameter allocator :: <GAllocator>;
  c-name: "g_allocator_free";
end;

define constant $G-MEM-ALIGN = 4;

define constant $G-ALLOC-ONLY = 1;

define constant $G-ALLOC-AND-FREE = 2;

define constant $G-ALLOCATOR-LIST = 1;

define constant $G-ALLOCATOR-SLIST = 2;

define constant $G-ALLOCATOR-NODE = 3;

define C-function g-slice-alloc
  input parameter block_size :: <gsize>;
  result res :: <gpointer>;
  c-name: "g_slice_alloc";
end;

define C-function g-slice-alloc0
  input parameter block_size :: <gsize>;
  result res :: <gpointer>;
  c-name: "g_slice_alloc0";
end;

define C-function g-slice-free1
  input parameter block_size :: <gsize>;
  input parameter mem_block :: <gpointer>;
  c-name: "g_slice_free1";
end;

define C-function g-slice-free-chain-with-offset
  input parameter block_size :: <gsize>;
  input parameter mem_chain :: <gpointer>;
  input parameter next_offset :: <gsize>;
  c-name: "g_slice_free_chain_with_offset";
end;

define constant <GSliceConfig> = limited(<integer>, min: 1, max: 6);
define constant $G-SLICE-CONFIG-ALWAYS-MALLOC :: <GSliceConfig> = 1;
define constant $G-SLICE-CONFIG-BYPASS-MAGAZINES :: <GSliceConfig> = 2;
define constant $G-SLICE-CONFIG-WORKING-SET-MSECS :: <GSliceConfig> = 3;
define constant $G-SLICE-CONFIG-COLOR-INCREMENT :: <GSliceConfig> = 4;
define constant $G-SLICE-CONFIG-CHUNK-SIZES :: <GSliceConfig> = 5;
define constant $G-SLICE-CONFIG-CONTENTION-COUNTER :: <GSliceConfig> = 6;

define C-function g-slice-set-config
  input parameter ckey :: <GSliceConfig>;
  input parameter value :: <gint64>;
  c-name: "g_slice_set_config";
end;

define C-function g-slice-get-config
  input parameter ckey :: <GSliceConfig>;
  result res :: <gint64>;
  c-name: "g_slice_get_config";
end;

define C-pointer-type <gint64*> => <gint64>;
define C-function g-slice-get-config-state
  input parameter ckey :: <GSliceConfig>;
  input parameter address :: <gint64>;
  input parameter n_values :: <guint*>;
  result res :: <gint64*>;
  c-name: "g_slice_get_config_state";
end;

define C-subtype <_GTimer> (<C-void*>) end;
define constant <GTimer> = <_GTimer>;

define C-function g-timer-new
  result res :: <GTimer>;
  c-name: "g_timer_new";
end;

define C-function g-timer-destroy
  input parameter timer :: <GTimer>;
  c-name: "g_timer_destroy";
end;

define C-function g-timer-start
  input parameter timer :: <GTimer>;
  c-name: "g_timer_start";
end;

define C-function g-timer-stop
  input parameter timer :: <GTimer>;
  c-name: "g_timer_stop";
end;

define C-function g-timer-reset
  input parameter timer :: <GTimer>;
  c-name: "g_timer_reset";
end;

define C-function g-timer-continue
  input parameter timer :: <GTimer>;
  c-name: "g_timer_continue";
end;

define C-pointer-type <gulong*> => <gulong>;
define C-function g-timer-elapsed
  input parameter timer :: <GTimer>;
  input parameter microseconds :: <gulong*>;
  result res :: <gdouble>;
  c-name: "g_timer_elapsed";
end;

define C-function g-usleep
  input parameter microseconds :: <gulong>;
  c-name: "g_usleep";
end;

define C-function g-time-val-add
  input parameter time_ :: <GTimeVal>;
  input parameter microseconds :: <glong>;
  c-name: "g_time_val_add";
end;

define C-function g-time-val-from-iso8601
  input parameter iso_date :: <c-string>;
  input parameter time_ :: <GTimeVal>;
  result res :: <gboolean>;
  c-name: "g_time_val_from_iso8601";
end;

define C-function g-time-val-to-iso8601
  input parameter time_ :: <GTimeVal>;
  result res :: <c-string>;
  c-name: "g_time_val_to_iso8601";
end;

define constant $G-USEC-PER-SEC = 1000000;

define C-subtype <_GThreadPool> (<C-void*>) end;
define constant <GThreadPool> = <_GThreadPool>;

define C-function g-thread-pool-new
  input parameter func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  input parameter max_threads :: <gint>;
  input parameter exclusive :: <gboolean>;
  input parameter error :: <GError*>;
  result res :: <GThreadPool>;
  c-name: "g_thread_pool_new";
end;

define C-function g-thread-pool-push
  input parameter pool :: <GThreadPool>;
  input parameter data :: <gpointer>;
  input parameter error :: <GError*>;
  c-name: "g_thread_pool_push";
end;

define C-function g-thread-pool-set-max-threads
  input parameter pool :: <GThreadPool>;
  input parameter max_threads :: <gint>;
  input parameter error :: <GError*>;
  c-name: "g_thread_pool_set_max_threads";
end;

define C-function g-thread-pool-get-max-threads
  input parameter pool :: <GThreadPool>;
  result res :: <gint>;
  c-name: "g_thread_pool_get_max_threads";
end;

define C-function g-thread-pool-get-num-threads
  input parameter pool :: <GThreadPool>;
  result res :: <guint>;
  c-name: "g_thread_pool_get_num_threads";
end;

define C-function g-thread-pool-unprocessed
  input parameter pool :: <GThreadPool>;
  result res :: <guint>;
  c-name: "g_thread_pool_unprocessed";
end;

define C-function g-thread-pool-free
  input parameter pool :: <GThreadPool>;
  input parameter immediate :: <gboolean>;
  input parameter wait_ :: <gboolean>;
  c-name: "g_thread_pool_free";
end;

define C-function g-thread-pool-set-max-unused-threads
  input parameter max_threads :: <gint>;
  c-name: "g_thread_pool_set_max_unused_threads";
end;

define C-function g-thread-pool-get-max-unused-threads
  result res :: <gint>;
  c-name: "g_thread_pool_get_max_unused_threads";
end;

define C-function g-thread-pool-get-num-unused-threads
  result res :: <guint>;
  c-name: "g_thread_pool_get_num_unused_threads";
end;

define C-function g-thread-pool-stop-unused-threads
  c-name: "g_thread_pool_stop_unused_threads";
end;

define C-function g-thread-pool-set-sort-function
  input parameter pool :: <GThreadPool>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_thread_pool_set_sort_function";
end;

define C-function g-thread-pool-set-max-idle-time
  input parameter interval :: <guint>;
  c-name: "g_thread_pool_set_max_idle_time";
end;

define C-function g-thread-pool-get-max-idle-time
  result res :: <guint>;
  c-name: "g_thread_pool_get_max_idle_time";
end;

define C-function g-thread-error-quark
  result res :: <GQuark>;
  c-name: "g_thread_error_quark";
end;

define constant <GThreadError> = limited(<integer>, min: 0, max: 0);
define constant $G-THREAD-ERROR-AGAIN :: <GThreadError> = 0;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-291>"*/
define constant <GThreadFunc> = <anonymous-291>;

define constant <GThreadPriority> = limited(<integer>, min: 0, max: 3);
define constant $G-THREAD-PRIORITY-LOW :: <GThreadPriority> = 0;
define constant $G-THREAD-PRIORITY-NORMAL :: <GThreadPriority> = 1;
define constant $G-THREAD-PRIORITY-HIGH :: <GThreadPriority> = 2;
define constant $G-THREAD-PRIORITY-URGENT :: <GThreadPriority> = 3;

define C-subtype <_GThread> (<C-void*>) end;
define constant <GThread> = <_GThread>;

define constant <GMutex> = <_GMutex>;

define C-subtype <_GCond> (<C-void*>) end;
define constant <GCond> = <_GCond>;

define C-subtype <_GPrivate> (<C-void*>) end;
define constant <GPrivate> = <_GPrivate>;

define C-subtype <_GStaticPrivate> (<C-void*>) end;
define constant <GStaticPrivate> = <_GStaticPrivate>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-293>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-294>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-295>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-296>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-297>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-298>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-299>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-300>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-301>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-302>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-303>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-304>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-305>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-306>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-307>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-308>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-309>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-310>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-311>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-312>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-313>"*/
define C-subtype <_GThreadFunctions> (<C-void*>) end;
define constant <GThreadFunctions> = <_GThreadFunctions>;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-thread-functions-for-glib-use"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "g-thread-use-default-impl"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "g-threads-got-initialized"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-314>"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "g-thread-gettime"*/
define C-pointer-type <GMutex*> => <GMutex>;
define C-function g-static-mutex-get-mutex-impl
  input parameter mutex :: <GMutex*>;
  result res :: <GMutex>;
  c-name: "g_static_mutex_get_mutex_impl";
end;

define C-function g-thread-create-full
  input parameter func :: <GThreadFunc>;
  input parameter data :: <gpointer>;
  input parameter stack_size :: <gulong>;
  input parameter joinable :: <gboolean>;
  input parameter bound :: <gboolean>;
  input parameter priority :: <GThreadPriority>;
  input parameter error :: <GError*>;
  result res :: <GThread>;
  c-name: "g_thread_create_full";
end;

define C-function g-thread-self
  result res :: <GThread>;
  c-name: "g_thread_self";
end;

define C-function g-thread-exit
  input parameter retval :: <gpointer>;
  c-name: "g_thread_exit";
end;

define C-function g-thread-join
  input parameter thread :: <GThread>;
  result res :: <gpointer>;
  c-name: "g_thread_join";
end;

define C-function g-thread-set-priority
  input parameter thread :: <GThread>;
  input parameter priority :: <GThreadPriority>;
  c-name: "g_thread_set_priority";
end;

define C-pointer-type <GStaticMutex*> => <GStaticMutex>;
define C-function g-static-mutex-init
  input parameter mutex :: <GStaticMutex*>;
  c-name: "g_static_mutex_init";
end;

define C-function g-static-mutex-free
  input parameter mutex :: <GStaticMutex*>;
  c-name: "g_static_mutex_free";
end;

define C-function g-static-private-init
  input parameter private_key :: <GStaticPrivate>;
  c-name: "g_static_private_init";
end;

define C-function g-static-private-get
  input parameter private_key :: <GStaticPrivate>;
  result res :: <gpointer>;
  c-name: "g_static_private_get";
end;

define C-function g-static-private-set
  input parameter private_key :: <GStaticPrivate>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  c-name: "g_static_private_set";
end;

define C-function g-static-private-free
  input parameter private_key :: <GStaticPrivate>;
  c-name: "g_static_private_free";
end;

define C-subtype <_GStaticRecMutex> (<C-void*>) end;
define constant <GStaticRecMutex> = <_GStaticRecMutex>;

define C-function g-static-rec-mutex-init
  input parameter mutex :: <GStaticRecMutex>;
  c-name: "g_static_rec_mutex_init";
end;

define C-function g-static-rec-mutex-lock
  input parameter mutex :: <GStaticRecMutex>;
  c-name: "g_static_rec_mutex_lock";
end;

define C-function g-static-rec-mutex-trylock
  input parameter mutex :: <GStaticRecMutex>;
  result res :: <gboolean>;
  c-name: "g_static_rec_mutex_trylock";
end;

define C-function g-static-rec-mutex-unlock
  input parameter mutex :: <GStaticRecMutex>;
  c-name: "g_static_rec_mutex_unlock";
end;

define C-function g-static-rec-mutex-lock-full
  input parameter mutex :: <GStaticRecMutex>;
  input parameter depth :: <guint>;
  c-name: "g_static_rec_mutex_lock_full";
end;

define C-function g-static-rec-mutex-unlock-full
  input parameter mutex :: <GStaticRecMutex>;
  result res :: <guint>;
  c-name: "g_static_rec_mutex_unlock_full";
end;

define C-function g-static-rec-mutex-free
  input parameter mutex :: <GStaticRecMutex>;
  c-name: "g_static_rec_mutex_free";
end;

define C-subtype <_GStaticRWLock> (<C-void*>) end;
define constant <GStaticRWLock> = <_GStaticRWLock>;

define C-function g-static-rw-lock-init
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_init";
end;

define C-function g-static-rw-lock-reader-lock
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_reader_lock";
end;

define C-function g-static-rw-lock-reader-trylock
  input parameter lock :: <GStaticRWLock>;
  result res :: <gboolean>;
  c-name: "g_static_rw_lock_reader_trylock";
end;

define C-function g-static-rw-lock-reader-unlock
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_reader_unlock";
end;

define C-function g-static-rw-lock-writer-lock
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_writer_lock";
end;

define C-function g-static-rw-lock-writer-trylock
  input parameter lock :: <GStaticRWLock>;
  result res :: <gboolean>;
  c-name: "g_static_rw_lock_writer_trylock";
end;

define C-function g-static-rw-lock-writer-unlock
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_writer_unlock";
end;

define C-function g-static-rw-lock-free
  input parameter lock :: <GStaticRWLock>;
  c-name: "g_static_rw_lock_free";
end;

define C-function g-thread-foreach
  input parameter thread_func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_thread_foreach";
end;

define constant <GOnceStatus> = limited(<integer>, min: 0, max: 2);
define constant $G-ONCE-STATUS-NOTCALLED :: <GOnceStatus> = 0;
define constant $G-ONCE-STATUS-PROGRESS :: <GOnceStatus> = 1;
define constant $G-ONCE-STATUS-READY :: <GOnceStatus> = 2;

define C-subtype <_GOnce> (<C-void*>) end;
define constant <GOnce> = <_GOnce>;

define C-function g-once-impl
  input parameter once :: <GOnce>;
  input parameter func :: <GThreadFunc>;
  input parameter arg :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_once_impl";
end;

define constant $G-MUTEX-DEBUG-MAGIC = #ex00000000F8E18AD7;

define C-function g-atomic-int-exchange-and-add
  input parameter atomic :: <gint*>;
  input parameter val :: <gint>;
  result res :: <gint>;
  c-name: "g_atomic_int_exchange_and_add";
end;

define C-function g-atomic-int-add
  input parameter atomic :: <gint*>;
  input parameter val :: <gint>;
  c-name: "g_atomic_int_add";
end;

define C-function g-atomic-int-compare-and-exchange
  input parameter atomic :: <gint*>;
  input parameter oldval :: <gint>;
  input parameter newval :: <gint>;
  result res :: <gboolean>;
  c-name: "g_atomic_int_compare_and_exchange";
end;

define C-function g-atomic-pointer-compare-and-exchange
  input parameter atomic :: <gpointer*>;
  input parameter oldval :: <gpointer>;
  input parameter newval :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_atomic_pointer_compare_and_exchange";
end;

define C-function g-atomic-int-get
  input parameter atomic :: <gint*>;
  result res :: <gint>;
  c-name: "g_atomic_int_get";
end;

define C-function g-atomic-int-set
  input parameter atomic :: <gint*>;
  input parameter newval :: <gint>;
  c-name: "g_atomic_int_set";
end;

define C-function g-atomic-pointer-get
  input parameter atomic :: <gpointer*>;
  result res :: <gpointer>;
  c-name: "g_atomic_pointer_get";
end;

define C-function g-atomic-pointer-set
  input parameter atomic :: <gpointer*>;
  input parameter newval :: <gpointer>;
  c-name: "g_atomic_pointer_set";
end;

define C-subtype <_GStringChunk> (<C-void*>) end;
define constant <GStringChunk> = <_GStringChunk>;

define C-function g-string-chunk-new
  input parameter size :: <gsize>;
  result res :: <GStringChunk>;
  c-name: "g_string_chunk_new";
end;

define C-function g-string-chunk-free
  input parameter chunk :: <GStringChunk>;
  c-name: "g_string_chunk_free";
end;

define C-function g-string-chunk-insert
  input parameter chunk :: <GStringChunk>;
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_string_chunk_insert";
end;

define C-function g-string-chunk-insert-len
  input parameter chunk :: <GStringChunk>;
  input parameter string :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_string_chunk_insert_len";
end;

define C-function g-string-chunk-insert-const
  input parameter chunk :: <GStringChunk>;
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_string_chunk_insert_const";
end;

define C-function g-string-new
  input parameter init :: <c-string>;
  result res :: <GString>;
  c-name: "g_string_new";
end;

define C-function g-string-new-len
  input parameter init :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <GString>;
  c-name: "g_string_new_len";
end;

define C-function g-string-sized-new
  input parameter dfl_size :: <gsize>;
  result res :: <GString>;
  c-name: "g_string_sized_new";
end;

define C-function g-string-free
  input parameter string :: <GString>;
  input parameter free_segment :: <gboolean>;
  result res :: <c-string>;
  c-name: "g_string_free";
end;

define C-function g-string-equal
  input parameter v :: <GString>;
  input parameter v2 :: <GString>;
  result res :: <gboolean>;
  c-name: "g_string_equal";
end;

define C-function g-string-hash
  input parameter str :: <GString>;
  result res :: <guint>;
  c-name: "g_string_hash";
end;

define C-function g-string-assign
  input parameter string :: <GString>;
  input parameter rval :: <c-string>;
  result res :: <GString>;
  c-name: "g_string_assign";
end;

define C-function g-string-truncate
  input parameter string :: <GString>;
  input parameter len :: <gsize>;
  result res :: <GString>;
  c-name: "g_string_truncate";
end;

define C-function g-string-set-size
  input parameter string :: <GString>;
  input parameter len :: <gsize>;
  result res :: <GString>;
  c-name: "g_string_set_size";
end;

define C-function g-string-insert-len
  input parameter string :: <GString>;
  input parameter pos :: <gssize>;
  input parameter val :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <GString>;
  c-name: "g_string_insert_len";
end;

define C-function g-string-append
  input parameter string :: <GString>;
  input parameter val :: <c-string>;
  result res :: <GString>;
  c-name: "g_string_append";
end;

define C-function g-string-append-len
  input parameter string :: <GString>;
  input parameter val :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <GString>;
  c-name: "g_string_append_len";
end;

define C-function g-string-append-c
  input parameter string :: <GString>;
  input parameter c :: <gchar>;
  result res :: <GString>;
  c-name: "g_string_append_c";
end;

define C-function g-string-append-unichar
  input parameter string :: <GString>;
  input parameter wc :: <gunichar>;
  result res :: <GString>;
  c-name: "g_string_append_unichar";
end;

define C-function g-string-prepend
  input parameter string :: <GString>;
  input parameter val :: <c-string>;
  result res :: <GString>;
  c-name: "g_string_prepend";
end;

define C-function g-string-prepend-c
  input parameter string :: <GString>;
  input parameter c :: <gchar>;
  result res :: <GString>;
  c-name: "g_string_prepend_c";
end;

define C-function g-string-prepend-unichar
  input parameter string :: <GString>;
  input parameter wc :: <gunichar>;
  result res :: <GString>;
  c-name: "g_string_prepend_unichar";
end;

define C-function g-string-prepend-len
  input parameter string :: <GString>;
  input parameter val :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <GString>;
  c-name: "g_string_prepend_len";
end;

define C-function g-string-insert
  input parameter string :: <GString>;
  input parameter pos :: <gssize>;
  input parameter val :: <c-string>;
  result res :: <GString>;
  c-name: "g_string_insert";
end;

define C-function g-string-insert-c
  input parameter string :: <GString>;
  input parameter pos :: <gssize>;
  input parameter c :: <gchar>;
  result res :: <GString>;
  c-name: "g_string_insert_c";
end;

define C-function g-string-insert-unichar
  input parameter string :: <GString>;
  input parameter pos :: <gssize>;
  input parameter wc :: <gunichar>;
  result res :: <GString>;
  c-name: "g_string_insert_unichar";
end;

define C-function g-string-erase
  input parameter string :: <GString>;
  input parameter pos :: <gssize>;
  input parameter len :: <gssize>;
  result res :: <GString>;
  c-name: "g_string_erase";
end;

define C-function g-string-ascii-down
  input parameter string :: <GString>;
  result res :: <GString>;
  c-name: "g_string_ascii_down";
end;

define C-function g-string-ascii-up
  input parameter string :: <GString>;
  result res :: <GString>;
  c-name: "g_string_ascii_up";
end;

define C-function g-string-printf
  input parameter string :: <GString>;
  input parameter format :: <c-string>;
  c-name: "g_string_printf";
end;

define C-function g-string-append-printf
  input parameter string :: <GString>;
  input parameter format :: <c-string>;
  c-name: "g_string_append_printf";
end;

define C-function g-string-down
  input parameter string :: <GString>;
  result res :: <GString>;
  c-name: "g_string_down";
end;

define C-function g-string-up
  input parameter string :: <GString>;
  result res :: <GString>;
  c-name: "g_string_up";
end;

define constant g-string-sprintf = g-string-printf;

define constant g-string-sprintfa = g-string-append-printf;

define constant <GAsciiType> = limited(<integer>, min: 1, max: 1024);
define constant $G-ASCII-ALNUM :: <GAsciiType> = 1;
define constant $G-ASCII-ALPHA :: <GAsciiType> = 2;
define constant $G-ASCII-CNTRL :: <GAsciiType> = 4;
define constant $G-ASCII-DIGIT :: <GAsciiType> = 8;
define constant $G-ASCII-GRAPH :: <GAsciiType> = 16;
define constant $G-ASCII-LOWER :: <GAsciiType> = 32;
define constant $G-ASCII-PRINT :: <GAsciiType> = 64;
define constant $G-ASCII-PUNCT :: <GAsciiType> = 128;
define constant $G-ASCII-SPACE :: <GAsciiType> = 256;
define constant $G-ASCII-UPPER :: <GAsciiType> = 512;
define constant $G-ASCII-XDIGIT :: <GAsciiType> = 1024;

define C-pointer-type <guint16*> => <guint16>;
 /* Ignoring declaration for {instance of <variable-declaration>} "g-ascii-table"*/
define C-function g-ascii-tolower
  input parameter c :: <gchar>;
  result res :: <gchar>;
  c-name: "g_ascii_tolower";
end;

define C-function g-ascii-toupper
  input parameter c :: <gchar>;
  result res :: <gchar>;
  c-name: "g_ascii_toupper";
end;

define C-function g-ascii-digit-value
  input parameter c :: <gchar>;
  result res :: <gint>;
  c-name: "g_ascii_digit_value";
end;

define C-function g-ascii-xdigit-value
  input parameter c :: <gchar>;
  result res :: <gint>;
  c-name: "g_ascii_xdigit_value";
end;

define C-function g-strdelimit
  input parameter string :: <c-string>;
  input parameter delimiters :: <c-string>;
  input parameter new_delimiter :: <gchar>;
  result res :: <c-string>;
  c-name: "g_strdelimit";
end;

define C-function g-strcanon
  input parameter string :: <c-string>;
  input parameter valid_chars :: <c-string>;
  input parameter substitutor :: <gchar>;
  result res :: <c-string>;
  c-name: "g_strcanon";
end;

define C-function g-strerror
  input parameter errnum :: <gint>;
  result res :: <c-string>;
  c-name: "g_strerror";
end;

define C-function g-strsignal
  input parameter signum :: <gint>;
  result res :: <c-string>;
  c-name: "g_strsignal";
end;

define C-function g-strreverse
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strreverse";
end;

define C-function g-strlcpy
  input parameter dest :: <c-string>;
  input parameter src :: <c-string>;
  input parameter dest_size :: <gsize>;
  result res :: <gsize>;
  c-name: "g_strlcpy";
end;

define C-function g-strlcat
  input parameter dest :: <c-string>;
  input parameter src :: <c-string>;
  input parameter dest_size :: <gsize>;
  result res :: <gsize>;
  c-name: "g_strlcat";
end;

define C-function g-strstr-len
  input parameter haystack :: <c-string>;
  input parameter haystack_len :: <gssize>;
  input parameter needle :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strstr_len";
end;

define C-function g-strrstr
  input parameter haystack :: <c-string>;
  input parameter needle :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strrstr";
end;

define C-function g-strrstr-len
  input parameter haystack :: <c-string>;
  input parameter haystack_len :: <gssize>;
  input parameter needle :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strrstr_len";
end;

define C-function g-str-has-suffix
  input parameter str :: <c-string>;
  input parameter suffix :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_str_has_suffix";
end;

define C-function g-str-has-prefix
  input parameter str :: <c-string>;
  input parameter prefix :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_str_has_prefix";
end;

define C-function g-strtod
  input parameter nptr :: <c-string>;
  input parameter endptr :: <gchar**>;
  result res :: <gdouble>;
  c-name: "g_strtod";
end;

define C-function g-ascii-strtod
  input parameter nptr :: <c-string>;
  input parameter endptr :: <gchar**>;
  result res :: <gdouble>;
  c-name: "g_ascii_strtod";
end;

define C-function g-ascii-strtoull
  input parameter nptr :: <c-string>;
  input parameter endptr :: <gchar**>;
  input parameter base :: <guint>;
  result res :: <guint64>;
  c-name: "g_ascii_strtoull";
end;

define C-function g-ascii-strtoll
  input parameter nptr :: <c-string>;
  input parameter endptr :: <gchar**>;
  input parameter base :: <guint>;
  result res :: <gint64>;
  c-name: "g_ascii_strtoll";
end;

define C-function g-ascii-dtostr
  input parameter buffer :: <c-string>;
  input parameter buf_len :: <gint>;
  input parameter d :: <gdouble>;
  result res :: <c-string>;
  c-name: "g_ascii_dtostr";
end;

define C-function g-ascii-formatd
  input parameter buffer :: <c-string>;
  input parameter buf_len :: <gint>;
  input parameter format :: <c-string>;
  input parameter d :: <gdouble>;
  result res :: <c-string>;
  c-name: "g_ascii_formatd";
end;

define C-function g-strchug
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strchug";
end;

define C-function g-strchomp
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strchomp";
end;

define C-function g-ascii-strcasecmp
  input parameter s1 :: <c-string>;
  input parameter s2 :: <c-string>;
  result res :: <gint>;
  c-name: "g_ascii_strcasecmp";
end;

define C-function g-ascii-strncasecmp
  input parameter s1 :: <c-string>;
  input parameter s2 :: <c-string>;
  input parameter n :: <gsize>;
  result res :: <gint>;
  c-name: "g_ascii_strncasecmp";
end;

define C-function g-ascii-strdown
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_ascii_strdown";
end;

define C-function g-ascii-strup
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  result res :: <c-string>;
  c-name: "g_ascii_strup";
end;

define C-function g-strcasecmp
  input parameter s1 :: <c-string>;
  input parameter s2 :: <c-string>;
  result res :: <gint>;
  c-name: "g_strcasecmp";
end;

define C-function g-strncasecmp
  input parameter s1 :: <c-string>;
  input parameter s2 :: <c-string>;
  input parameter n :: <guint>;
  result res :: <gint>;
  c-name: "g_strncasecmp";
end;

define C-function g-strdown
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strdown";
end;

define C-function g-strup
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strup";
end;

define C-function g-strdup
  input parameter str :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strdup";
end;

define C-function g-strdup-printf
  input parameter format :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strdup_printf";
end;

define C-function g-strdup-vprintf
  input parameter format :: <c-string>;
  input parameter args :: <va-list>;
  result res :: <c-string>;
  c-name: "g_strdup_vprintf";
end;

define C-function g-strndup
  input parameter str :: <c-string>;
  input parameter n :: <gsize>;
  result res :: <c-string>;
  c-name: "g_strndup";
end;

define C-function g-strnfill
  input parameter length :: <gsize>;
  input parameter fill_char :: <gchar>;
  result res :: <c-string>;
  c-name: "g_strnfill";
end;

define C-function g-strconcat
  input parameter string1 :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strconcat";
end;

define C-function g-strjoin
  input parameter separator :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strjoin";
end;

define C-function g-strcompress
  input parameter source :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strcompress";
end;

define C-function g-strescape
  input parameter source :: <c-string>;
  input parameter exceptions :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strescape";
end;

define C-function g-memdup
  input parameter mem :: <gconstpointer>;
  input parameter byte_size :: <guint>;
  result res :: <gpointer>;
  c-name: "g_memdup";
end;

define C-function g-strsplit
  input parameter string :: <c-string>;
  input parameter delimiter :: <c-string>;
  input parameter max_tokens :: <gint>;
  result res :: <gchar**>;
  c-name: "g_strsplit";
end;

define C-function g-strsplit-set
  input parameter string :: <c-string>;
  input parameter delimiters :: <c-string>;
  input parameter max_tokens :: <gint>;
  result res :: <gchar**>;
  c-name: "g_strsplit_set";
end;

define C-function g-strjoinv
  input parameter separator :: <c-string>;
  input parameter str_array :: <gchar**>;
  result res :: <c-string>;
  c-name: "g_strjoinv";
end;

define C-function g-strfreev
  input parameter str_array :: <gchar**>;
  c-name: "g_strfreev";
end;

define C-function g-strdupv
  input parameter str_array :: <gchar**>;
  result res :: <gchar**>;
  c-name: "g_strdupv";
end;

define C-function g-strv-length
  input parameter str_array :: <gchar**>;
  result res :: <guint>;
  c-name: "g_strv_length";
end;

define C-function g-stpcpy
  input parameter dest :: <c-string>;
  input parameter src :: <c-string>;
  result res :: <c-string>;
  c-name: "g_stpcpy";
end;

define C-function g-strip-context
  input parameter msgid :: <c-string>;
  input parameter msgval :: <c-string>;
  result res :: <c-string>;
  c-name: "g_strip_context";
end;

define constant $G-STR-DELIMITERS = "_-|> <.";

define constant $G-ASCII-DTOSTR-BUF-SIZE = 39;

define constant <GSpawnError> = limited(<integer>, min: 0, max: 19);
define constant $G-SPAWN-ERROR-FORK :: <GSpawnError> = 0;
define constant $G-SPAWN-ERROR-READ :: <GSpawnError> = 1;
define constant $G-SPAWN-ERROR-CHDIR :: <GSpawnError> = 2;
define constant $G-SPAWN-ERROR-ACCES :: <GSpawnError> = 3;
define constant $G-SPAWN-ERROR-PERM :: <GSpawnError> = 4;
define constant $G-SPAWN-ERROR-2BIG :: <GSpawnError> = 5;
define constant $G-SPAWN-ERROR-NOEXEC :: <GSpawnError> = 6;
define constant $G-SPAWN-ERROR-NAMETOOLONG :: <GSpawnError> = 7;
define constant $G-SPAWN-ERROR-NOENT :: <GSpawnError> = 8;
define constant $G-SPAWN-ERROR-NOMEM :: <GSpawnError> = 9;
define constant $G-SPAWN-ERROR-NOTDIR :: <GSpawnError> = 10;
define constant $G-SPAWN-ERROR-LOOP :: <GSpawnError> = 11;
define constant $G-SPAWN-ERROR-TXTBUSY :: <GSpawnError> = 12;
define constant $G-SPAWN-ERROR-IO :: <GSpawnError> = 13;
define constant $G-SPAWN-ERROR-NFILE :: <GSpawnError> = 14;
define constant $G-SPAWN-ERROR-MFILE :: <GSpawnError> = 15;
define constant $G-SPAWN-ERROR-INVAL :: <GSpawnError> = 16;
define constant $G-SPAWN-ERROR-ISDIR :: <GSpawnError> = 17;
define constant $G-SPAWN-ERROR-LIBBAD :: <GSpawnError> = 18;
define constant $G-SPAWN-ERROR-FAILED :: <GSpawnError> = 19;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1272>"*/
define constant <GSpawnChildSetupFunc> = <anonymous-1272>;

define constant <GSpawnFlags> = limited(<integer>, min: 1, max: 64);
define constant $G-SPAWN-LEAVE-DESCRIPTORS-OPEN :: <GSpawnFlags> = 1;
define constant $G-SPAWN-DO-NOT-REAP-CHILD :: <GSpawnFlags> = 2;
define constant $G-SPAWN-SEARCH-PATH :: <GSpawnFlags> = 4;
define constant $G-SPAWN-STDOUT-TO-DEV-NULL :: <GSpawnFlags> = 8;
define constant $G-SPAWN-STDERR-TO-DEV-NULL :: <GSpawnFlags> = 16;
define constant $G-SPAWN-CHILD-INHERITS-STDIN :: <GSpawnFlags> = 32;
define constant $G-SPAWN-FILE-AND-ARGV-ZERO :: <GSpawnFlags> = 64;

define C-function g-spawn-error-quark
  result res :: <GQuark>;
  c-name: "g_spawn_error_quark";
end;

define C-pointer-type <GPid*> => <GPid>;
define C-function g-spawn-async-utf8
  input parameter working_directory :: <c-string>;
  input parameter argv :: <gchar**>;
  input parameter envp :: <gchar**>;
  input parameter flags :: <GSpawnFlags>;
  input parameter child_setup :: <GSpawnChildSetupFunc>;
  input parameter user_data :: <gpointer>;
  input parameter child_pid :: <GPid*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_spawn_async_utf8";
end;

define C-function g-spawn-async-with-pipes-utf8
  input parameter working_directory :: <c-string>;
  input parameter argv :: <gchar**>;
  input parameter envp :: <gchar**>;
  input parameter flags :: <GSpawnFlags>;
  input parameter child_setup :: <GSpawnChildSetupFunc>;
  input parameter user_data :: <gpointer>;
  input parameter child_pid :: <GPid*>;
  input parameter standard_input :: <gint*>;
  input parameter standard_output :: <gint*>;
  input parameter standard_error :: <gint*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_spawn_async_with_pipes_utf8";
end;

define C-function g-spawn-sync-utf8
  input parameter working_directory :: <c-string>;
  input parameter argv :: <gchar**>;
  input parameter envp :: <gchar**>;
  input parameter flags :: <GSpawnFlags>;
  input parameter child_setup :: <GSpawnChildSetupFunc>;
  input parameter user_data :: <gpointer>;
  input parameter standard_output :: <gchar**>;
  input parameter standard_error :: <gchar**>;
  input parameter exit_status :: <gint*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_spawn_sync_utf8";
end;

define C-function g-spawn-command-line-sync-utf8
  input parameter command_line :: <c-string>;
  input parameter standard_output :: <gchar**>;
  input parameter standard_error :: <gchar**>;
  input parameter exit_status :: <gint*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_spawn_command_line_sync_utf8";
end;

define C-function g-spawn-command-line-async-utf8
  input parameter command_line :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_spawn_command_line_async_utf8";
end;

define C-function g-spawn-close-pid
  input parameter pid :: <GPid>;
  c-name: "g_spawn_close_pid";
end;

define constant g-spawn-async = g-spawn-async-utf8;

define constant g-spawn-async-with-pipes = g-spawn-async-with-pipes-utf8;

define constant g-spawn-sync = g-spawn-sync-utf8;

define constant g-spawn-command-line-sync = g-spawn-command-line-sync-utf8;

define constant g-spawn-command-line-async = g-spawn-command-line-async-utf8;

define C-function g-slist-alloc
  result res :: <GSList>;
  c-name: "g_slist_alloc";
end;

define C-function g-slist-free
  input parameter list :: <GSList>;
  c-name: "g_slist_free";
end;

define C-function g-slist-free-1
  input parameter list :: <GSList>;
  c-name: "g_slist_free_1";
end;

define C-function g-slist-append
  input parameter list :: <GSList>;
  input parameter data :: <gpointer>;
  result res :: <GSList>;
  c-name: "g_slist_append";
end;

define C-function g-slist-prepend
  input parameter list :: <GSList>;
  input parameter data :: <gpointer>;
  result res :: <GSList>;
  c-name: "g_slist_prepend";
end;

define C-function g-slist-insert
  input parameter list :: <GSList>;
  input parameter data :: <gpointer>;
  input parameter position :: <gint>;
  result res :: <GSList>;
  c-name: "g_slist_insert";
end;

define C-function g-slist-insert-sorted
  input parameter list :: <GSList>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GSList>;
  c-name: "g_slist_insert_sorted";
end;

define C-function g-slist-insert-sorted-with-data
  input parameter list :: <GSList>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GSList>;
  c-name: "g_slist_insert_sorted_with_data";
end;

define C-function g-slist-insert-before
  input parameter slist :: <GSList>;
  input parameter sibling :: <GSList>;
  input parameter data :: <gpointer>;
  result res :: <GSList>;
  c-name: "g_slist_insert_before";
end;

define C-function g-slist-concat
  input parameter list1 :: <GSList>;
  input parameter list2 :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_concat";
end;

define C-function g-slist-remove
  input parameter list :: <GSList>;
  input parameter data :: <gconstpointer>;
  result res :: <GSList>;
  c-name: "g_slist_remove";
end;

define C-function g-slist-remove-all
  input parameter list :: <GSList>;
  input parameter data :: <gconstpointer>;
  result res :: <GSList>;
  c-name: "g_slist_remove_all";
end;

define C-function g-slist-remove-link
  input parameter list :: <GSList>;
  input parameter link_ :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_remove_link";
end;

define C-function g-slist-delete-link
  input parameter list :: <GSList>;
  input parameter link_ :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_delete_link";
end;

define C-function g-slist-reverse
  input parameter list :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_reverse";
end;

define C-function g-slist-copy
  input parameter list :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_copy";
end;

define C-function g-slist-nth
  input parameter list :: <GSList>;
  input parameter n :: <guint>;
  result res :: <GSList>;
  c-name: "g_slist_nth";
end;

define C-function g-slist-find
  input parameter list :: <GSList>;
  input parameter data :: <gconstpointer>;
  result res :: <GSList>;
  c-name: "g_slist_find";
end;

define C-function g-slist-find-custom
  input parameter list :: <GSList>;
  input parameter data :: <gconstpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GSList>;
  c-name: "g_slist_find_custom";
end;

define C-function g-slist-position
  input parameter list :: <GSList>;
  input parameter llink :: <GSList>;
  result res :: <gint>;
  c-name: "g_slist_position";
end;

define C-function g-slist-index
  input parameter list :: <GSList>;
  input parameter data :: <gconstpointer>;
  result res :: <gint>;
  c-name: "g_slist_index";
end;

define C-function g-slist-last
  input parameter list :: <GSList>;
  result res :: <GSList>;
  c-name: "g_slist_last";
end;

define C-function g-slist-length
  input parameter list :: <GSList>;
  result res :: <guint>;
  c-name: "g_slist_length";
end;

define C-function g-slist-foreach
  input parameter list :: <GSList>;
  input parameter func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_slist_foreach";
end;

define C-function g-slist-sort
  input parameter list :: <GSList>;
  input parameter compare_func :: <GCompareFunc>;
  result res :: <GSList>;
  c-name: "g_slist_sort";
end;

define C-function g-slist-sort-with-data
  input parameter list :: <GSList>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GSList>;
  c-name: "g_slist_sort_with_data";
end;

define C-function g-slist-nth-data
  input parameter list :: <GSList>;
  input parameter n :: <guint>;
  result res :: <gpointer>;
  c-name: "g_slist_nth_data";
end;

define C-function g-slist-push-allocator
  input parameter dummy :: <gpointer>;
  c-name: "g_slist_push_allocator";
end;

define C-function g-slist-pop-allocator
  c-name: "g_slist_pop_allocator";
end;

define constant g-slist-free1 = g-slist-free-1;

define constant <GShellError> = limited(<integer>, min: 0, max: 2);
define constant $G-SHELL-ERROR-BAD-QUOTING :: <GShellError> = 0;
define constant $G-SHELL-ERROR-EMPTY-STRING :: <GShellError> = 1;
define constant $G-SHELL-ERROR-FAILED :: <GShellError> = 2;

define C-function g-shell-error-quark
  result res :: <GQuark>;
  c-name: "g_shell_error_quark";
end;

define C-function g-shell-quote
  input parameter unquoted_string :: <c-string>;
  result res :: <c-string>;
  c-name: "g_shell_quote";
end;

define C-function g-shell-unquote
  input parameter quoted_string :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_shell_unquote";
end;

define C-pointer-type <gchar***> => <gchar**>;
define C-function g-shell-parse-argv
  input parameter command_line :: <c-string>;
  input parameter argcp :: <gint*>;
  input parameter argvp :: <gchar***>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_shell_parse_argv";
end;

define C-subtype <_GScannerConfig> (<C-void*>) end;
define constant <GScannerConfig> = <_GScannerConfig>;

define constant <GTokenType> = limited(<integer>, min: 0, max: 270);
define constant $G-TOKEN-EOF :: <GTokenType> = 0;
define constant $G-TOKEN-LEFT-PAREN :: <GTokenType> = 40;
define constant $G-TOKEN-RIGHT-PAREN :: <GTokenType> = 41;
define constant $G-TOKEN-LEFT-CURLY :: <GTokenType> = 123;
define constant $G-TOKEN-RIGHT-CURLY :: <GTokenType> = 125;
define constant $G-TOKEN-LEFT-BRACE :: <GTokenType> = 91;
define constant $G-TOKEN-RIGHT-BRACE :: <GTokenType> = 93;
define constant $G-TOKEN-EQUAL-SIGN :: <GTokenType> = 61;
define constant $G-TOKEN-COMMA :: <GTokenType> = 44;
define constant $G-TOKEN-NONE :: <GTokenType> = 256;
define constant $G-TOKEN-ERROR :: <GTokenType> = 257;
define constant $G-TOKEN-CHAR :: <GTokenType> = 258;
define constant $G-TOKEN-BINARY :: <GTokenType> = 259;
define constant $G-TOKEN-OCTAL :: <GTokenType> = 260;
define constant $G-TOKEN-INT :: <GTokenType> = 261;
define constant $G-TOKEN-HEX :: <GTokenType> = 262;
define constant $G-TOKEN-FLOAT :: <GTokenType> = 263;
define constant $G-TOKEN-STRING :: <GTokenType> = 264;
define constant $G-TOKEN-SYMBOL :: <GTokenType> = 265;
define constant $G-TOKEN-IDENTIFIER :: <GTokenType> = 266;
define constant $G-TOKEN-IDENTIFIER-NULL :: <GTokenType> = 267;
define constant $G-TOKEN-COMMENT-SINGLE :: <GTokenType> = 268;
define constant $G-TOKEN-COMMENT-MULTI :: <GTokenType> = 269;
define constant $G-TOKEN-LAST :: <GTokenType> = 270;

 /* Ignoring declaration for {instance of <union-declaration>} "<_GTokenValue>"*/
define constant <GTokenValue> = <_GTokenValue>;

define C-subtype <_GHashTable> (<C-void*>) end;
define constant <GHashTable> = <_GHashTable>;

define constant <GScanner> = <_GScanner>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1220>"*/
define constant <GScannerMsgFunc> = <anonymous-1220>;

define C-subtype <_GScanner> (<C-void*>) end;
define constant <GErrorType> = limited(<integer>, min: 0, max: 7);
define constant $G-ERR-UNKNOWN :: <GErrorType> = 0;
define constant $G-ERR-UNEXP-EOF :: <GErrorType> = 1;
define constant $G-ERR-UNEXP-EOF-IN-STRING :: <GErrorType> = 2;
define constant $G-ERR-UNEXP-EOF-IN-COMMENT :: <GErrorType> = 3;
define constant $G-ERR-NON-DIGIT-IN-CONST :: <GErrorType> = 4;
define constant $G-ERR-DIGIT-RADIX :: <GErrorType> = 5;
define constant $G-ERR-FLOAT-RADIX :: <GErrorType> = 6;
define constant $G-ERR-FLOAT-MALFORMED :: <GErrorType> = 7;

define C-function g-scanner-new
  input parameter config_templ :: <GScannerConfig>;
  result res :: <GScanner>;
  c-name: "g_scanner_new";
end;

define C-function g-scanner-destroy
  input parameter scanner :: <GScanner>;
  c-name: "g_scanner_destroy";
end;

define C-function g-scanner-input-file
  input parameter scanner :: <GScanner>;
  input parameter input_fd :: <gint>;
  c-name: "g_scanner_input_file";
end;

define C-function g-scanner-sync-file-offset
  input parameter scanner :: <GScanner>;
  c-name: "g_scanner_sync_file_offset";
end;

define C-function g-scanner-input-text
  input parameter scanner :: <GScanner>;
  input parameter text :: <c-string>;
  input parameter text_len :: <guint>;
  c-name: "g_scanner_input_text";
end;

define C-function g-scanner-get-next-token
  input parameter scanner :: <GScanner>;
  result res :: <GTokenType>;
  c-name: "g_scanner_get_next_token";
end;

define C-function g-scanner-peek-next-token
  input parameter scanner :: <GScanner>;
  result res :: <GTokenType>;
  c-name: "g_scanner_peek_next_token";
end;

define C-function g-scanner-cur-token
  input parameter scanner :: <GScanner>;
  result res :: <GTokenType>;
  c-name: "g_scanner_cur_token";
end;

define C-function g-scanner-cur-line
  input parameter scanner :: <GScanner>;
  result res :: <guint>;
  c-name: "g_scanner_cur_line";
end;

define C-function g-scanner-cur-position
  input parameter scanner :: <GScanner>;
  result res :: <guint>;
  c-name: "g_scanner_cur_position";
end;

define C-function g-scanner-eof
  input parameter scanner :: <GScanner>;
  result res :: <gboolean>;
  c-name: "g_scanner_eof";
end;

define C-function g-scanner-set-scope
  input parameter scanner :: <GScanner>;
  input parameter scope_id :: <guint>;
  result res :: <guint>;
  c-name: "g_scanner_set_scope";
end;

define C-function g-scanner-scope-add-symbol
  input parameter scanner :: <GScanner>;
  input parameter scope_id :: <guint>;
  input parameter symbol :: <c-string>;
  input parameter value :: <gpointer>;
  c-name: "g_scanner_scope_add_symbol";
end;

define C-function g-scanner-scope-remove-symbol
  input parameter scanner :: <GScanner>;
  input parameter scope_id :: <guint>;
  input parameter symbol :: <c-string>;
  c-name: "g_scanner_scope_remove_symbol";
end;

define C-function g-scanner-scope-lookup-symbol
  input parameter scanner :: <GScanner>;
  input parameter scope_id :: <guint>;
  input parameter symbol :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_scanner_scope_lookup_symbol";
end;

define C-function g-scanner-scope-foreach-symbol
  input parameter scanner :: <GScanner>;
  input parameter scope_id :: <guint>;
  input parameter func :: <GHFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_scanner_scope_foreach_symbol";
end;

define C-function g-scanner-lookup-symbol
  input parameter scanner :: <GScanner>;
  input parameter symbol :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_scanner_lookup_symbol";
end;

define C-function g-scanner-unexp-token
  input parameter scanner :: <GScanner>;
  input parameter expected_token :: <GTokenType>;
  input parameter identifier_spec :: <c-string>;
  input parameter symbol_spec :: <c-string>;
  input parameter symbol_name :: <c-string>;
  input parameter message :: <c-string>;
  input parameter is_error :: <gint>;
  c-name: "g_scanner_unexp_token";
end;

define C-function g-scanner-error
  input parameter scanner :: <GScanner>;
  input parameter format :: <c-string>;
  c-name: "g_scanner_error";
end;

define C-function g-scanner-warn
  input parameter scanner :: <GScanner>;
  input parameter format :: <c-string>;
  c-name: "g_scanner_warn";
end;

define constant $G-CSET-A-2-Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

define constant $G-CSET-DIGITS = "0123456789";

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-633>"*/
define constant <GHRFunc> = <anonymous-633>;

define C-function g-hash-table-new
  input parameter hash_func :: <GHashFunc>;
  input parameter key_equal_func :: <GEqualFunc>;
  result res :: <GHashTable>;
  c-name: "g_hash_table_new";
end;

define C-function g-hash-table-new-full
  input parameter hash_func :: <GHashFunc>;
  input parameter key_equal_func :: <GEqualFunc>;
  input parameter key_destroy_func :: <GDestroyNotify>;
  input parameter value_destroy_func :: <GDestroyNotify>;
  result res :: <GHashTable>;
  c-name: "g_hash_table_new_full";
end;

define C-function g-hash-table-destroy
  input parameter hash_table :: <GHashTable>;
  c-name: "g_hash_table_destroy";
end;

define C-function g-hash-table-insert
  input parameter hash_table :: <GHashTable>;
  input parameter key :: <gpointer>;
  input parameter value :: <gpointer>;
  c-name: "g_hash_table_insert";
end;

define C-function g-hash-table-replace
  input parameter hash_table :: <GHashTable>;
  input parameter key :: <gpointer>;
  input parameter value :: <gpointer>;
  c-name: "g_hash_table_replace";
end;

define C-function g-hash-table-remove
  input parameter hash_table :: <GHashTable>;
  input parameter key :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_hash_table_remove";
end;

define C-function g-hash-table-remove-all
  input parameter hash_table :: <GHashTable>;
  c-name: "g_hash_table_remove_all";
end;

define C-function g-hash-table-steal
  input parameter hash_table :: <GHashTable>;
  input parameter key :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_hash_table_steal";
end;

define C-function g-hash-table-steal-all
  input parameter hash_table :: <GHashTable>;
  c-name: "g_hash_table_steal_all";
end;

define C-function g-hash-table-lookup
  input parameter hash_table :: <GHashTable>;
  input parameter key :: <gconstpointer>;
  result res :: <gpointer>;
  c-name: "g_hash_table_lookup";
end;

define C-function g-hash-table-lookup-extended
  input parameter hash_table :: <GHashTable>;
  input parameter lookup_key :: <gconstpointer>;
  input parameter orig_key :: <gpointer*>;
  input parameter value :: <gpointer*>;
  result res :: <gboolean>;
  c-name: "g_hash_table_lookup_extended";
end;

define C-function g-hash-table-foreach
  input parameter hash_table :: <GHashTable>;
  input parameter func :: <GHFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_hash_table_foreach";
end;

define C-function g-hash-table-find
  input parameter hash_table :: <GHashTable>;
  input parameter predicate :: <GHRFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_hash_table_find";
end;

define C-function g-hash-table-foreach-remove
  input parameter hash_table :: <GHashTable>;
  input parameter func :: <GHRFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_hash_table_foreach_remove";
end;

define C-function g-hash-table-foreach-steal
  input parameter hash_table :: <GHashTable>;
  input parameter func :: <GHRFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_hash_table_foreach_steal";
end;

define C-function g-hash-table-size
  input parameter hash_table :: <GHashTable>;
  result res :: <guint>;
  c-name: "g_hash_table_size";
end;

define C-function g-hash-table-ref
  input parameter hash_table :: <GHashTable>;
  result res :: <GHashTable>;
  c-name: "g_hash_table_ref";
end;

define C-function g-hash-table-unref
  input parameter hash_table :: <GHashTable>;
  c-name: "g_hash_table_unref";
end;

define C-function g-str-equal
  input parameter v1 :: <gconstpointer>;
  input parameter v2 :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_str_equal";
end;

define C-function g-str-hash
  input parameter v :: <gconstpointer>;
  result res :: <guint>;
  c-name: "g_str_hash";
end;

define C-function g-int-equal
  input parameter v1 :: <gconstpointer>;
  input parameter v2 :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_int_equal";
end;

define C-function g-int-hash
  input parameter v :: <gconstpointer>;
  result res :: <guint>;
  c-name: "g_int_hash";
end;

define C-function g-direct-hash
  input parameter v :: <gconstpointer>;
  result res :: <guint>;
  c-name: "g_direct_hash";
end;

define C-function g-direct-equal
  input parameter v1 :: <gconstpointer>;
  input parameter v2 :: <gconstpointer>;
  result res :: <gboolean>;
  c-name: "g_direct_equal";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-542>"*/
define constant <GDataForeachFunc> = <anonymous-542>;

define C-pointer-type <GData*> => <GData>;
define C-function g-datalist-init
  input parameter datalist :: <GData*>;
  c-name: "g_datalist_init";
end;

define C-function g-datalist-clear
  input parameter datalist :: <GData*>;
  c-name: "g_datalist_clear";
end;

define C-function g-datalist-id-get-data
  input parameter datalist :: <GData*>;
  input parameter key_id :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_datalist_id_get_data";
end;

define C-function g-datalist-id-set-data-full
  input parameter datalist :: <GData*>;
  input parameter key_id :: <GQuark>;
  input parameter data :: <gpointer>;
  input parameter destroy_func :: <GDestroyNotify>;
  c-name: "g_datalist_id_set_data_full";
end;

define C-function g-datalist-id-remove-no-notify
  input parameter datalist :: <GData*>;
  input parameter key_id :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_datalist_id_remove_no_notify";
end;

define C-function g-datalist-foreach
  input parameter datalist :: <GData*>;
  input parameter func :: <GDataForeachFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_datalist_foreach";
end;

define C-function g-datalist-set-flags
  input parameter datalist :: <GData*>;
  input parameter flags :: <guint>;
  c-name: "g_datalist_set_flags";
end;

define C-function g-datalist-unset-flags
  input parameter datalist :: <GData*>;
  input parameter flags :: <guint>;
  c-name: "g_datalist_unset_flags";
end;

define C-function g-datalist-get-flags
  input parameter datalist :: <GData*>;
  result res :: <guint>;
  c-name: "g_datalist_get_flags";
end;

define C-function g-dataset-destroy
  input parameter dataset_location :: <gconstpointer>;
  c-name: "g_dataset_destroy";
end;

define C-function g-dataset-id-get-data
  input parameter dataset_location :: <gconstpointer>;
  input parameter key_id :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_dataset_id_get_data";
end;

define C-function g-dataset-id-set-data-full
  input parameter dataset_location :: <gconstpointer>;
  input parameter key_id :: <GQuark>;
  input parameter data :: <gpointer>;
  input parameter destroy_func :: <GDestroyNotify>;
  c-name: "g_dataset_id_set_data_full";
end;

define C-function g-dataset-id-remove-no-notify
  input parameter dataset_location :: <gconstpointer>;
  input parameter key_id :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_dataset_id_remove_no_notify";
end;

define C-function g-dataset-foreach
  input parameter dataset_location :: <gconstpointer>;
  input parameter func :: <GDataForeachFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_dataset_foreach";
end;

define constant $G-DATALIST-FLAGS-MASK = 3;

define C-subtype <_GRelation> (<C-void*>) end;
define constant <GRelation> = <_GRelation>;

define C-subtype <_GTuples> (<C-void*>) end;
define constant <GTuples> = <_GTuples>;

define C-function g-relation-new
  input parameter fields :: <gint>;
  result res :: <GRelation>;
  c-name: "g_relation_new";
end;

define C-function g-relation-destroy
  input parameter relation :: <GRelation>;
  c-name: "g_relation_destroy";
end;

define C-function g-relation-index
  input parameter relation :: <GRelation>;
  input parameter field :: <gint>;
  input parameter hash_func :: <GHashFunc>;
  input parameter key_equal_func :: <GEqualFunc>;
  c-name: "g_relation_index";
end;

define C-function g-relation-insert
  input parameter relation :: <GRelation>;
  c-name: "g_relation_insert";
end;

define C-function g-relation-delete
  input parameter relation :: <GRelation>;
  input parameter key :: <gconstpointer>;
  input parameter field :: <gint>;
  result res :: <gint>;
  c-name: "g_relation_delete";
end;

define C-function g-relation-select
  input parameter relation :: <GRelation>;
  input parameter key :: <gconstpointer>;
  input parameter field :: <gint>;
  result res :: <GTuples>;
  c-name: "g_relation_select";
end;

define C-function g-relation-count
  input parameter relation :: <GRelation>;
  input parameter key :: <gconstpointer>;
  input parameter field :: <gint>;
  result res :: <gint>;
  c-name: "g_relation_count";
end;

define C-function g-relation-exists
  input parameter relation :: <GRelation>;
  result res :: <gboolean>;
  c-name: "g_relation_exists";
end;

define C-function g-relation-print
  input parameter relation :: <GRelation>;
  c-name: "g_relation_print";
end;

define C-function g-tuples-destroy
  input parameter tuples :: <GTuples>;
  c-name: "g_tuples_destroy";
end;

define C-function g-tuples-index
  input parameter tuples :: <GTuples>;
  input parameter index_ :: <gint>;
  input parameter field :: <gint>;
  result res :: <gpointer>;
  c-name: "g_tuples_index";
end;

define C-subtype <_GRand> (<C-void*>) end;
define constant <GRand> = <_GRand>;

define C-function g-rand-new-with-seed
  input parameter seed :: <guint32>;
  result res :: <GRand>;
  c-name: "g_rand_new_with_seed";
end;

define C-function g-rand-new-with-seed-array
  input parameter seed :: <guint32*>;
  input parameter seed_length :: <guint>;
  result res :: <GRand>;
  c-name: "g_rand_new_with_seed_array";
end;

define C-function g-rand-new
  result res :: <GRand>;
  c-name: "g_rand_new";
end;

define C-function g-rand-free
  input parameter rand_ :: <GRand>;
  c-name: "g_rand_free";
end;

define C-function g-rand-copy
  input parameter rand_ :: <GRand>;
  result res :: <GRand>;
  c-name: "g_rand_copy";
end;

define C-function g-rand-set-seed
  input parameter rand_ :: <GRand>;
  input parameter seed :: <guint32>;
  c-name: "g_rand_set_seed";
end;

define C-function g-rand-set-seed-array
  input parameter rand_ :: <GRand>;
  input parameter seed :: <guint32*>;
  input parameter seed_length :: <guint>;
  c-name: "g_rand_set_seed_array";
end;

define C-function g-rand-int
  input parameter rand_ :: <GRand>;
  result res :: <guint32>;
  c-name: "g_rand_int";
end;

define C-function g-rand-int-range
  input parameter rand_ :: <GRand>;
  input parameter begin :: <gint32>;
  input parameter end :: <gint32>;
  result res :: <gint32>;
  c-name: "g_rand_int_range";
end;

define C-function g-rand-double
  input parameter rand_ :: <GRand>;
  result res :: <gdouble>;
  c-name: "g_rand_double";
end;

define C-function g-rand-double-range
  input parameter rand_ :: <GRand>;
  input parameter begin :: <gdouble>;
  input parameter end :: <gdouble>;
  result res :: <gdouble>;
  c-name: "g_rand_double_range";
end;

define C-function g-random-set-seed
  input parameter seed :: <guint32>;
  c-name: "g_random_set_seed";
end;

define C-function g-random-int
  result res :: <guint32>;
  c-name: "g_random_int";
end;

define C-function g-random-int-range
  input parameter begin :: <gint32>;
  input parameter end :: <gint32>;
  result res :: <gint32>;
  c-name: "g_random_int_range";
end;

define C-function g-random-double
  result res :: <gdouble>;
  c-name: "g_random_double";
end;

define C-function g-random-double-range
  input parameter begin :: <gdouble>;
  input parameter end :: <gdouble>;
  result res :: <gdouble>;
  c-name: "g_random_double_range";
end;

define C-subtype <_GQueue> (<C-void*>) end;
define constant <GQueue> = <_GQueue>;

define C-function g-queue-new
  result res :: <GQueue>;
  c-name: "g_queue_new";
end;

define C-function g-queue-free
  input parameter queue :: <GQueue>;
  c-name: "g_queue_free";
end;

define C-function g-queue-is-empty
  input parameter queue :: <GQueue>;
  result res :: <gboolean>;
  c-name: "g_queue_is_empty";
end;

define C-function g-queue-get-length
  input parameter queue :: <GQueue>;
  result res :: <guint>;
  c-name: "g_queue_get_length";
end;

define C-function g-queue-reverse
  input parameter queue :: <GQueue>;
  c-name: "g_queue_reverse";
end;

define C-function g-queue-copy
  input parameter queue :: <GQueue>;
  result res :: <GQueue>;
  c-name: "g_queue_copy";
end;

define C-function g-queue-foreach
  input parameter queue :: <GQueue>;
  input parameter func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_queue_foreach";
end;

define C-function g-queue-find
  input parameter queue :: <GQueue>;
  input parameter data :: <gconstpointer>;
  result res :: <GList>;
  c-name: "g_queue_find";
end;

define C-function g-queue-find-custom
  input parameter queue :: <GQueue>;
  input parameter data :: <gconstpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GList>;
  c-name: "g_queue_find_custom";
end;

define C-function g-queue-sort
  input parameter queue :: <GQueue>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_queue_sort";
end;

define C-function g-queue-push-head
  input parameter queue :: <GQueue>;
  input parameter data :: <gpointer>;
  c-name: "g_queue_push_head";
end;

define C-function g-queue-push-tail
  input parameter queue :: <GQueue>;
  input parameter data :: <gpointer>;
  c-name: "g_queue_push_tail";
end;

define C-function g-queue-push-nth
  input parameter queue :: <GQueue>;
  input parameter data :: <gpointer>;
  input parameter n :: <gint>;
  c-name: "g_queue_push_nth";
end;

define C-function g-queue-pop-head
  input parameter queue :: <GQueue>;
  result res :: <gpointer>;
  c-name: "g_queue_pop_head";
end;

define C-function g-queue-pop-tail
  input parameter queue :: <GQueue>;
  result res :: <gpointer>;
  c-name: "g_queue_pop_tail";
end;

define C-function g-queue-pop-nth
  input parameter queue :: <GQueue>;
  input parameter n :: <guint>;
  result res :: <gpointer>;
  c-name: "g_queue_pop_nth";
end;

define C-function g-queue-peek-head
  input parameter queue :: <GQueue>;
  result res :: <gpointer>;
  c-name: "g_queue_peek_head";
end;

define C-function g-queue-peek-tail
  input parameter queue :: <GQueue>;
  result res :: <gpointer>;
  c-name: "g_queue_peek_tail";
end;

define C-function g-queue-peek-nth
  input parameter queue :: <GQueue>;
  input parameter n :: <guint>;
  result res :: <gpointer>;
  c-name: "g_queue_peek_nth";
end;

define C-function g-queue-index
  input parameter queue :: <GQueue>;
  input parameter data :: <gconstpointer>;
  result res :: <gint>;
  c-name: "g_queue_index";
end;

define C-function g-queue-remove
  input parameter queue :: <GQueue>;
  input parameter data :: <gconstpointer>;
  c-name: "g_queue_remove";
end;

define C-function g-queue-remove-all
  input parameter queue :: <GQueue>;
  input parameter data :: <gconstpointer>;
  c-name: "g_queue_remove_all";
end;

define C-function g-queue-insert-before
  input parameter queue :: <GQueue>;
  input parameter sibling :: <GList>;
  input parameter data :: <gpointer>;
  c-name: "g_queue_insert_before";
end;

define C-function g-queue-insert-after
  input parameter queue :: <GQueue>;
  input parameter sibling :: <GList>;
  input parameter data :: <gpointer>;
  c-name: "g_queue_insert_after";
end;

define C-function g-queue-insert-sorted
  input parameter queue :: <GQueue>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_queue_insert_sorted";
end;

define C-function g-queue-push-head-link
  input parameter queue :: <GQueue>;
  input parameter link_ :: <GList>;
  c-name: "g_queue_push_head_link";
end;

define C-function g-queue-push-tail-link
  input parameter queue :: <GQueue>;
  input parameter link_ :: <GList>;
  c-name: "g_queue_push_tail_link";
end;

define C-function g-queue-push-nth-link
  input parameter queue :: <GQueue>;
  input parameter n :: <gint>;
  input parameter link_ :: <GList>;
  c-name: "g_queue_push_nth_link";
end;

define C-function g-queue-pop-head-link
  input parameter queue :: <GQueue>;
  result res :: <GList>;
  c-name: "g_queue_pop_head_link";
end;

define C-function g-queue-pop-tail-link
  input parameter queue :: <GQueue>;
  result res :: <GList>;
  c-name: "g_queue_pop_tail_link";
end;

define C-function g-queue-pop-nth-link
  input parameter queue :: <GQueue>;
  input parameter n :: <guint>;
  result res :: <GList>;
  c-name: "g_queue_pop_nth_link";
end;

define C-function g-queue-peek-head-link
  input parameter queue :: <GQueue>;
  result res :: <GList>;
  c-name: "g_queue_peek_head_link";
end;

define C-function g-queue-peek-tail-link
  input parameter queue :: <GQueue>;
  result res :: <GList>;
  c-name: "g_queue_peek_tail_link";
end;

define C-function g-queue-peek-nth-link
  input parameter queue :: <GQueue>;
  input parameter n :: <guint>;
  result res :: <GList>;
  c-name: "g_queue_peek_nth_link";
end;

define C-function g-queue-link-index
  input parameter queue :: <GQueue>;
  input parameter link_ :: <GList>;
  result res :: <gint>;
  c-name: "g_queue_link_index";
end;

define C-function g-queue-unlink
  input parameter queue :: <GQueue>;
  input parameter link_ :: <GList>;
  c-name: "g_queue_unlink";
end;

define C-function g-queue-delete-link
  input parameter queue :: <GQueue>;
  input parameter link_ :: <GList>;
  c-name: "g_queue_delete_link";
end;

define C-function g-list-alloc
  result res :: <GList>;
  c-name: "g_list_alloc";
end;

define C-function g-list-free
  input parameter list :: <GList>;
  c-name: "g_list_free";
end;

define C-function g-list-free-1
  input parameter list :: <GList>;
  c-name: "g_list_free_1";
end;

define C-function g-list-append
  input parameter list :: <GList>;
  input parameter data :: <gpointer>;
  result res :: <GList>;
  c-name: "g_list_append";
end;

define C-function g-list-prepend
  input parameter list :: <GList>;
  input parameter data :: <gpointer>;
  result res :: <GList>;
  c-name: "g_list_prepend";
end;

define C-function g-list-insert
  input parameter list :: <GList>;
  input parameter data :: <gpointer>;
  input parameter position :: <gint>;
  result res :: <GList>;
  c-name: "g_list_insert";
end;

define C-function g-list-insert-sorted
  input parameter list :: <GList>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GList>;
  c-name: "g_list_insert_sorted";
end;

define C-function g-list-insert-sorted-with-data
  input parameter list :: <GList>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GList>;
  c-name: "g_list_insert_sorted_with_data";
end;

define C-function g-list-insert-before
  input parameter list :: <GList>;
  input parameter sibling :: <GList>;
  input parameter data :: <gpointer>;
  result res :: <GList>;
  c-name: "g_list_insert_before";
end;

define C-function g-list-concat
  input parameter list1 :: <GList>;
  input parameter list2 :: <GList>;
  result res :: <GList>;
  c-name: "g_list_concat";
end;

define C-function g-list-remove
  input parameter list :: <GList>;
  input parameter data :: <gconstpointer>;
  result res :: <GList>;
  c-name: "g_list_remove";
end;

define C-function g-list-remove-all
  input parameter list :: <GList>;
  input parameter data :: <gconstpointer>;
  result res :: <GList>;
  c-name: "g_list_remove_all";
end;

define C-function g-list-remove-link
  input parameter list :: <GList>;
  input parameter llink :: <GList>;
  result res :: <GList>;
  c-name: "g_list_remove_link";
end;

define C-function g-list-delete-link
  input parameter list :: <GList>;
  input parameter link_ :: <GList>;
  result res :: <GList>;
  c-name: "g_list_delete_link";
end;

define C-function g-list-reverse
  input parameter list :: <GList>;
  result res :: <GList>;
  c-name: "g_list_reverse";
end;

define C-function g-list-copy
  input parameter list :: <GList>;
  result res :: <GList>;
  c-name: "g_list_copy";
end;

define C-function g-list-nth
  input parameter list :: <GList>;
  input parameter n :: <guint>;
  result res :: <GList>;
  c-name: "g_list_nth";
end;

define C-function g-list-nth-prev
  input parameter list :: <GList>;
  input parameter n :: <guint>;
  result res :: <GList>;
  c-name: "g_list_nth_prev";
end;

define C-function g-list-find
  input parameter list :: <GList>;
  input parameter data :: <gconstpointer>;
  result res :: <GList>;
  c-name: "g_list_find";
end;

define C-function g-list-find-custom
  input parameter list :: <GList>;
  input parameter data :: <gconstpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GList>;
  c-name: "g_list_find_custom";
end;

define C-function g-list-position
  input parameter list :: <GList>;
  input parameter llink :: <GList>;
  result res :: <gint>;
  c-name: "g_list_position";
end;

define C-function g-list-index
  input parameter list :: <GList>;
  input parameter data :: <gconstpointer>;
  result res :: <gint>;
  c-name: "g_list_index";
end;

define C-function g-list-last
  input parameter list :: <GList>;
  result res :: <GList>;
  c-name: "g_list_last";
end;

define C-function g-list-first
  input parameter list :: <GList>;
  result res :: <GList>;
  c-name: "g_list_first";
end;

define C-function g-list-length
  input parameter list :: <GList>;
  result res :: <guint>;
  c-name: "g_list_length";
end;

define C-function g-list-foreach
  input parameter list :: <GList>;
  input parameter func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_list_foreach";
end;

define C-function g-list-sort
  input parameter list :: <GList>;
  input parameter compare_func :: <GCompareFunc>;
  result res :: <GList>;
  c-name: "g_list_sort";
end;

define C-function g-list-sort-with-data
  input parameter list :: <GList>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GList>;
  c-name: "g_list_sort_with_data";
end;

define C-function g-list-nth-data
  input parameter list :: <GList>;
  input parameter n :: <guint>;
  result res :: <gpointer>;
  c-name: "g_list_nth_data";
end;

define C-function g-list-push-allocator
  input parameter allocator :: <gpointer>;
  c-name: "g_list_push_allocator";
end;

define C-function g-list-pop-allocator
  c-name: "g_list_pop_allocator";
end;

define constant g-list-free1 = g-list-free-1;

define C-function g-qsort-with-data
  input parameter pbase :: <gconstpointer>;
  input parameter total_elems :: <gint>;
  input parameter size :: <gsize>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_qsort_with_data";
end;

define C-function g-spaced-primes-closest
  input parameter num :: <guint>;
  result res :: <guint>;
  c-name: "g_spaced_primes_closest";
end;

define C-subtype <_GPatternSpec> (<C-void*>) end;
define constant <GPatternSpec> = <_GPatternSpec>;

define C-function g-pattern-spec-new
  input parameter pattern :: <c-string>;
  result res :: <GPatternSpec>;
  c-name: "g_pattern_spec_new";
end;

define C-function g-pattern-spec-free
  input parameter pspec :: <GPatternSpec>;
  c-name: "g_pattern_spec_free";
end;

define C-function g-pattern-spec-equal
  input parameter pspec1 :: <GPatternSpec>;
  input parameter pspec2 :: <GPatternSpec>;
  result res :: <gboolean>;
  c-name: "g_pattern_spec_equal";
end;

define C-function g-pattern-match
  input parameter pspec :: <GPatternSpec>;
  input parameter string_length :: <guint>;
  input parameter string :: <c-string>;
  input parameter string_reversed :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_pattern_match";
end;

define C-function g-pattern-match-string
  input parameter pspec :: <GPatternSpec>;
  input parameter string :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_pattern_match_string";
end;

define C-function g-pattern-match-simple
  input parameter pattern :: <c-string>;
  input parameter string :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_pattern_match_simple";
end;

define C-subtype <_GOptionContext> (<C-void*>) end;
define constant <GOptionContext> = <_GOptionContext>;

define C-subtype <_GOptionGroup> (<C-void*>) end;
define constant <GOptionGroup> = <_GOptionGroup>;

define constant <GOptionArg> = limited(<integer>, min: 0, max: 8);
define constant $G-OPTION-ARG-NONE :: <GOptionArg> = 0;
define constant $G-OPTION-ARG-STRING :: <GOptionArg> = 1;
define constant $G-OPTION-ARG-INT :: <GOptionArg> = 2;
define constant $G-OPTION-ARG-CALLBACK :: <GOptionArg> = 3;
define constant $G-OPTION-ARG-FILENAME :: <GOptionArg> = 4;
define constant $G-OPTION-ARG-STRING-ARRAY :: <GOptionArg> = 5;
define constant $G-OPTION-ARG-FILENAME-ARRAY :: <GOptionArg> = 6;
define constant $G-OPTION-ARG-DOUBLE :: <GOptionArg> = 7;
define constant $G-OPTION-ARG-INT64 :: <GOptionArg> = 8;

define C-subtype <_GOptionEntry> (<C-void*>) end;
define constant <GOptionEntry> = <_GOptionEntry>;

define constant <GOptionFlags> = limited(<integer>, min: 1, max: 64);
define constant $G-OPTION-FLAG-HIDDEN :: <GOptionFlags> = 1;
define constant $G-OPTION-FLAG-IN-MAIN :: <GOptionFlags> = 2;
define constant $G-OPTION-FLAG-REVERSE :: <GOptionFlags> = 4;
define constant $G-OPTION-FLAG-NO-ARG :: <GOptionFlags> = 8;
define constant $G-OPTION-FLAG-FILENAME :: <GOptionFlags> = 16;
define constant $G-OPTION-FLAG-OPTIONAL-ARG :: <GOptionFlags> = 32;
define constant $G-OPTION-FLAG-NOALIAS :: <GOptionFlags> = 64;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1117>"*/
define constant <GOptionArgFunc> = <anonymous-1117>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1118>"*/
define constant <GOptionParseFunc> = <anonymous-1118>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1119>"*/
define constant <GOptionErrorFunc> = <anonymous-1119>;

define constant <GOptionError> = limited(<integer>, min: 0, max: 2);
define constant $G-OPTION-ERROR-UNKNOWN-OPTION :: <GOptionError> = 0;
define constant $G-OPTION-ERROR-BAD-VALUE :: <GOptionError> = 1;
define constant $G-OPTION-ERROR-FAILED :: <GOptionError> = 2;

define C-function g-option-error-quark
  result res :: <GQuark>;
  c-name: "g_option_error_quark";
end;

define C-function g-option-context-new
  input parameter parameter_string :: <c-string>;
  result res :: <GOptionContext>;
  c-name: "g_option_context_new";
end;

define C-function g-option-context-set-summary
  input parameter context :: <GOptionContext>;
  input parameter summary :: <c-string>;
  c-name: "g_option_context_set_summary";
end;

define C-function g-option-context-get-summary
  input parameter context :: <GOptionContext>;
  result res :: <c-string>;
  c-name: "g_option_context_get_summary";
end;

define C-function g-option-context-set-description
  input parameter context :: <GOptionContext>;
  input parameter description :: <c-string>;
  c-name: "g_option_context_set_description";
end;

define C-function g-option-context-get-description
  input parameter context :: <GOptionContext>;
  result res :: <c-string>;
  c-name: "g_option_context_get_description";
end;

define C-function g-option-context-free
  input parameter context :: <GOptionContext>;
  c-name: "g_option_context_free";
end;

define C-function g-option-context-set-help-enabled
  input parameter context :: <GOptionContext>;
  input parameter help_enabled :: <gboolean>;
  c-name: "g_option_context_set_help_enabled";
end;

define C-function g-option-context-get-help-enabled
  input parameter context :: <GOptionContext>;
  result res :: <gboolean>;
  c-name: "g_option_context_get_help_enabled";
end;

define C-function g-option-context-set-ignore-unknown-options
  input parameter context :: <GOptionContext>;
  input parameter ignore_unknown :: <gboolean>;
  c-name: "g_option_context_set_ignore_unknown_options";
end;

define C-function g-option-context-get-ignore-unknown-options
  input parameter context :: <GOptionContext>;
  result res :: <gboolean>;
  c-name: "g_option_context_get_ignore_unknown_options";
end;

define C-function g-option-context-add-main-entries
  input parameter context :: <GOptionContext>;
  input parameter entries :: <GOptionEntry>;
  input parameter translation_domain :: <c-string>;
  c-name: "g_option_context_add_main_entries";
end;

define C-function g-option-context-parse
  input parameter context :: <GOptionContext>;
  input parameter argc :: <gint*>;
  input parameter argv :: <gchar***>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_option_context_parse";
end;

define C-function g-option-context-set-translate-func
  input parameter context :: <GOptionContext>;
  input parameter func :: <GTranslateFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy_notify :: <GDestroyNotify>;
  c-name: "g_option_context_set_translate_func";
end;

define C-function g-option-context-set-translation-domain
  input parameter context :: <GOptionContext>;
  input parameter domain :: <c-string>;
  c-name: "g_option_context_set_translation_domain";
end;

define C-function g-option-context-add-group
  input parameter context :: <GOptionContext>;
  input parameter group :: <GOptionGroup>;
  c-name: "g_option_context_add_group";
end;

define C-function g-option-context-set-main-group
  input parameter context :: <GOptionContext>;
  input parameter group :: <GOptionGroup>;
  c-name: "g_option_context_set_main_group";
end;

define C-function g-option-context-get-main-group
  input parameter context :: <GOptionContext>;
  result res :: <GOptionGroup>;
  c-name: "g_option_context_get_main_group";
end;

define C-function g-option-context-set-input-is-utf8
  input parameter context :: <GOptionContext>;
  input parameter is_utf8 :: <gboolean>;
  c-name: "g_option_context_set_input_is_utf8";
end;

define C-function g-option-context-get-input-is-utf8
  input parameter context :: <GOptionContext>;
  result res :: <gboolean>;
  c-name: "g_option_context_get_input_is_utf8";
end;

define C-function g-option-group-new
  input parameter name :: <c-string>;
  input parameter description :: <c-string>;
  input parameter help_description :: <c-string>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  result res :: <GOptionGroup>;
  c-name: "g_option_group_new";
end;

define C-function g-option-group-set-parse-hooks
  input parameter group :: <GOptionGroup>;
  input parameter pre_parse_func :: <GOptionParseFunc>;
  input parameter post_parse_func :: <GOptionParseFunc>;
  c-name: "g_option_group_set_parse_hooks";
end;

define C-function g-option-group-set-error-hook
  input parameter group :: <GOptionGroup>;
  input parameter error_func :: <GOptionErrorFunc>;
  c-name: "g_option_group_set_error_hook";
end;

define C-function g-option-group-free
  input parameter group :: <GOptionGroup>;
  c-name: "g_option_group_free";
end;

define C-function g-option-group-add-entries
  input parameter group :: <GOptionGroup>;
  input parameter entries :: <GOptionEntry>;
  c-name: "g_option_group_add_entries";
end;

define C-function g-option-group-set-translate-func
  input parameter group :: <GOptionGroup>;
  input parameter func :: <GTranslateFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy_notify :: <GDestroyNotify>;
  c-name: "g_option_group_set_translate_func";
end;

define C-function g-option-group-set-translation-domain
  input parameter group :: <GOptionGroup>;
  input parameter domain :: <c-string>;
  c-name: "g_option_group_set_translation_domain";
end;

define constant $G-OPTION-REMAINING = "";

define C-function g-printf-string-upper-bound
  input parameter format :: <c-string>;
  input parameter args :: <va-list>;
  result res :: <gsize>;
  c-name: "g_printf_string_upper_bound";
end;

define constant <GLogLevelFlags> = limited(<integer>, min: -4, max: 128);
define constant $G-LOG-FLAG-RECURSION :: <GLogLevelFlags> = 1;
define constant $G-LOG-FLAG-FATAL :: <GLogLevelFlags> = 2;
define constant $G-LOG-LEVEL-ERROR :: <GLogLevelFlags> = 4;
define constant $G-LOG-LEVEL-CRITICAL :: <GLogLevelFlags> = 8;
define constant $G-LOG-LEVEL-WARNING :: <GLogLevelFlags> = 16;
define constant $G-LOG-LEVEL-MESSAGE :: <GLogLevelFlags> = 32;
define constant $G-LOG-LEVEL-INFO :: <GLogLevelFlags> = 64;
define constant $G-LOG-LEVEL-DEBUG :: <GLogLevelFlags> = 128;
define constant $G-LOG-LEVEL-MASK :: <GLogLevelFlags> = -4;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1060>"*/
define constant <GLogFunc> = <anonymous-1060>;

define C-function g-log-set-handler
  input parameter log_domain :: <c-string>;
  input parameter log_levels :: <GLogLevelFlags>;
  input parameter log_func :: <GLogFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_log_set_handler";
end;

define C-function g-log-remove-handler
  input parameter log_domain :: <c-string>;
  input parameter handler_id :: <guint>;
  c-name: "g_log_remove_handler";
end;

define C-function g-log-default-handler
  input parameter log_domain :: <c-string>;
  input parameter log_level :: <GLogLevelFlags>;
  input parameter message :: <c-string>;
  input parameter unused_data :: <gpointer>;
  c-name: "g_log_default_handler";
end;

define C-function g-log-set-default-handler
  input parameter log_func :: <GLogFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GLogFunc>;
  c-name: "g_log_set_default_handler";
end;

define C-function g-log
  input parameter log_domain :: <c-string>;
  input parameter log_level :: <GLogLevelFlags>;
  input parameter format :: <c-string>;
  c-name: "g_log";
end;

define C-function g-logv
  input parameter log_domain :: <c-string>;
  input parameter log_level :: <GLogLevelFlags>;
  input parameter format :: <c-string>;
  input parameter args :: <va-list>;
  c-name: "g_logv";
end;

define C-function g-log-set-fatal-mask
  input parameter log_domain :: <c-string>;
  input parameter fatal_mask :: <GLogLevelFlags>;
  result res :: <GLogLevelFlags>;
  c-name: "g_log_set_fatal_mask";
end;

define C-function g-log-set-always-fatal
  input parameter fatal_mask :: <GLogLevelFlags>;
  result res :: <GLogLevelFlags>;
  c-name: "g_log_set_always_fatal";
end;

define C-function _g-log-fallback-handler
  input parameter log_domain :: <c-string>;
  input parameter log_level :: <GLogLevelFlags>;
  input parameter message :: <c-string>;
  input parameter unused_data :: <gpointer>;
  c-name: "_g_log_fallback_handler";
end;

define C-function g-return-if-fail-warning
  input parameter log_domain :: <c-string>;
  input parameter pretty_function :: <c-string>;
  input parameter expression :: <c-string>;
  c-name: "g_return_if_fail_warning";
end;

define C-function g-assert-warning
  input parameter log_domain :: <c-string>;
  input parameter file :: <c-string>;
  input parameter line :: <integer>;
  input parameter pretty_function :: <c-string>;
  input parameter expression :: <c-string>;
  c-name: "g_assert_warning";
end;

define C-function g-error
  input parameter format :: <c-string>;
  c-name: "g_error";
end;

define C-function g-message
  input parameter format :: <c-string>;
  c-name: "g_message";
end;

define C-function g-critical
  input parameter format :: <c-string>;
  c-name: "g_critical";
end;

define C-function g-warning
  input parameter format :: <c-string>;
  c-name: "g_warning";
end;

define C-function g-debug
  input parameter format :: <c-string>;
  c-name: "g_debug";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1077>"*/
define constant <GPrintFunc> = <anonymous-1077>;

define C-function g-print
  input parameter format :: <c-string>;
  c-name: "g_print";
end;

define C-function g-set-print-handler
  input parameter func :: <GPrintFunc>;
  result res :: <GPrintFunc>;
  c-name: "g_set_print_handler";
end;

define C-function g-printerr
  input parameter format :: <c-string>;
  c-name: "g_printerr";
end;

define C-function g-set-printerr-handler
  input parameter func :: <GPrintFunc>;
  result res :: <GPrintFunc>;
  c-name: "g_set_printerr_handler";
end;

define constant $G-LOG-LEVEL-USER-SHIFT = 8;

define constant $G-LOG-FATAL-MASK = 0;

define constant <GMarkupError> = limited(<integer>, min: 0, max: 5);
define constant $G-MARKUP-ERROR-BAD-UTF8 :: <GMarkupError> = 0;
define constant $G-MARKUP-ERROR-EMPTY :: <GMarkupError> = 1;
define constant $G-MARKUP-ERROR-PARSE :: <GMarkupError> = 2;
define constant $G-MARKUP-ERROR-UNKNOWN-ELEMENT :: <GMarkupError> = 3;
define constant $G-MARKUP-ERROR-UNKNOWN-ATTRIBUTE :: <GMarkupError> = 4;
define constant $G-MARKUP-ERROR-INVALID-CONTENT :: <GMarkupError> = 5;

define C-function g-markup-error-quark
  result res :: <GQuark>;
  c-name: "g_markup_error_quark";
end;

define constant <GMarkupParseFlags> = limited(<integer>, min: 1, max: 2);
define constant $G-MARKUP-DO-NOT-USE-THIS-UNSUPPORTED-FLAG :: <GMarkupParseFlags> = 1;
define constant $G-MARKUP-TREAT-CDATA-AS-TEXT :: <GMarkupParseFlags> = 2;

define C-subtype <_GMarkupParseContext> (<C-void*>) end;
define constant <GMarkupParseContext> = <_GMarkupParseContext>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1044>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1045>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1046>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1047>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1048>"*/
define C-subtype <_GMarkupParser> (<C-void*>) end;
define constant <GMarkupParser> = <_GMarkupParser>;

define C-function g-markup-parse-context-new
  input parameter parser :: <GMarkupParser>;
  input parameter flags :: <GMarkupParseFlags>;
  input parameter user_data :: <gpointer>;
  input parameter user_data_dnotify :: <GDestroyNotify>;
  result res :: <GMarkupParseContext>;
  c-name: "g_markup_parse_context_new";
end;

define C-function g-markup-parse-context-free
  input parameter context :: <GMarkupParseContext>;
  c-name: "g_markup_parse_context_free";
end;

define C-function g-markup-parse-context-parse
  input parameter context :: <GMarkupParseContext>;
  input parameter text :: <c-string>;
  input parameter text_len :: <gssize>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_markup_parse_context_parse";
end;

define C-function g-markup-parse-context-end-parse
  input parameter context :: <GMarkupParseContext>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_markup_parse_context_end_parse";
end;

define C-function g-markup-parse-context-get-element
  input parameter context :: <GMarkupParseContext>;
  result res :: <c-string>;
  c-name: "g_markup_parse_context_get_element";
end;

define C-function g-markup-parse-context-get-position
  input parameter context :: <GMarkupParseContext>;
  input parameter line_number :: <gint*>;
  input parameter char_number :: <gint*>;
  c-name: "g_markup_parse_context_get_position";
end;

define C-function g-markup-escape-text
  input parameter text :: <c-string>;
  input parameter length :: <gssize>;
  result res :: <c-string>;
  c-name: "g_markup_escape_text";
end;

define C-function g-markup-printf-escaped
  input parameter format :: <c-string>;
  result res :: <c-string>;
  c-name: "g_markup_printf_escaped";
end;

define C-function g-markup-vprintf-escaped
  input parameter format :: <c-string>;
  input parameter args :: <va-list>;
  result res :: <c-string>;
  c-name: "g_markup_vprintf_escaped";
end;

define C-subtype <_GMappedFile> (<C-void*>) end;
define constant <GMappedFile> = <_GMappedFile>;

define C-function g-mapped-file-new
  input parameter filename :: <c-string>;
  input parameter writable :: <gboolean>;
  input parameter error :: <GError*>;
  result res :: <GMappedFile>;
  c-name: "g_mapped_file_new";
end;

define C-function g-mapped-file-get-length
  input parameter file :: <GMappedFile>;
  result res :: <gsize>;
  c-name: "g_mapped_file_get_length";
end;

define C-function g-mapped-file-get-contents
  input parameter file :: <GMappedFile>;
  result res :: <c-string>;
  c-name: "g_mapped_file_get_contents";
end;

define C-function g-mapped-file-free
  input parameter file :: <GMappedFile>;
  c-name: "g_mapped_file_free";
end;

define C-subtype <_GMainContext> (<C-void*>) end;
define constant <GMainContext> = <_GMainContext>;

define C-subtype <_GMainLoop> (<C-void*>) end;
define constant <GMainLoop> = <_GMainLoop>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-722>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-723>"*/
define constant <GSource> = <_GSource>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-720>"*/
define constant <GSourceFunc> = <anonymous-720>;

define C-pointer-type <GSourceFunc*> => <GSourceFunc>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-724>"*/
define C-subtype <_GSourceCallbackFuncs> (<C-void*>) end;
define constant <GSourceCallbackFuncs> = <_GSourceCallbackFuncs>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-726>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-727>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-728>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-729>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-725>"*/
define constant <GSourceDummyMarshal> = <anonymous-725>;

define C-subtype <_GSourceFuncs> (<C-void*>) end;
define constant <GSourceFuncs> = <_GSourceFuncs>;

define C-subtype <_GSource> (<C-void*>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-721>"*/
define constant <GChildWatchFunc> = <anonymous-721>;

define C-subtype <_GPollFD> (<C-void*>) end;
define constant <GPollFD> = <_GPollFD>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-730>"*/
define constant <GPollFunc> = <anonymous-730>;

define C-function g-main-context-new
  result res :: <GMainContext>;
  c-name: "g_main_context_new";
end;

define C-function g-main-context-ref
  input parameter context :: <GMainContext>;
  result res :: <GMainContext>;
  c-name: "g_main_context_ref";
end;

define C-function g-main-context-unref
  input parameter context :: <GMainContext>;
  c-name: "g_main_context_unref";
end;

define C-function g-main-context-default
  result res :: <GMainContext>;
  c-name: "g_main_context_default";
end;

define C-function g-main-context-iteration
  input parameter context :: <GMainContext>;
  input parameter may_block :: <gboolean>;
  result res :: <gboolean>;
  c-name: "g_main_context_iteration";
end;

define C-function g-main-context-pending
  input parameter context :: <GMainContext>;
  result res :: <gboolean>;
  c-name: "g_main_context_pending";
end;

define C-function g-main-context-find-source-by-id
  input parameter context :: <GMainContext>;
  input parameter source_id :: <guint>;
  result res :: <GSource>;
  c-name: "g_main_context_find_source_by_id";
end;

define C-function g-main-context-find-source-by-user-data
  input parameter context :: <GMainContext>;
  input parameter user_data :: <gpointer>;
  result res :: <GSource>;
  c-name: "g_main_context_find_source_by_user_data";
end;

define C-function g-main-context-find-source-by-funcs-user-data
  input parameter context :: <GMainContext>;
  input parameter funcs :: <GSourceFuncs>;
  input parameter user_data :: <gpointer>;
  result res :: <GSource>;
  c-name: "g_main_context_find_source_by_funcs_user_data";
end;

define C-function g-main-context-wakeup
  input parameter context :: <GMainContext>;
  c-name: "g_main_context_wakeup";
end;

define C-function g-main-context-acquire
  input parameter context :: <GMainContext>;
  result res :: <gboolean>;
  c-name: "g_main_context_acquire";
end;

define C-function g-main-context-release
  input parameter context :: <GMainContext>;
  c-name: "g_main_context_release";
end;

define C-function g-main-context-is-owner
  input parameter context :: <GMainContext>;
  result res :: <gboolean>;
  c-name: "g_main_context_is_owner";
end;

define C-function g-main-context-wait
  input parameter context :: <GMainContext>;
  input parameter cond :: <GCond>;
  input parameter mutex :: <GMutex>;
  result res :: <gboolean>;
  c-name: "g_main_context_wait";
end;

define C-function g-main-context-prepare
  input parameter context :: <GMainContext>;
  input parameter priority :: <gint*>;
  result res :: <gboolean>;
  c-name: "g_main_context_prepare";
end;

define C-function g-main-context-query
  input parameter context :: <GMainContext>;
  input parameter max_priority :: <gint>;
  input parameter timeout_ :: <gint*>;
  input parameter fds :: <GPollFD>;
  input parameter n_fds :: <gint>;
  result res :: <gint>;
  c-name: "g_main_context_query";
end;

define C-function g-main-context-check
  input parameter context :: <GMainContext>;
  input parameter max_priority :: <gint>;
  input parameter fds :: <GPollFD>;
  input parameter n_fds :: <gint>;
  result res :: <gint>;
  c-name: "g_main_context_check";
end;

define C-function g-main-context-dispatch
  input parameter context :: <GMainContext>;
  c-name: "g_main_context_dispatch";
end;

define C-function g-main-context-set-poll-func
  input parameter context :: <GMainContext>;
  input parameter func :: <GPollFunc>;
  c-name: "g_main_context_set_poll_func";
end;

define C-function g-main-context-get-poll-func
  input parameter context :: <GMainContext>;
  result res :: <GPollFunc>;
  c-name: "g_main_context_get_poll_func";
end;

define C-function g-main-context-add-poll
  input parameter context :: <GMainContext>;
  input parameter fd :: <GPollFD>;
  input parameter priority :: <gint>;
  c-name: "g_main_context_add_poll";
end;

define C-function g-main-context-remove-poll
  input parameter context :: <GMainContext>;
  input parameter fd :: <GPollFD>;
  c-name: "g_main_context_remove_poll";
end;

define C-function g-main-depth
  result res :: <gint>;
  c-name: "g_main_depth";
end;

define C-function g-main-current-source
  result res :: <GSource>;
  c-name: "g_main_current_source";
end;

define C-function g-main-loop-new
  input parameter context :: <GMainContext>;
  input parameter is_running :: <gboolean>;
  result res :: <GMainLoop>;
  c-name: "g_main_loop_new";
end;

define C-function g-main-loop-run
  input parameter loop :: <GMainLoop>;
  c-name: "g_main_loop_run";
end;

define C-function g-main-loop-quit
  input parameter loop :: <GMainLoop>;
  c-name: "g_main_loop_quit";
end;

define C-function g-main-loop-ref
  input parameter loop :: <GMainLoop>;
  result res :: <GMainLoop>;
  c-name: "g_main_loop_ref";
end;

define C-function g-main-loop-unref
  input parameter loop :: <GMainLoop>;
  c-name: "g_main_loop_unref";
end;

define C-function g-main-loop-is-running
  input parameter loop :: <GMainLoop>;
  result res :: <gboolean>;
  c-name: "g_main_loop_is_running";
end;

define C-function g-main-loop-get-context
  input parameter loop :: <GMainLoop>;
  result res :: <GMainContext>;
  c-name: "g_main_loop_get_context";
end;

define C-function g-source-new
  input parameter source_funcs :: <GSourceFuncs>;
  input parameter struct_size :: <guint>;
  result res :: <GSource>;
  c-name: "g_source_new";
end;

define C-function g-source-ref
  input parameter source :: <GSource>;
  result res :: <GSource>;
  c-name: "g_source_ref";
end;

define C-function g-source-unref
  input parameter source :: <GSource>;
  c-name: "g_source_unref";
end;

define C-function g-source-attach
  input parameter source :: <GSource>;
  input parameter context :: <GMainContext>;
  result res :: <guint>;
  c-name: "g_source_attach";
end;

define C-function g-source-destroy
  input parameter source :: <GSource>;
  c-name: "g_source_destroy";
end;

define C-function g-source-set-priority
  input parameter source :: <GSource>;
  input parameter priority :: <gint>;
  c-name: "g_source_set_priority";
end;

define C-function g-source-get-priority
  input parameter source :: <GSource>;
  result res :: <gint>;
  c-name: "g_source_get_priority";
end;

define C-function g-source-set-can-recurse
  input parameter source :: <GSource>;
  input parameter can_recurse :: <gboolean>;
  c-name: "g_source_set_can_recurse";
end;

define C-function g-source-get-can-recurse
  input parameter source :: <GSource>;
  result res :: <gboolean>;
  c-name: "g_source_get_can_recurse";
end;

define C-function g-source-get-id
  input parameter source :: <GSource>;
  result res :: <guint>;
  c-name: "g_source_get_id";
end;

define C-function g-source-get-context
  input parameter source :: <GSource>;
  result res :: <GMainContext>;
  c-name: "g_source_get_context";
end;

define C-function g-source-set-callback
  input parameter source :: <GSource>;
  input parameter func :: <GSourceFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  c-name: "g_source_set_callback";
end;

define C-function g-source-set-funcs
  input parameter source :: <GSource>;
  input parameter funcs :: <GSourceFuncs>;
  c-name: "g_source_set_funcs";
end;

define C-function g-source-is-destroyed
  input parameter source :: <GSource>;
  result res :: <gboolean>;
  c-name: "g_source_is_destroyed";
end;

define C-function g-source-set-callback-indirect
  input parameter source :: <GSource>;
  input parameter callback_data :: <gpointer>;
  input parameter callback_funcs :: <GSourceCallbackFuncs>;
  c-name: "g_source_set_callback_indirect";
end;

define C-function g-source-add-poll
  input parameter source :: <GSource>;
  input parameter fd :: <GPollFD>;
  c-name: "g_source_add_poll";
end;

define C-function g-source-remove-poll
  input parameter source :: <GSource>;
  input parameter fd :: <GPollFD>;
  c-name: "g_source_remove_poll";
end;

define C-function g-source-get-current-time
  input parameter source :: <GSource>;
  input parameter timeval :: <GTimeVal>;
  c-name: "g_source_get_current_time";
end;

define C-function g-idle-source-new
  result res :: <GSource>;
  c-name: "g_idle_source_new";
end;

define C-function g-child-watch-source-new
  input parameter pid :: <GPid>;
  result res :: <GSource>;
  c-name: "g_child_watch_source_new";
end;

define C-function g-timeout-source-new
  input parameter interval :: <guint>;
  result res :: <GSource>;
  c-name: "g_timeout_source_new";
end;

define C-function g-get-current-time
  input parameter result :: <GTimeVal>;
  c-name: "g_get_current_time";
end;

define C-function g-source-remove
  input parameter tag :: <guint>;
  result res :: <gboolean>;
  c-name: "g_source_remove";
end;

define C-function g-source-remove-by-user-data
  input parameter user_data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_source_remove_by_user_data";
end;

define C-function g-source-remove-by-funcs-user-data
  input parameter funcs :: <GSourceFuncs>;
  input parameter user_data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_source_remove_by_funcs_user_data";
end;

define C-function g-timeout-add-full
  input parameter priority :: <gint>;
  input parameter interval :: <guint>;
  input parameter function :: <GSourceFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  result res :: <guint>;
  c-name: "g_timeout_add_full";
end;

define C-function g-timeout-add
  input parameter interval :: <guint>;
  input parameter function :: <GSourceFunc>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_timeout_add";
end;

define C-function g-child-watch-add-full
  input parameter priority :: <gint>;
  input parameter pid :: <GPid>;
  input parameter function :: <GChildWatchFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  result res :: <guint>;
  c-name: "g_child_watch_add_full";
end;

define C-function g-child-watch-add
  input parameter pid :: <GPid>;
  input parameter function :: <GChildWatchFunc>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_child_watch_add";
end;

define C-function g-idle-add
  input parameter function :: <GSourceFunc>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_idle_add";
end;

define C-function g-idle-add-full
  input parameter priority :: <gint>;
  input parameter function :: <GSourceFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  result res :: <guint>;
  c-name: "g_idle_add_full";
end;

define C-function g-idle-remove-by-data
  input parameter data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_idle_remove_by_data";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-timeout-funcs"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "g-child-watch-funcs"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "g-idle-funcs"*/
define constant $G-PRIORITY-HIGH = -100;

define constant $G-PRIORITY-DEFAULT = 0;

define constant $G-PRIORITY-HIGH-IDLE = 100;

define constant $G-PRIORITY-DEFAULT-IDLE = 200;

define constant $G-PRIORITY-LOW = 300;

define constant <GKeyFileError> = limited(<integer>, min: 0, max: 5);
define constant $G-KEY-FILE-ERROR-UNKNOWN-ENCODING :: <GKeyFileError> = 0;
define constant $G-KEY-FILE-ERROR-PARSE :: <GKeyFileError> = 1;
define constant $G-KEY-FILE-ERROR-NOT-FOUND :: <GKeyFileError> = 2;
define constant $G-KEY-FILE-ERROR-KEY-NOT-FOUND :: <GKeyFileError> = 3;
define constant $G-KEY-FILE-ERROR-GROUP-NOT-FOUND :: <GKeyFileError> = 4;
define constant $G-KEY-FILE-ERROR-INVALID-VALUE :: <GKeyFileError> = 5;

define C-function g-key-file-error-quark
  result res :: <GQuark>;
  c-name: "g_key_file_error_quark";
end;

define C-subtype <_GKeyFile> (<C-void*>) end;
define constant <GKeyFile> = <_GKeyFile>;

define constant <GKeyFileFlags> = limited(<integer>, min: 0, max: 2);
define constant $G-KEY-FILE-NONE :: <GKeyFileFlags> = 0;
define constant $G-KEY-FILE-KEEP-COMMENTS :: <GKeyFileFlags> = 1;
define constant $G-KEY-FILE-KEEP-TRANSLATIONS :: <GKeyFileFlags> = 2;

define C-function g-key-file-new
  result res :: <GKeyFile>;
  c-name: "g_key_file_new";
end;

define C-function g-key-file-free
  input parameter key_file :: <GKeyFile>;
  c-name: "g_key_file_free";
end;

define C-function g-key-file-set-list-separator
  input parameter key_file :: <GKeyFile>;
  input parameter separator :: <gchar>;
  c-name: "g_key_file_set_list_separator";
end;

define C-function g-key-file-load-from-file
  input parameter key_file :: <GKeyFile>;
  input parameter file :: <c-string>;
  input parameter flags :: <GKeyFileFlags>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_key_file_load_from_file";
end;

define C-function g-key-file-load-from-data
  input parameter key_file :: <GKeyFile>;
  input parameter data :: <c-string>;
  input parameter length :: <gsize>;
  input parameter flags :: <GKeyFileFlags>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_key_file_load_from_data";
end;

define C-function g-key-file-load-from-data-dirs
  input parameter key_file :: <GKeyFile>;
  input parameter file :: <c-string>;
  input parameter full_path :: <gchar**>;
  input parameter flags :: <GKeyFileFlags>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_key_file_load_from_data_dirs";
end;

define C-function g-key-file-to-data
  input parameter key_file :: <GKeyFile>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_key_file_to_data";
end;

define C-function g-key-file-get-start-group
  input parameter key_file :: <GKeyFile>;
  result res :: <c-string>;
  c-name: "g_key_file_get_start_group";
end;

define C-function g-key-file-get-groups
  input parameter key_file :: <GKeyFile>;
  input parameter length :: <gsize*>;
  result res :: <gchar**>;
  c-name: "g_key_file_get_groups";
end;

define C-function g-key-file-get-keys
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gchar**>;
  c-name: "g_key_file_get_keys";
end;

define C-function g-key-file-has-group
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_key_file_has_group";
end;

define C-function g-key-file-has-key
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_key_file_has_key";
end;

define C-function g-key-file-get-value
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_key_file_get_value";
end;

define C-function g-key-file-set-value
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter value :: <c-string>;
  c-name: "g_key_file_set_value";
end;

define C-function g-key-file-get-string
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_key_file_get_string";
end;

define C-function g-key-file-set-string
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter string :: <c-string>;
  c-name: "g_key_file_set_string";
end;

define C-function g-key-file-get-locale-string
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter locale :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_key_file_get_locale_string";
end;

define C-function g-key-file-set-locale-string
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter locale :: <c-string>;
  input parameter string :: <c-string>;
  c-name: "g_key_file_set_locale_string";
end;

define C-function g-key-file-get-boolean
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_key_file_get_boolean";
end;

define C-function g-key-file-set-boolean
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter value :: <gboolean>;
  c-name: "g_key_file_set_boolean";
end;

define C-function g-key-file-get-integer
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gint>;
  c-name: "g_key_file_get_integer";
end;

define C-function g-key-file-set-integer
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter value :: <gint>;
  c-name: "g_key_file_set_integer";
end;

define C-function g-key-file-get-double
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gdouble>;
  c-name: "g_key_file_get_double";
end;

define C-function g-key-file-set-double
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter value :: <gdouble>;
  c-name: "g_key_file_set_double";
end;

define C-function g-key-file-get-string-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gchar**>;
  c-name: "g_key_file_get_string_list";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar*<@>>"*/
define C-function g-key-file-set-string-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter list :: <gchar*<@>>;
  input parameter length :: <gsize>;
  c-name: "g_key_file_set_string_list";
end;

define C-function g-key-file-get-locale-string-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter locale :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gchar**>;
  c-name: "g_key_file_get_locale_string_list";
end;

define C-function g-key-file-set-locale-string-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter locale :: <c-string>;
  input parameter list :: <gchar*<@>>;
  input parameter length :: <gsize>;
  c-name: "g_key_file_set_locale_string_list";
end;

define C-function g-key-file-get-boolean-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gboolean*>;
  c-name: "g_key_file_get_boolean_list";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gboolean<@>>"*/
define C-function g-key-file-set-boolean-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter list :: <gboolean<@>>;
  input parameter length :: <gsize>;
  c-name: "g_key_file_set_boolean_list";
end;

define C-function g-key-file-get-integer-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gint*>;
  c-name: "g_key_file_get_integer_list";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gdouble<@>>"*/
define C-function g-key-file-set-double-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter list :: <gdouble<@>>;
  input parameter length :: <gsize>;
  c-name: "g_key_file_set_double_list";
end;

define C-function g-key-file-get-double-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gdouble*>;
  c-name: "g_key_file_get_double_list";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@>>"*/
define C-function g-key-file-set-integer-list
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter list :: <gint<@>>;
  input parameter length :: <gsize>;
  c-name: "g_key_file_set_integer_list";
end;

define C-function g-key-file-set-comment
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter comment :: <c-string>;
  input parameter error :: <GError*>;
  c-name: "g_key_file_set_comment";
end;

define C-function g-key-file-get-comment
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_key_file_get_comment";
end;

define C-function g-key-file-remove-comment
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  c-name: "g_key_file_remove_comment";
end;

define C-function g-key-file-remove-key
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter key :: <c-string>;
  input parameter error :: <GError*>;
  c-name: "g_key_file_remove_key";
end;

define C-function g-key-file-remove-group
  input parameter key_file :: <GKeyFile>;
  input parameter group_name :: <c-string>;
  input parameter error :: <GError*>;
  c-name: "g_key_file_remove_group";
end;

define constant <GIOStatus> = limited(<integer>, min: 0, max: 3);
define constant $G-IO-STATUS-ERROR :: <GIOStatus> = 0;
define constant $G-IO-STATUS-NORMAL :: <GIOStatus> = 1;
define constant $G-IO-STATUS-EOF :: <GIOStatus> = 2;
define constant $G-IO-STATUS-AGAIN :: <GIOStatus> = 3;

define constant <GIOChannel> = <_GIOChannel>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-943>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-944>"*/
define constant <GSeekType> = limited(<integer>, min: 0, max: 2);
define constant $G-SEEK-CUR :: <GSeekType> = 0;
define constant $G-SEEK-SET :: <GSeekType> = 1;
define constant $G-SEEK-END :: <GSeekType> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-945>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-946>"*/
define constant <GIOCondition> = limited(<integer>, min: 1, max: 32);
define constant $G-IO-IN :: <GIOCondition> = 1;
define constant $G-IO-OUT :: <GIOCondition> = 4;
define constant $G-IO-PRI :: <GIOCondition> = 2;
define constant $G-IO-ERR :: <GIOCondition> = 8;
define constant $G-IO-HUP :: <GIOCondition> = 16;
define constant $G-IO-NVAL :: <GIOCondition> = 32;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-947>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-948>"*/
define constant <GIOFlags> = limited(<integer>, min: 1, max: 31);
define constant $G-IO-FLAG-APPEND :: <GIOFlags> = 1;
define constant $G-IO-FLAG-NONBLOCK :: <GIOFlags> = 2;
define constant $G-IO-FLAG-IS-READABLE :: <GIOFlags> = 4;
define constant $G-IO-FLAG-IS-WRITEABLE :: <GIOFlags> = 8;
define constant $G-IO-FLAG-IS-SEEKABLE :: <GIOFlags> = 16;
define constant $G-IO-FLAG-MASK :: <GIOFlags> = 31;
define constant $G-IO-FLAG-GET-MASK :: <GIOFlags> = 31;
define constant $G-IO-FLAG-SET-MASK :: <GIOFlags> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-949>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-950>"*/
define C-subtype <_GIOFuncs> (<C-void*>) end;
define constant <GIOFuncs> = <_GIOFuncs>;

define C-subtype <_GIConv> (<C-void*>) end;
define constant <GIConv> = <_GIConv>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar<@6>>"*/
define C-subtype <_GIOChannel> (<C-void*>) end;
define constant <GIOError> = limited(<integer>, min: 0, max: 3);
define constant $G-IO-ERROR-NONE :: <GIOError> = 0;
define constant $G-IO-ERROR-AGAIN :: <GIOError> = 1;
define constant $G-IO-ERROR-INVAL :: <GIOError> = 2;
define constant $G-IO-ERROR-UNKNOWN :: <GIOError> = 3;

define constant <GIOChannelError> = limited(<integer>, min: 0, max: 8);
define constant $G-IO-CHANNEL-ERROR-FBIG :: <GIOChannelError> = 0;
define constant $G-IO-CHANNEL-ERROR-INVAL :: <GIOChannelError> = 1;
define constant $G-IO-CHANNEL-ERROR-IO :: <GIOChannelError> = 2;
define constant $G-IO-CHANNEL-ERROR-ISDIR :: <GIOChannelError> = 3;
define constant $G-IO-CHANNEL-ERROR-NOSPC :: <GIOChannelError> = 4;
define constant $G-IO-CHANNEL-ERROR-NXIO :: <GIOChannelError> = 5;
define constant $G-IO-CHANNEL-ERROR-OVERFLOW :: <GIOChannelError> = 6;
define constant $G-IO-CHANNEL-ERROR-PIPE :: <GIOChannelError> = 7;
define constant $G-IO-CHANNEL-ERROR-FAILED :: <GIOChannelError> = 8;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-942>"*/
define constant <GIOFunc> = <anonymous-942>;

define C-function g-io-channel-init
  input parameter channel :: <GIOChannel>;
  c-name: "g_io_channel_init";
end;

define C-function g-io-channel-ref
  input parameter channel :: <GIOChannel>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_ref";
end;

define C-function g-io-channel-unref
  input parameter channel :: <GIOChannel>;
  c-name: "g_io_channel_unref";
end;

define C-function g-io-channel-read
  input parameter channel :: <GIOChannel>;
  input parameter buf :: <c-string>;
  input parameter count :: <gsize>;
  input parameter bytes_read :: <gsize*>;
  result res :: <GIOError>;
  c-name: "g_io_channel_read";
end;

define C-function g-io-channel-write
  input parameter channel :: <GIOChannel>;
  input parameter buf :: <c-string>;
  input parameter count :: <gsize>;
  input parameter bytes_written :: <gsize*>;
  result res :: <GIOError>;
  c-name: "g_io_channel_write";
end;

define C-function g-io-channel-seek
  input parameter channel :: <GIOChannel>;
  input parameter offset :: <gint64>;
  input parameter type :: <GSeekType>;
  result res :: <GIOError>;
  c-name: "g_io_channel_seek";
end;

define C-function g-io-channel-close
  input parameter channel :: <GIOChannel>;
  c-name: "g_io_channel_close";
end;

define C-function g-io-channel-shutdown
  input parameter channel :: <GIOChannel>;
  input parameter flush :: <gboolean>;
  input parameter err :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_shutdown";
end;

define C-function g-io-add-watch-full
  input parameter channel :: <GIOChannel>;
  input parameter priority :: <gint>;
  input parameter condition :: <GIOCondition>;
  input parameter func :: <GIOFunc>;
  input parameter user_data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  result res :: <guint>;
  c-name: "g_io_add_watch_full";
end;

define C-function g-io-create-watch
  input parameter channel :: <GIOChannel>;
  input parameter condition :: <GIOCondition>;
  result res :: <GSource>;
  c-name: "g_io_create_watch";
end;

define C-function g-io-add-watch
  input parameter channel :: <GIOChannel>;
  input parameter condition :: <GIOCondition>;
  input parameter func :: <GIOFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_io_add_watch";
end;

define C-function g-io-channel-set-buffer-size
  input parameter channel :: <GIOChannel>;
  input parameter size :: <gsize>;
  c-name: "g_io_channel_set_buffer_size";
end;

define C-function g-io-channel-get-buffer-size
  input parameter channel :: <GIOChannel>;
  result res :: <gsize>;
  c-name: "g_io_channel_get_buffer_size";
end;

define C-function g-io-channel-get-buffer-condition
  input parameter channel :: <GIOChannel>;
  result res :: <GIOCondition>;
  c-name: "g_io_channel_get_buffer_condition";
end;

define C-function g-io-channel-set-flags
  input parameter channel :: <GIOChannel>;
  input parameter flags :: <GIOFlags>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_set_flags";
end;

define C-function g-io-channel-get-flags
  input parameter channel :: <GIOChannel>;
  result res :: <GIOFlags>;
  c-name: "g_io_channel_get_flags";
end;

define C-function g-io-channel-set-line-term
  input parameter channel :: <GIOChannel>;
  input parameter line_term :: <c-string>;
  input parameter length :: <gint>;
  c-name: "g_io_channel_set_line_term";
end;

define C-function g-io-channel-get-line-term
  input parameter channel :: <GIOChannel>;
  input parameter length :: <gint*>;
  result res :: <c-string>;
  c-name: "g_io_channel_get_line_term";
end;

define C-function g-io-channel-set-buffered
  input parameter channel :: <GIOChannel>;
  input parameter buffered :: <gboolean>;
  c-name: "g_io_channel_set_buffered";
end;

define C-function g-io-channel-get-buffered
  input parameter channel :: <GIOChannel>;
  result res :: <gboolean>;
  c-name: "g_io_channel_get_buffered";
end;

define C-function g-io-channel-set-encoding
  input parameter channel :: <GIOChannel>;
  input parameter encoding :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_set_encoding";
end;

define C-function g-io-channel-get-encoding
  input parameter channel :: <GIOChannel>;
  result res :: <c-string>;
  c-name: "g_io_channel_get_encoding";
end;

define C-function g-io-channel-set-close-on-unref
  input parameter channel :: <GIOChannel>;
  input parameter do_close :: <gboolean>;
  c-name: "g_io_channel_set_close_on_unref";
end;

define C-function g-io-channel-get-close-on-unref
  input parameter channel :: <GIOChannel>;
  result res :: <gboolean>;
  c-name: "g_io_channel_get_close_on_unref";
end;

define C-function g-io-channel-flush
  input parameter channel :: <GIOChannel>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_flush";
end;

define C-function g-io-channel-read-line
  input parameter channel :: <GIOChannel>;
  input parameter str_return :: <gchar**>;
  input parameter length :: <gsize*>;
  input parameter terminator_pos :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_read_line";
end;

define C-function g-io-channel-read-line-string
  input parameter channel :: <GIOChannel>;
  input parameter buffer :: <GString>;
  input parameter terminator_pos :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_read_line_string";
end;

define C-function g-io-channel-read-to-end
  input parameter channel :: <GIOChannel>;
  input parameter str_return :: <gchar**>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_read_to_end";
end;

define C-function g-io-channel-read-chars
  input parameter channel :: <GIOChannel>;
  input parameter buf :: <c-string>;
  input parameter count :: <gsize>;
  input parameter bytes_read :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_read_chars";
end;

define C-function g-io-channel-read-unichar
  input parameter channel :: <GIOChannel>;
  input parameter thechar :: <gunichar*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_read_unichar";
end;

define C-function g-io-channel-write-chars
  input parameter channel :: <GIOChannel>;
  input parameter buf :: <c-string>;
  input parameter count :: <gssize>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_write_chars";
end;

define C-function g-io-channel-write-unichar
  input parameter channel :: <GIOChannel>;
  input parameter thechar :: <gunichar>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_write_unichar";
end;

define C-function g-io-channel-seek-position
  input parameter channel :: <GIOChannel>;
  input parameter offset :: <gint64>;
  input parameter type :: <GSeekType>;
  input parameter error :: <GError*>;
  result res :: <GIOStatus>;
  c-name: "g_io_channel_seek_position";
end;

define C-function g-io-channel-new-file-utf8
  input parameter filename :: <c-string>;
  input parameter mode :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_new_file_utf8";
end;

define C-function g-io-channel-error-quark
  result res :: <GQuark>;
  c-name: "g_io_channel_error_quark";
end;

define C-function g-io-channel-error-from-errno
  input parameter en :: <gint>;
  result res :: <GIOChannelError>;
  c-name: "g_io_channel_error_from_errno";
end;

define C-function g-io-channel-unix-new
  input parameter fd :: <integer>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_unix_new";
end;

define C-function g-io-channel-unix-get-fd
  input parameter channel :: <GIOChannel>;
  result res :: <gint>;
  c-name: "g_io_channel_unix_get_fd";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-io-watch-funcs"*/
define C-function g-io-channel-win32-make-pollfd
  input parameter channel :: <GIOChannel>;
  input parameter condition :: <GIOCondition>;
  input parameter fd :: <GPollFD>;
  c-name: "g_io_channel_win32_make_pollfd";
end;

define C-function g-io-channel-win32-poll
  input parameter fds :: <GPollFD>;
  input parameter n_fds :: <gint>;
  input parameter timeout_ :: <gint>;
  result res :: <gint>;
  c-name: "g_io_channel_win32_poll";
end;

define C-function g-io-channel-win32-new-messages
  input parameter hwnd :: <guint>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_win32_new_messages";
end;

define C-function g-io-channel-win32-new-fd
  input parameter fd :: <gint>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_win32_new_fd";
end;

define C-function g-io-channel-win32-get-fd
  input parameter channel :: <GIOChannel>;
  result res :: <gint>;
  c-name: "g_io_channel_win32_get_fd";
end;

define C-function g-io-channel-win32-new-socket
  input parameter socket :: <gint>;
  result res :: <GIOChannel>;
  c-name: "g_io_channel_win32_new_socket";
end;

define constant g-io-channel-new-file = g-io-channel-new-file-utf8;

define constant $G-WIN32-MSG-HANDLE = 19981206;

define constant <GConvertError> = limited(<integer>, min: 0, max: 5);
define constant $G-CONVERT-ERROR-NO-CONVERSION :: <GConvertError> = 0;
define constant $G-CONVERT-ERROR-ILLEGAL-SEQUENCE :: <GConvertError> = 1;
define constant $G-CONVERT-ERROR-FAILED :: <GConvertError> = 2;
define constant $G-CONVERT-ERROR-PARTIAL-INPUT :: <GConvertError> = 3;
define constant $G-CONVERT-ERROR-BAD-URI :: <GConvertError> = 4;
define constant $G-CONVERT-ERROR-NOT-ABSOLUTE-PATH :: <GConvertError> = 5;

define C-function g-convert-error-quark
  result res :: <GQuark>;
  c-name: "g_convert_error_quark";
end;

define C-function g-iconv-open
  input parameter to_codeset :: <c-string>;
  input parameter from_codeset :: <c-string>;
  result res :: <GIConv>;
  c-name: "g_iconv_open";
end;

define C-function g-iconv
  input parameter converter :: <GIConv>;
  input parameter inbuf :: <gchar**>;
  input parameter inbytes_left :: <gsize*>;
  input parameter outbuf :: <gchar**>;
  input parameter outbytes_left :: <gsize*>;
  result res :: <size-t>;
  c-name: "g_iconv";
end;

define C-function g-iconv-close
  input parameter converter :: <GIConv>;
  result res :: <gint>;
  c-name: "g_iconv_close";
end;

define C-function g-convert
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  input parameter to_codeset :: <c-string>;
  input parameter from_codeset :: <c-string>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_convert";
end;

define C-function g-convert-with-iconv
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  input parameter converter :: <GIConv>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_convert_with_iconv";
end;

define C-function g-convert-with-fallback
  input parameter str :: <c-string>;
  input parameter len :: <gssize>;
  input parameter to_codeset :: <c-string>;
  input parameter from_codeset :: <c-string>;
  input parameter fallback :: <c-string>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_convert_with_fallback";
end;

define C-function g-locale-to-utf8
  input parameter opsysstring :: <c-string>;
  input parameter len :: <gssize>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_locale_to_utf8";
end;

define C-function g-locale-from-utf8
  input parameter utf8string :: <c-string>;
  input parameter len :: <gssize>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_locale_from_utf8";
end;

define C-function g-filename-to-utf8-utf8
  input parameter opsysstring :: <c-string>;
  input parameter len :: <gssize>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_filename_to_utf8_utf8";
end;

define C-function g-filename-from-utf8-utf8
  input parameter utf8string :: <c-string>;
  input parameter len :: <gssize>;
  input parameter bytes_read :: <gsize*>;
  input parameter bytes_written :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_filename_from_utf8_utf8";
end;

define C-function g-filename-from-uri-utf8
  input parameter uri :: <c-string>;
  input parameter hostname :: <gchar**>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_filename_from_uri_utf8";
end;

define C-function g-filename-to-uri-utf8
  input parameter filename :: <c-string>;
  input parameter hostname :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_filename_to_uri_utf8";
end;

define C-function g-filename-display-name
  input parameter filename :: <c-string>;
  result res :: <c-string>;
  c-name: "g_filename_display_name";
end;

define C-function g-get-filename-charsets
  input parameter charsets :: <gchar***>;
  result res :: <gboolean>;
  c-name: "g_get_filename_charsets";
end;

define C-function g-filename-display-basename
  input parameter filename :: <c-string>;
  result res :: <c-string>;
  c-name: "g_filename_display_basename";
end;

define C-function g-uri-list-extract-uris
  input parameter uri_list :: <c-string>;
  result res :: <gchar**>;
  c-name: "g_uri_list_extract_uris";
end;

define constant g-filename-to-utf8 = g-filename-to-utf8-utf8;

define constant g-filename-from-utf8 = g-filename-from-utf8-utf8;

define constant g-filename-from-uri = g-filename-from-uri-utf8;

define constant g-filename-to-uri = g-filename-to-uri-utf8;

define constant <GHook> = <_GHook>;

define C-subtype <_GHook> (<C-void*>) end;
define constant <GHookList> = <_GHookList>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-664>"*/
define constant <GHookFinalizeFunc> = <anonymous-664>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gpointer<@2>>"*/
define C-subtype <_GHookList> (<C-void*>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-658>"*/
define constant <GHookCompareFunc> = <anonymous-658>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-659>"*/
define constant <GHookFindFunc> = <anonymous-659>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-660>"*/
define constant <GHookMarshaller> = <anonymous-660>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-661>"*/
define constant <GHookCheckMarshaller> = <anonymous-661>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-662>"*/
define constant <GHookFunc> = <anonymous-662>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-663>"*/
define constant <GHookCheckFunc> = <anonymous-663>;

define constant <GHookFlagMask> = limited(<integer>, min: 1, max: 15);
define constant $G-HOOK-FLAG-ACTIVE :: <GHookFlagMask> = 1;
define constant $G-HOOK-FLAG-IN-CALL :: <GHookFlagMask> = 2;
define constant $G-HOOK-FLAG-MASK :: <GHookFlagMask> = 15;

define C-function g-hook-list-init
  input parameter hook_list :: <GHookList>;
  input parameter hook_size :: <guint>;
  c-name: "g_hook_list_init";
end;

define C-function g-hook-list-clear
  input parameter hook_list :: <GHookList>;
  c-name: "g_hook_list_clear";
end;

define C-function g-hook-alloc
  input parameter hook_list :: <GHookList>;
  result res :: <GHook>;
  c-name: "g_hook_alloc";
end;

define C-function g-hook-free
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  c-name: "g_hook_free";
end;

define C-function g-hook-ref
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  result res :: <GHook>;
  c-name: "g_hook_ref";
end;

define C-function g-hook-unref
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  c-name: "g_hook_unref";
end;

define C-function g-hook-destroy
  input parameter hook_list :: <GHookList>;
  input parameter hook_id :: <gulong>;
  result res :: <gboolean>;
  c-name: "g_hook_destroy";
end;

define C-function g-hook-destroy-link
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  c-name: "g_hook_destroy_link";
end;

define C-function g-hook-prepend
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  c-name: "g_hook_prepend";
end;

define C-function g-hook-insert-before
  input parameter hook_list :: <GHookList>;
  input parameter sibling :: <GHook>;
  input parameter hook :: <GHook>;
  c-name: "g_hook_insert_before";
end;

define C-function g-hook-insert-sorted
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  input parameter func :: <GHookCompareFunc>;
  c-name: "g_hook_insert_sorted";
end;

define C-function g-hook-get
  input parameter hook_list :: <GHookList>;
  input parameter hook_id :: <gulong>;
  result res :: <GHook>;
  c-name: "g_hook_get";
end;

define C-function g-hook-find
  input parameter hook_list :: <GHookList>;
  input parameter need_valids :: <gboolean>;
  input parameter func :: <GHookFindFunc>;
  input parameter data :: <gpointer>;
  result res :: <GHook>;
  c-name: "g_hook_find";
end;

define C-function g-hook-find-data
  input parameter hook_list :: <GHookList>;
  input parameter need_valids :: <gboolean>;
  input parameter data :: <gpointer>;
  result res :: <GHook>;
  c-name: "g_hook_find_data";
end;

define C-function g-hook-find-func
  input parameter hook_list :: <GHookList>;
  input parameter need_valids :: <gboolean>;
  input parameter func :: <gpointer>;
  result res :: <GHook>;
  c-name: "g_hook_find_func";
end;

define C-function g-hook-find-func-data
  input parameter hook_list :: <GHookList>;
  input parameter need_valids :: <gboolean>;
  input parameter func :: <gpointer>;
  input parameter data :: <gpointer>;
  result res :: <GHook>;
  c-name: "g_hook_find_func_data";
end;

define C-function g-hook-first-valid
  input parameter hook_list :: <GHookList>;
  input parameter may_be_in_call :: <gboolean>;
  result res :: <GHook>;
  c-name: "g_hook_first_valid";
end;

define C-function g-hook-next-valid
  input parameter hook_list :: <GHookList>;
  input parameter hook :: <GHook>;
  input parameter may_be_in_call :: <gboolean>;
  result res :: <GHook>;
  c-name: "g_hook_next_valid";
end;

define C-function g-hook-compare-ids
  input parameter new_hook :: <GHook>;
  input parameter sibling :: <GHook>;
  result res :: <gint>;
  c-name: "g_hook_compare_ids";
end;

define C-function g-hook-list-invoke
  input parameter hook_list :: <GHookList>;
  input parameter may_recurse :: <gboolean>;
  c-name: "g_hook_list_invoke";
end;

define C-function g-hook-list-invoke-check
  input parameter hook_list :: <GHookList>;
  input parameter may_recurse :: <gboolean>;
  c-name: "g_hook_list_invoke_check";
end;

define C-function g-hook-list-marshal
  input parameter hook_list :: <GHookList>;
  input parameter may_recurse :: <gboolean>;
  input parameter marshaller :: <GHookMarshaller>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_hook_list_marshal";
end;

define C-function g-hook-list-marshal-check
  input parameter hook_list :: <GHookList>;
  input parameter may_recurse :: <gboolean>;
  input parameter marshaller :: <GHookCheckMarshaller>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_hook_list_marshal_check";
end;

define constant $G-HOOK-FLAG-USER-SHIFT = 4;

define constant <GFileError> = limited(<integer>, min: 0, max: 24);
define constant $G-FILE-ERROR-EXIST :: <GFileError> = 0;
define constant $G-FILE-ERROR-ISDIR :: <GFileError> = 1;
define constant $G-FILE-ERROR-ACCES :: <GFileError> = 2;
define constant $G-FILE-ERROR-NAMETOOLONG :: <GFileError> = 3;
define constant $G-FILE-ERROR-NOENT :: <GFileError> = 4;
define constant $G-FILE-ERROR-NOTDIR :: <GFileError> = 5;
define constant $G-FILE-ERROR-NXIO :: <GFileError> = 6;
define constant $G-FILE-ERROR-NODEV :: <GFileError> = 7;
define constant $G-FILE-ERROR-ROFS :: <GFileError> = 8;
define constant $G-FILE-ERROR-TXTBSY :: <GFileError> = 9;
define constant $G-FILE-ERROR-FAULT :: <GFileError> = 10;
define constant $G-FILE-ERROR-LOOP :: <GFileError> = 11;
define constant $G-FILE-ERROR-NOSPC :: <GFileError> = 12;
define constant $G-FILE-ERROR-NOMEM :: <GFileError> = 13;
define constant $G-FILE-ERROR-MFILE :: <GFileError> = 14;
define constant $G-FILE-ERROR-NFILE :: <GFileError> = 15;
define constant $G-FILE-ERROR-BADF :: <GFileError> = 16;
define constant $G-FILE-ERROR-INVAL :: <GFileError> = 17;
define constant $G-FILE-ERROR-PIPE :: <GFileError> = 18;
define constant $G-FILE-ERROR-AGAIN :: <GFileError> = 19;
define constant $G-FILE-ERROR-INTR :: <GFileError> = 20;
define constant $G-FILE-ERROR-IO :: <GFileError> = 21;
define constant $G-FILE-ERROR-PERM :: <GFileError> = 22;
define constant $G-FILE-ERROR-NOSYS :: <GFileError> = 23;
define constant $G-FILE-ERROR-FAILED :: <GFileError> = 24;

define constant <GFileTest> = limited(<integer>, min: 1, max: 16);
define constant $G-FILE-TEST-IS-REGULAR :: <GFileTest> = 1;
define constant $G-FILE-TEST-IS-SYMLINK :: <GFileTest> = 2;
define constant $G-FILE-TEST-IS-DIR :: <GFileTest> = 4;
define constant $G-FILE-TEST-IS-EXECUTABLE :: <GFileTest> = 8;
define constant $G-FILE-TEST-EXISTS :: <GFileTest> = 16;

define C-function g-file-error-quark
  result res :: <GQuark>;
  c-name: "g_file_error_quark";
end;

define C-function g-file-error-from-errno
  input parameter err_no :: <gint>;
  result res :: <GFileError>;
  c-name: "g_file_error_from_errno";
end;

define C-function g-file-test-utf8
  input parameter filename :: <c-string>;
  input parameter test :: <GFileTest>;
  result res :: <gboolean>;
  c-name: "g_file_test_utf8";
end;

define C-function g-file-get-contents-utf8
  input parameter filename :: <c-string>;
  input parameter contents :: <gchar**>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_file_get_contents_utf8";
end;

define C-function g-file-set-contents
  input parameter filename :: <c-string>;
  input parameter contents :: <c-string>;
  input parameter length :: <gssize>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_file_set_contents";
end;

define C-function g-file-read-link
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_file_read_link";
end;

define C-function g-mkstemp-utf8
  input parameter tmpl :: <c-string>;
  result res :: <gint>;
  c-name: "g_mkstemp_utf8";
end;

define C-function g-file-open-tmp-utf8
  input parameter tmpl :: <c-string>;
  input parameter name_used :: <gchar**>;
  input parameter error :: <GError*>;
  result res :: <gint>;
  c-name: "g_file_open_tmp_utf8";
end;

define C-function g-build-path
  input parameter separator :: <c-string>;
  input parameter first_element :: <c-string>;
  result res :: <c-string>;
  c-name: "g_build_path";
end;

define C-function g-build-pathv
  input parameter separator :: <c-string>;
  input parameter args :: <gchar**>;
  result res :: <c-string>;
  c-name: "g_build_pathv";
end;

define C-function g-build-filename
  input parameter first_element :: <c-string>;
  result res :: <c-string>;
  c-name: "g_build_filename";
end;

define C-function g-build-filenamev
  input parameter args :: <gchar**>;
  result res :: <c-string>;
  c-name: "g_build_filenamev";
end;

define C-function g-mkdir-with-parents
  input parameter pathname :: <c-string>;
  input parameter mode :: <integer>;
  result res :: <integer>;
  c-name: "g_mkdir_with_parents";
end;

define constant g-file-test = g-file-test-utf8;

define constant g-file-get-contents = g-file-get-contents-utf8;

define constant g-mkstemp = g-mkstemp-utf8;

define constant g-file-open-tmp = g-file-open-tmp-utf8;

define C-subtype <_GDir> (<C-void*>) end;
define constant <GDir> = <_GDir>;

define C-function g-dir-open-utf8
  input parameter path :: <c-string>;
  input parameter flags :: <guint>;
  input parameter error :: <GError*>;
  result res :: <GDir>;
  c-name: "g_dir_open_utf8";
end;

define C-function g-dir-read-name-utf8
  input parameter dir :: <GDir>;
  result res :: <c-string>;
  c-name: "g_dir_read_name_utf8";
end;

define C-function g-dir-rewind
  input parameter dir :: <GDir>;
  c-name: "g_dir_rewind";
end;

define C-function g-dir-close
  input parameter dir :: <GDir>;
  c-name: "g_dir_close";
end;

define constant g-dir-open = g-dir-open-utf8;

define constant g-dir-read-name = g-dir-read-name-utf8;

define constant <GTime> = <gint32>;

define constant <GDateYear> = <guint16>;

define constant <GDateDay> = <guint8>;

define C-subtype <_GDate> (<C-void*>) end;
define constant <GDate> = <_GDate>;

define constant <GDateDMY> = limited(<integer>, min: 0, max: 2);
define constant $G-DATE-DAY :: <GDateDMY> = 0;
define constant $G-DATE-MONTH :: <GDateDMY> = 1;
define constant $G-DATE-YEAR :: <GDateDMY> = 2;

define constant <GDateWeekday> = limited(<integer>, min: 0, max: 7);
define constant $G-DATE-BAD-WEEKDAY :: <GDateWeekday> = 0;
define constant $G-DATE-MONDAY :: <GDateWeekday> = 1;
define constant $G-DATE-TUESDAY :: <GDateWeekday> = 2;
define constant $G-DATE-WEDNESDAY :: <GDateWeekday> = 3;
define constant $G-DATE-THURSDAY :: <GDateWeekday> = 4;
define constant $G-DATE-FRIDAY :: <GDateWeekday> = 5;
define constant $G-DATE-SATURDAY :: <GDateWeekday> = 6;
define constant $G-DATE-SUNDAY :: <GDateWeekday> = 7;

define constant <GDateMonth> = limited(<integer>, min: 0, max: 12);
define constant $G-DATE-BAD-MONTH :: <GDateMonth> = 0;
define constant $G-DATE-JANUARY :: <GDateMonth> = 1;
define constant $G-DATE-FEBRUARY :: <GDateMonth> = 2;
define constant $G-DATE-MARCH :: <GDateMonth> = 3;
define constant $G-DATE-APRIL :: <GDateMonth> = 4;
define constant $G-DATE-MAY :: <GDateMonth> = 5;
define constant $G-DATE-JUNE :: <GDateMonth> = 6;
define constant $G-DATE-JULY :: <GDateMonth> = 7;
define constant $G-DATE-AUGUST :: <GDateMonth> = 8;
define constant $G-DATE-SEPTEMBER :: <GDateMonth> = 9;
define constant $G-DATE-OCTOBER :: <GDateMonth> = 10;
define constant $G-DATE-NOVEMBER :: <GDateMonth> = 11;
define constant $G-DATE-DECEMBER :: <GDateMonth> = 12;

define C-function g-date-new
  result res :: <GDate>;
  c-name: "g_date_new";
end;

define C-function g-date-new-dmy
  input parameter day :: <GDateDay>;
  input parameter month :: <GDateMonth>;
  input parameter year :: <GDateYear>;
  result res :: <GDate>;
  c-name: "g_date_new_dmy";
end;

define C-function g-date-new-julian
  input parameter julian_day :: <guint32>;
  result res :: <GDate>;
  c-name: "g_date_new_julian";
end;

define C-function g-date-free
  input parameter date :: <GDate>;
  c-name: "g_date_free";
end;

define C-function g-date-valid
  input parameter date :: <GDate>;
  result res :: <gboolean>;
  c-name: "g_date_valid";
end;

define C-function g-date-valid-day
  input parameter day :: <GDateDay>;
  result res :: <gboolean>;
  c-name: "g_date_valid_day";
end;

define C-function g-date-valid-month
  input parameter month :: <GDateMonth>;
  result res :: <gboolean>;
  c-name: "g_date_valid_month";
end;

define C-function g-date-valid-year
  input parameter year :: <GDateYear>;
  result res :: <gboolean>;
  c-name: "g_date_valid_year";
end;

define C-function g-date-valid-weekday
  input parameter weekday :: <GDateWeekday>;
  result res :: <gboolean>;
  c-name: "g_date_valid_weekday";
end;

define C-function g-date-valid-julian
  input parameter julian_date :: <guint32>;
  result res :: <gboolean>;
  c-name: "g_date_valid_julian";
end;

define C-function g-date-valid-dmy
  input parameter day :: <GDateDay>;
  input parameter month :: <GDateMonth>;
  input parameter year :: <GDateYear>;
  result res :: <gboolean>;
  c-name: "g_date_valid_dmy";
end;

define C-function g-date-get-weekday
  input parameter date :: <GDate>;
  result res :: <GDateWeekday>;
  c-name: "g_date_get_weekday";
end;

define C-function g-date-get-month
  input parameter date :: <GDate>;
  result res :: <GDateMonth>;
  c-name: "g_date_get_month";
end;

define C-function g-date-get-year
  input parameter date :: <GDate>;
  result res :: <GDateYear>;
  c-name: "g_date_get_year";
end;

define C-function g-date-get-day
  input parameter date :: <GDate>;
  result res :: <GDateDay>;
  c-name: "g_date_get_day";
end;

define C-function g-date-get-julian
  input parameter date :: <GDate>;
  result res :: <guint32>;
  c-name: "g_date_get_julian";
end;

define C-function g-date-get-day-of-year
  input parameter date :: <GDate>;
  result res :: <guint>;
  c-name: "g_date_get_day_of_year";
end;

define C-function g-date-get-monday-week-of-year
  input parameter date :: <GDate>;
  result res :: <guint>;
  c-name: "g_date_get_monday_week_of_year";
end;

define C-function g-date-get-sunday-week-of-year
  input parameter date :: <GDate>;
  result res :: <guint>;
  c-name: "g_date_get_sunday_week_of_year";
end;

define C-function g-date-get-iso8601-week-of-year
  input parameter date :: <GDate>;
  result res :: <guint>;
  c-name: "g_date_get_iso8601_week_of_year";
end;

define C-function g-date-clear
  input parameter date :: <GDate>;
  input parameter n_dates :: <guint>;
  c-name: "g_date_clear";
end;

define C-function g-date-set-parse
  input parameter date :: <GDate>;
  input parameter str :: <c-string>;
  c-name: "g_date_set_parse";
end;

define constant <time-t> = <integer>;

define C-function g-date-set-time-t
  input parameter date :: <GDate>;
  input parameter timet :: <time-t>;
  c-name: "g_date_set_time_t";
end;

define C-function g-date-set-time-val
  input parameter date :: <GDate>;
  input parameter timeval :: <GTimeVal>;
  c-name: "g_date_set_time_val";
end;

define C-function g-date-set-time
  input parameter date :: <GDate>;
  input parameter time_ :: <GTime>;
  c-name: "g_date_set_time";
end;

define C-function g-date-set-month
  input parameter date :: <GDate>;
  input parameter month :: <GDateMonth>;
  c-name: "g_date_set_month";
end;

define C-function g-date-set-day
  input parameter date :: <GDate>;
  input parameter day :: <GDateDay>;
  c-name: "g_date_set_day";
end;

define C-function g-date-set-year
  input parameter date :: <GDate>;
  input parameter year :: <GDateYear>;
  c-name: "g_date_set_year";
end;

define C-function g-date-set-dmy
  input parameter date :: <GDate>;
  input parameter day :: <GDateDay>;
  input parameter month :: <GDateMonth>;
  input parameter y :: <GDateYear>;
  c-name: "g_date_set_dmy";
end;

define C-function g-date-set-julian
  input parameter date :: <GDate>;
  input parameter julian_date :: <guint32>;
  c-name: "g_date_set_julian";
end;

define C-function g-date-is-first-of-month
  input parameter date :: <GDate>;
  result res :: <gboolean>;
  c-name: "g_date_is_first_of_month";
end;

define C-function g-date-is-last-of-month
  input parameter date :: <GDate>;
  result res :: <gboolean>;
  c-name: "g_date_is_last_of_month";
end;

define C-function g-date-add-days
  input parameter date :: <GDate>;
  input parameter n_days :: <guint>;
  c-name: "g_date_add_days";
end;

define C-function g-date-subtract-days
  input parameter date :: <GDate>;
  input parameter n_days :: <guint>;
  c-name: "g_date_subtract_days";
end;

define C-function g-date-add-months
  input parameter date :: <GDate>;
  input parameter n_months :: <guint>;
  c-name: "g_date_add_months";
end;

define C-function g-date-subtract-months
  input parameter date :: <GDate>;
  input parameter n_months :: <guint>;
  c-name: "g_date_subtract_months";
end;

define C-function g-date-add-years
  input parameter date :: <GDate>;
  input parameter n_years :: <guint>;
  c-name: "g_date_add_years";
end;

define C-function g-date-subtract-years
  input parameter date :: <GDate>;
  input parameter n_years :: <guint>;
  c-name: "g_date_subtract_years";
end;

define C-function g-date-is-leap-year
  input parameter year :: <GDateYear>;
  result res :: <gboolean>;
  c-name: "g_date_is_leap_year";
end;

define C-function g-date-get-days-in-month
  input parameter month :: <GDateMonth>;
  input parameter year :: <GDateYear>;
  result res :: <guint8>;
  c-name: "g_date_get_days_in_month";
end;

define C-function g-date-get-monday-weeks-in-year
  input parameter year :: <GDateYear>;
  result res :: <guint8>;
  c-name: "g_date_get_monday_weeks_in_year";
end;

define C-function g-date-get-sunday-weeks-in-year
  input parameter year :: <GDateYear>;
  result res :: <guint8>;
  c-name: "g_date_get_sunday_weeks_in_year";
end;

define C-function g-date-days-between
  input parameter date1 :: <GDate>;
  input parameter date2 :: <GDate>;
  result res :: <gint>;
  c-name: "g_date_days_between";
end;

define C-function g-date-compare
  input parameter lhs :: <GDate>;
  input parameter rhs :: <GDate>;
  result res :: <gint>;
  c-name: "g_date_compare";
end;

define C-subtype <tm> (<C-void*>) end;
define C-function g-date-to-struct-tm
  input parameter date :: <GDate>;
  input parameter tm :: <tm>;
  c-name: "g_date_to_struct_tm";
end;

define C-function g-date-clamp
  input parameter date :: <GDate>;
  input parameter min_date :: <GDate>;
  input parameter max_date :: <GDate>;
  c-name: "g_date_clamp";
end;

define C-function g-date-order
  input parameter date1 :: <GDate>;
  input parameter date2 :: <GDate>;
  c-name: "g_date_order";
end;

define C-function g-date-strftime
  input parameter s :: <c-string>;
  input parameter slen :: <gsize>;
  input parameter format :: <c-string>;
  input parameter date :: <GDate>;
  result res :: <gsize>;
  c-name: "g_date_strftime";
end;

define constant $G-DATE-BAD-JULIAN = 0;

define constant $G-DATE-BAD-DAY = 0;

define constant $G-DATE-BAD-YEAR = 0;

define constant g-date-weekday = g-date-get-weekday;

define constant g-date-month = g-date-get-month;

define constant g-date-year = g-date-get-year;

define constant g-date-day = g-date-get-day;

define constant g-date-julian = g-date-get-julian;

define constant g-date-day-of-year = g-date-get-day-of-year;

define constant g-date-monday-week-of-year = g-date-get-monday-week-of-year;

define constant g-date-sunday-week-of-year = g-date-get-sunday-week-of-year;

define constant g-date-days-in-month = g-date-get-days-in-month;

define constant g-date-monday-weeks-in-year = g-date-get-monday-weeks-in-year;

define constant g-date-sunday-weeks-in-year = g-date-get-sunday-weeks-in-year;

define constant <clock-t> = <integer>;

 /* Ignoring declaration for {instance of <variable-declaration>} "_daylight"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "_dstbias"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "_timezone"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<char*<@2>>"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "_tzname"*/
define C-function asctime
  input parameter  :: <tm>;
  result res :: <c-string>;
  c-name: "asctime";
end;

define C-pointer-type <time-t*> => <time-t>;
define C-function ctime
  input parameter  :: <time-t*>;
  result res :: <c-string>;
  c-name: "ctime";
end;

define C-function clock
  result res :: <clock-t>;
  c-name: "clock";
end;

define C-function difftime
  input parameter  :: <time-t>;
  input parameter  :: <time-t>;
  result res :: <double-float>;
  c-name: "difftime";
end;

define C-function gmtime
  input parameter  :: <time-t*>;
  result res :: <tm>;
  c-name: "gmtime";
end;

define C-function localtime
  input parameter  :: <time-t*>;
  result res :: <tm>;
  c-name: "localtime";
end;

define C-function mktime
  input parameter  :: <tm>;
  result res :: <time-t>;
  c-name: "mktime";
end;

define C-function strftime
  input parameter  :: <c-string>;
  input parameter  :: <size-t>;
  input parameter  :: <c-string>;
  input parameter  :: <tm>;
  result res :: <size-t>;
  c-name: "strftime";
end;

define C-function _strdate
  input parameter  :: <c-string>;
  result res :: <c-string>;
  c-name: "_strdate";
end;

define C-function _strtime
  input parameter  :: <c-string>;
  result res :: <c-string>;
  c-name: "_strtime";
end;

define C-function time
  input parameter  :: <time-t*>;
  result res :: <time-t>;
  c-name: "time";
end;

define C-function tzset
  c-name: "tzset";
end;

define C-function _getsystime
  input parameter  :: <tm>;
  result res :: <integer>;
  c-name: "_getsystime";
end;

define C-function _setsystime
  input parameter  :: <tm>;
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "_setsystime";
end;

define C-pointer-type <wchar-t*> => <wchar-t>;
define C-function _wasctime
  input parameter  :: <tm>;
  result res :: <wchar-t*>;
  c-name: "_wasctime";
end;

define C-function _wctime
  input parameter  :: <time-t*>;
  result res :: <wchar-t*>;
  c-name: "_wctime";
end;

define C-function wcsftime
  input parameter  :: <wchar-t*>;
  input parameter  :: <size-t>;
  input parameter  :: <wchar-t*>;
  input parameter  :: <tm>;
  result res :: <size-t>;
  c-name: "wcsftime";
end;

define C-function _wstrdate
  input parameter  :: <wchar-t*>;
  result res :: <wchar-t*>;
  c-name: "_wstrdate";
end;

define C-function _wstrtime
  input parameter  :: <wchar-t*>;
  result res :: <wchar-t*>;
  c-name: "_wstrtime";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "daylight"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "timezone"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "tzname"*/
define constant $CLOCKS-PER-SEC = 1000;

define constant $CLK-TCK = 1000;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-514>"*/
define constant <GCompletionFunc> = <anonymous-514>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-515>"*/
define constant <GCompletionStrncmpFunc> = <anonymous-515>;

define C-subtype <_GCompletion> (<C-void*>) end;
define constant <GCompletion> = <_GCompletion>;

define C-function g-completion-new
  input parameter func :: <GCompletionFunc>;
  result res :: <GCompletion>;
  c-name: "g_completion_new";
end;

define C-function g-completion-add-items
  input parameter cmp :: <GCompletion>;
  input parameter items :: <GList>;
  c-name: "g_completion_add_items";
end;

define C-function g-completion-remove-items
  input parameter cmp :: <GCompletion>;
  input parameter items :: <GList>;
  c-name: "g_completion_remove_items";
end;

define C-function g-completion-clear-items
  input parameter cmp :: <GCompletion>;
  c-name: "g_completion_clear_items";
end;

define C-function g-completion-complete
  input parameter cmp :: <GCompletion>;
  input parameter prefix :: <c-string>;
  input parameter new_prefix :: <gchar**>;
  result res :: <GList>;
  c-name: "g_completion_complete";
end;

define C-function g-completion-complete-utf8
  input parameter cmp :: <GCompletion>;
  input parameter prefix :: <c-string>;
  input parameter new_prefix :: <gchar**>;
  result res :: <GList>;
  c-name: "g_completion_complete_utf8";
end;

define C-function g-completion-set-compare
  input parameter cmp :: <GCompletion>;
  input parameter strncmp_func :: <GCompletionStrncmpFunc>;
  c-name: "g_completion_set_compare";
end;

define C-function g-completion-free
  input parameter cmp :: <GCompletion>;
  c-name: "g_completion_free";
end;

define C-subtype <_GCache> (<C-void*>) end;
define constant <GCache> = <_GCache>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-505>"*/
define constant <GCacheNewFunc> = <anonymous-505>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-506>"*/
define constant <GCacheDupFunc> = <anonymous-506>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-507>"*/
define constant <GCacheDestroyFunc> = <anonymous-507>;

define C-function g-cache-new
  input parameter value_new_func :: <GCacheNewFunc>;
  input parameter value_destroy_func :: <GCacheDestroyFunc>;
  input parameter key_dup_func :: <GCacheDupFunc>;
  input parameter key_destroy_func :: <GCacheDestroyFunc>;
  input parameter hash_key_func :: <GHashFunc>;
  input parameter hash_value_func :: <GHashFunc>;
  input parameter key_equal_func :: <GEqualFunc>;
  result res :: <GCache>;
  c-name: "g_cache_new";
end;

define C-function g-cache-destroy
  input parameter cache :: <GCache>;
  c-name: "g_cache_destroy";
end;

define C-function g-cache-insert
  input parameter cache :: <GCache>;
  input parameter key :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_cache_insert";
end;

define C-function g-cache-remove
  input parameter cache :: <GCache>;
  input parameter value :: <gconstpointer>;
  c-name: "g_cache_remove";
end;

define C-function g-cache-key-foreach
  input parameter cache :: <GCache>;
  input parameter func :: <GHFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_cache_key_foreach";
end;

define C-function g-cache-value-foreach
  input parameter cache :: <GCache>;
  input parameter func :: <GHFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_cache_value_foreach";
end;

define constant <GBookmarkFileError> = limited(<integer>, min: 0, max: 7);
define constant $G-BOOKMARK-FILE-ERROR-INVALID-URI :: <GBookmarkFileError> = 0;
define constant $G-BOOKMARK-FILE-ERROR-INVALID-VALUE :: <GBookmarkFileError> = 1;
define constant $G-BOOKMARK-FILE-ERROR-APP-NOT-REGISTERED :: <GBookmarkFileError> = 2;
define constant $G-BOOKMARK-FILE-ERROR-URI-NOT-FOUND :: <GBookmarkFileError> = 3;
define constant $G-BOOKMARK-FILE-ERROR-READ :: <GBookmarkFileError> = 4;
define constant $G-BOOKMARK-FILE-ERROR-UNKNOWN-ENCODING :: <GBookmarkFileError> = 5;
define constant $G-BOOKMARK-FILE-ERROR-WRITE :: <GBookmarkFileError> = 6;
define constant $G-BOOKMARK-FILE-ERROR-FILE-NOT-FOUND :: <GBookmarkFileError> = 7;

define C-function g-bookmark-file-error-quark
  result res :: <GQuark>;
  c-name: "g_bookmark_file_error_quark";
end;

define C-subtype <_GBookmarkFile> (<C-void*>) end;
define constant <GBookmarkFile> = <_GBookmarkFile>;

define C-function g-bookmark-file-new
  result res :: <GBookmarkFile>;
  c-name: "g_bookmark_file_new";
end;

define C-function g-bookmark-file-free
  input parameter bookmark :: <GBookmarkFile>;
  c-name: "g_bookmark_file_free";
end;

define C-function g-bookmark-file-load-from-file
  input parameter bookmark :: <GBookmarkFile>;
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_load_from_file";
end;

define C-function g-bookmark-file-load-from-data
  input parameter bookmark :: <GBookmarkFile>;
  input parameter data :: <c-string>;
  input parameter length :: <gsize>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_load_from_data";
end;

define C-function g-bookmark-file-load-from-data-dirs
  input parameter bookmark :: <GBookmarkFile>;
  input parameter file :: <c-string>;
  input parameter full_path :: <gchar**>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_load_from_data_dirs";
end;

define C-function g-bookmark-file-to-data
  input parameter bookmark :: <GBookmarkFile>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_bookmark_file_to_data";
end;

define C-function g-bookmark-file-to-file
  input parameter bookmark :: <GBookmarkFile>;
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_to_file";
end;

define C-function g-bookmark-file-set-title
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter title :: <c-string>;
  c-name: "g_bookmark_file_set_title";
end;

define C-function g-bookmark-file-get-title
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_bookmark_file_get_title";
end;

define C-function g-bookmark-file-set-description
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter description :: <c-string>;
  c-name: "g_bookmark_file_set_description";
end;

define C-function g-bookmark-file-get-description
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_bookmark_file_get_description";
end;

define C-function g-bookmark-file-set-mime-type
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter mime_type :: <c-string>;
  c-name: "g_bookmark_file_set_mime_type";
end;

define C-function g-bookmark-file-get-mime-type
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <c-string>;
  c-name: "g_bookmark_file_get_mime_type";
end;

define C-function g-bookmark-file-set-groups
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter groups :: <gchar**>;
  input parameter length :: <gsize>;
  c-name: "g_bookmark_file_set_groups";
end;

define C-function g-bookmark-file-add-group
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter group :: <c-string>;
  c-name: "g_bookmark_file_add_group";
end;

define C-function g-bookmark-file-has-group
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter group :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_has_group";
end;

define C-function g-bookmark-file-get-groups
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gchar**>;
  c-name: "g_bookmark_file_get_groups";
end;

define C-function g-bookmark-file-add-application
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter name :: <c-string>;
  input parameter exec :: <c-string>;
  c-name: "g_bookmark_file_add_application";
end;

define C-function g-bookmark-file-has-application
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter name :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_has_application";
end;

define C-function g-bookmark-file-get-applications
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter length :: <gsize*>;
  input parameter error :: <GError*>;
  result res :: <gchar**>;
  c-name: "g_bookmark_file_get_applications";
end;

define C-function g-bookmark-file-set-app-info
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter name :: <c-string>;
  input parameter exec :: <c-string>;
  input parameter count :: <gint>;
  input parameter stamp :: <time-t>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_set_app_info";
end;

define C-function g-bookmark-file-get-app-info
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter name :: <c-string>;
  input parameter exec :: <gchar**>;
  input parameter count :: <guint*>;
  input parameter stamp :: <time-t*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_get_app_info";
end;

define C-function g-bookmark-file-set-is-private
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter is_private :: <gboolean>;
  c-name: "g_bookmark_file_set_is_private";
end;

define C-function g-bookmark-file-get-is-private
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_get_is_private";
end;

define C-function g-bookmark-file-set-icon
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter href :: <c-string>;
  input parameter mime_type :: <c-string>;
  c-name: "g_bookmark_file_set_icon";
end;

define C-function g-bookmark-file-get-icon
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter href :: <gchar**>;
  input parameter mime_type :: <gchar**>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_get_icon";
end;

define C-function g-bookmark-file-set-added
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter added :: <time-t>;
  c-name: "g_bookmark_file_set_added";
end;

define C-function g-bookmark-file-get-added
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <time-t>;
  c-name: "g_bookmark_file_get_added";
end;

define C-function g-bookmark-file-set-modified
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter modified :: <time-t>;
  c-name: "g_bookmark_file_set_modified";
end;

define C-function g-bookmark-file-get-modified
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <time-t>;
  c-name: "g_bookmark_file_get_modified";
end;

define C-function g-bookmark-file-set-visited
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter visited :: <time-t>;
  c-name: "g_bookmark_file_set_visited";
end;

define C-function g-bookmark-file-get-visited
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <time-t>;
  c-name: "g_bookmark_file_get_visited";
end;

define C-function g-bookmark-file-has-item
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_has_item";
end;

define C-function g-bookmark-file-get-size
  input parameter bookmark :: <GBookmarkFile>;
  result res :: <gint>;
  c-name: "g_bookmark_file_get_size";
end;

define C-function g-bookmark-file-get-uris
  input parameter bookmark :: <GBookmarkFile>;
  input parameter length :: <gsize*>;
  result res :: <gchar**>;
  c-name: "g_bookmark_file_get_uris";
end;

define C-function g-bookmark-file-remove-group
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter group :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_remove_group";
end;

define C-function g-bookmark-file-remove-application
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter name :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_remove_application";
end;

define C-function g-bookmark-file-remove-item
  input parameter bookmark :: <GBookmarkFile>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_remove_item";
end;

define C-function g-bookmark-file-move-item
  input parameter bookmark :: <GBookmarkFile>;
  input parameter old_uri :: <c-string>;
  input parameter new_uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "g_bookmark_file_move_item";
end;

define C-function g-base64-encode-step
  input parameter in :: <guchar*>;
  input parameter len :: <gsize>;
  input parameter break_lines :: <gboolean>;
  input parameter out :: <c-string>;
  input parameter state :: <gint*>;
  input parameter save :: <gint*>;
  result res :: <gsize>;
  c-name: "g_base64_encode_step";
end;

define C-function g-base64-encode-close
  input parameter break_lines :: <gboolean>;
  input parameter out :: <c-string>;
  input parameter state :: <gint*>;
  input parameter save :: <gint*>;
  result res :: <gsize>;
  c-name: "g_base64_encode_close";
end;

define C-function g-base64-encode
  input parameter data :: <guchar*>;
  input parameter len :: <gsize>;
  result res :: <c-string>;
  c-name: "g_base64_encode";
end;

define C-function g-base64-decode-step
  input parameter in :: <c-string>;
  input parameter len :: <gsize>;
  input parameter out :: <guchar*>;
  input parameter state :: <gint*>;
  input parameter save :: <guint*>;
  result res :: <gsize>;
  c-name: "g_base64_decode_step";
end;

define C-function g-base64-decode
  input parameter text :: <c-string>;
  input parameter out_len :: <gsize*>;
  result res :: <guchar*>;
  c-name: "g_base64_decode";
end;

define C-function g-on-error-query
  input parameter prg_name :: <c-string>;
  c-name: "g_on_error_query";
end;

define C-function g-on-error-stack-trace
  input parameter prg_name :: <c-string>;
  c-name: "g_on_error_stack_trace";
end;

define C-subtype <_GAsyncQueue> (<C-void*>) end;
define constant <GAsyncQueue> = <_GAsyncQueue>;

define C-function g-async-queue-new
  result res :: <GAsyncQueue>;
  c-name: "g_async_queue_new";
end;

define C-function g-async-queue-lock
  input parameter queue :: <GAsyncQueue>;
  c-name: "g_async_queue_lock";
end;

define C-function g-async-queue-unlock
  input parameter queue :: <GAsyncQueue>;
  c-name: "g_async_queue_unlock";
end;

define C-function g-async-queue-ref
  input parameter queue :: <GAsyncQueue>;
  result res :: <GAsyncQueue>;
  c-name: "g_async_queue_ref";
end;

define C-function g-async-queue-unref
  input parameter queue :: <GAsyncQueue>;
  c-name: "g_async_queue_unref";
end;

define C-function g-async-queue-ref-unlocked
  input parameter queue :: <GAsyncQueue>;
  c-name: "g_async_queue_ref_unlocked";
end;

define C-function g-async-queue-unref-and-unlock
  input parameter queue :: <GAsyncQueue>;
  c-name: "g_async_queue_unref_and_unlock";
end;

define C-function g-async-queue-push
  input parameter queue :: <GAsyncQueue>;
  input parameter data :: <gpointer>;
  c-name: "g_async_queue_push";
end;

define C-function g-async-queue-push-unlocked
  input parameter queue :: <GAsyncQueue>;
  input parameter data :: <gpointer>;
  c-name: "g_async_queue_push_unlocked";
end;

define C-function g-async-queue-push-sorted
  input parameter queue :: <GAsyncQueue>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_async_queue_push_sorted";
end;

define C-function g-async-queue-push-sorted-unlocked
  input parameter queue :: <GAsyncQueue>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_async_queue_push_sorted_unlocked";
end;

define C-function g-async-queue-pop
  input parameter queue :: <GAsyncQueue>;
  result res :: <gpointer>;
  c-name: "g_async_queue_pop";
end;

define C-function g-async-queue-pop-unlocked
  input parameter queue :: <GAsyncQueue>;
  result res :: <gpointer>;
  c-name: "g_async_queue_pop_unlocked";
end;

define C-function g-async-queue-try-pop
  input parameter queue :: <GAsyncQueue>;
  result res :: <gpointer>;
  c-name: "g_async_queue_try_pop";
end;

define C-function g-async-queue-try-pop-unlocked
  input parameter queue :: <GAsyncQueue>;
  result res :: <gpointer>;
  c-name: "g_async_queue_try_pop_unlocked";
end;

define C-function g-async-queue-timed-pop
  input parameter queue :: <GAsyncQueue>;
  input parameter end_time :: <GTimeVal>;
  result res :: <gpointer>;
  c-name: "g_async_queue_timed_pop";
end;

define C-function g-async-queue-timed-pop-unlocked
  input parameter queue :: <GAsyncQueue>;
  input parameter end_time :: <GTimeVal>;
  result res :: <gpointer>;
  c-name: "g_async_queue_timed_pop_unlocked";
end;

define C-function g-async-queue-length
  input parameter queue :: <GAsyncQueue>;
  result res :: <gint>;
  c-name: "g_async_queue_length";
end;

define C-function g-async-queue-length-unlocked
  input parameter queue :: <GAsyncQueue>;
  result res :: <gint>;
  c-name: "g_async_queue_length_unlocked";
end;

define C-function g-async-queue-sort
  input parameter queue :: <GAsyncQueue>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_async_queue_sort";
end;

define C-function g-async-queue-sort-unlocked
  input parameter queue :: <GAsyncQueue>;
  input parameter func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_async_queue_sort_unlocked";
end;

define C-function _g-async-queue-get-mutex
  input parameter queue :: <GAsyncQueue>;
  result res :: <GMutex>;
  c-name: "_g_async_queue_get_mutex";
end;

define C-pointer-type <guint8*> => <guint8>;
define C-subtype <_GByteArray> (<C-void*>) end;
define constant <GByteArray> = <_GByteArray>;

define C-function g-array-new
  input parameter zero_terminated :: <gboolean>;
  input parameter clear_ :: <gboolean>;
  input parameter element_size :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_new";
end;

define C-function g-array-sized-new
  input parameter zero_terminated :: <gboolean>;
  input parameter clear_ :: <gboolean>;
  input parameter element_size :: <guint>;
  input parameter reserved_size :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_sized_new";
end;

define C-function g-array-free
  input parameter array :: <GArray>;
  input parameter free_segment :: <gboolean>;
  result res :: <c-string>;
  c-name: "g_array_free";
end;

define C-function g-array-append-vals
  input parameter array :: <GArray>;
  input parameter data :: <gconstpointer>;
  input parameter len :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_append_vals";
end;

define C-function g-array-prepend-vals
  input parameter array :: <GArray>;
  input parameter data :: <gconstpointer>;
  input parameter len :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_prepend_vals";
end;

define C-function g-array-insert-vals
  input parameter array :: <GArray>;
  input parameter index_ :: <guint>;
  input parameter data :: <gconstpointer>;
  input parameter len :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_insert_vals";
end;

define C-function g-array-set-size
  input parameter array :: <GArray>;
  input parameter length :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_set_size";
end;

define C-function g-array-remove-index
  input parameter array :: <GArray>;
  input parameter index_ :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_remove_index";
end;

define C-function g-array-remove-index-fast
  input parameter array :: <GArray>;
  input parameter index_ :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_remove_index_fast";
end;

define C-function g-array-remove-range
  input parameter array :: <GArray>;
  input parameter index_ :: <guint>;
  input parameter length :: <guint>;
  result res :: <GArray>;
  c-name: "g_array_remove_range";
end;

define C-function g-array-sort
  input parameter array :: <GArray>;
  input parameter compare_func :: <GCompareFunc>;
  c-name: "g_array_sort";
end;

define C-function g-array-sort-with-data
  input parameter array :: <GArray>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_array_sort_with_data";
end;

define C-function g-ptr-array-new
  result res :: <GPtrArray>;
  c-name: "g_ptr_array_new";
end;

define C-function g-ptr-array-sized-new
  input parameter reserved_size :: <guint>;
  result res :: <GPtrArray>;
  c-name: "g_ptr_array_sized_new";
end;

define C-function g-ptr-array-free
  input parameter array :: <GPtrArray>;
  input parameter free_seg :: <gboolean>;
  result res :: <gpointer*>;
  c-name: "g_ptr_array_free";
end;

define C-function g-ptr-array-set-size
  input parameter array :: <GPtrArray>;
  input parameter length :: <gint>;
  c-name: "g_ptr_array_set_size";
end;

define C-function g-ptr-array-remove-index
  input parameter array :: <GPtrArray>;
  input parameter index_ :: <guint>;
  result res :: <gpointer>;
  c-name: "g_ptr_array_remove_index";
end;

define C-function g-ptr-array-remove-index-fast
  input parameter array :: <GPtrArray>;
  input parameter index_ :: <guint>;
  result res :: <gpointer>;
  c-name: "g_ptr_array_remove_index_fast";
end;

define C-function g-ptr-array-remove
  input parameter array :: <GPtrArray>;
  input parameter data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_ptr_array_remove";
end;

define C-function g-ptr-array-remove-fast
  input parameter array :: <GPtrArray>;
  input parameter data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_ptr_array_remove_fast";
end;

define C-function g-ptr-array-remove-range
  input parameter array :: <GPtrArray>;
  input parameter index_ :: <guint>;
  input parameter length :: <guint>;
  c-name: "g_ptr_array_remove_range";
end;

define C-function g-ptr-array-add
  input parameter array :: <GPtrArray>;
  input parameter data :: <gpointer>;
  c-name: "g_ptr_array_add";
end;

define C-function g-ptr-array-sort
  input parameter array :: <GPtrArray>;
  input parameter compare_func :: <GCompareFunc>;
  c-name: "g_ptr_array_sort";
end;

define C-function g-ptr-array-sort-with-data
  input parameter array :: <GPtrArray>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_ptr_array_sort_with_data";
end;

define C-function g-ptr-array-foreach
  input parameter array :: <GPtrArray>;
  input parameter func :: <GFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_ptr_array_foreach";
end;

define C-function g-byte-array-new
  result res :: <GByteArray>;
  c-name: "g_byte_array_new";
end;

define C-function g-byte-array-sized-new
  input parameter reserved_size :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_sized_new";
end;

define C-function g-byte-array-free
  input parameter array :: <GByteArray>;
  input parameter free_segment :: <gboolean>;
  result res :: <guint8*>;
  c-name: "g_byte_array_free";
end;

define C-function g-byte-array-append
  input parameter array :: <GByteArray>;
  input parameter data :: <guint8*>;
  input parameter len :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_append";
end;

define C-function g-byte-array-prepend
  input parameter array :: <GByteArray>;
  input parameter data :: <guint8*>;
  input parameter len :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_prepend";
end;

define C-function g-byte-array-set-size
  input parameter array :: <GByteArray>;
  input parameter length :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_set_size";
end;

define C-function g-byte-array-remove-index
  input parameter array :: <GByteArray>;
  input parameter index_ :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_remove_index";
end;

define C-function g-byte-array-remove-index-fast
  input parameter array :: <GByteArray>;
  input parameter index_ :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_remove_index_fast";
end;

define C-function g-byte-array-remove-range
  input parameter array :: <GByteArray>;
  input parameter index_ :: <guint>;
  input parameter length :: <guint>;
  result res :: <GByteArray>;
  c-name: "g_byte_array_remove_range";
end;

define C-function g-byte-array-sort
  input parameter array :: <GByteArray>;
  input parameter compare_func :: <GCompareFunc>;
  c-name: "g_byte_array_sort";
end;

define C-function g-byte-array-sort-with-data
  input parameter array :: <GByteArray>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "g_byte_array_sort_with_data";
end;

define C-pointer-type <int*> => <integer>;
define C-subtype <_heapinfo> (<C-void*>) end;
define constant <_HEAPINFO> = <_heapinfo>;

 /* Ignoring declaration for {instance of <variable-declaration>} "_amblksiz"*/
define C-function calloc
  input parameter  :: <size-t>;
  input parameter  :: <size-t>;
  result res :: <machine-pointer>;
  c-name: "calloc";
end;

define C-function free
  input parameter  :: <machine-pointer>;
  c-name: "free";
end;

define C-function malloc
  input parameter  :: <size-t>;
  result res :: <machine-pointer>;
  c-name: "malloc";
end;

define C-function realloc
  input parameter  :: <machine-pointer>;
  input parameter  :: <size-t>;
  result res :: <machine-pointer>;
  c-name: "realloc";
end;

define constant $_HEAP-MAXREQ = #ex00000000FFFFFFE0;

define constant $_HEAPEMPTY = -1;

define constant $_HEAPOK = -2;

define constant $_HEAPBADBEGIN = -3;

define constant $_HEAPBADNODE = -4;

define constant $_HEAPEND = -5;

define constant $_HEAPBADPTR = -6;

define constant $_FREEENTRY = 0;

define constant $_USEDENTRY = 1;

define C-subtype <_GValueArray> (<C-void*>) end;
define constant <GValueArray> = <_GValueArray>;

define C-function g-value-array-get-nth
  input parameter value_array :: <GValueArray>;
  input parameter index_ :: <guint>;
  result res :: <GValue>;
  c-name: "g_value_array_get_nth";
end;

define C-function g-value-array-new
  input parameter n_prealloced :: <guint>;
  result res :: <GValueArray>;
  c-name: "g_value_array_new";
end;

define C-function g-value-array-free
  input parameter value_array :: <GValueArray>;
  c-name: "g_value_array_free";
end;

define C-function g-value-array-copy
  input parameter value_array :: <GValueArray>;
  result res :: <GValueArray>;
  c-name: "g_value_array_copy";
end;

define C-function g-value-array-prepend
  input parameter value_array :: <GValueArray>;
  input parameter value :: <GValue>;
  result res :: <GValueArray>;
  c-name: "g_value_array_prepend";
end;

define C-function g-value-array-append
  input parameter value_array :: <GValueArray>;
  input parameter value :: <GValue>;
  result res :: <GValueArray>;
  c-name: "g_value_array_append";
end;

define C-function g-value-array-insert
  input parameter value_array :: <GValueArray>;
  input parameter index_ :: <guint>;
  input parameter value :: <GValue>;
  result res :: <GValueArray>;
  c-name: "g_value_array_insert";
end;

define C-function g-value-array-remove
  input parameter value_array :: <GValueArray>;
  input parameter index_ :: <guint>;
  result res :: <GValueArray>;
  c-name: "g_value_array_remove";
end;

define C-function g-value-array-sort
  input parameter value_array :: <GValueArray>;
  input parameter compare_func :: <GCompareFunc>;
  result res :: <GValueArray>;
  c-name: "g_value_array_sort";
end;

define C-function g-value-array-sort-with-data
  input parameter value_array :: <GValueArray>;
  input parameter compare_func :: <GCompareDataFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GValueArray>;
  c-name: "g_value_array_sort_with_data";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1755>"*/
define constant <GTypePluginUse> = <anonymous-1755>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1756>"*/
define constant <GTypePluginUnuse> = <anonymous-1756>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1757>"*/
define constant <GTypePluginCompleteTypeInfo> = <anonymous-1757>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1758>"*/
define constant <GTypePluginCompleteInterfaceInfo> = <anonymous-1758>;

define C-subtype <_GTypePluginClass> (<C-void*>) end;
define constant <GTypePluginClass> = <_GTypePluginClass>;

define C-function g-type-plugin-get-type
  result res :: <GType>;
  c-name: "g_type_plugin_get_type";
end;

define C-function g-type-plugin-use
  input parameter plugin :: <GTypePlugin>;
  c-name: "g_type_plugin_use";
end;

define C-function g-type-plugin-unuse
  input parameter plugin :: <GTypePlugin>;
  c-name: "g_type_plugin_unuse";
end;

define C-function g-type-plugin-complete-type-info
  input parameter plugin :: <GTypePlugin>;
  input parameter g_type :: <GType>;
  input parameter info :: <GTypeInfo>;
  input parameter value_table :: <GTypeValueTable>;
  c-name: "g_type_plugin_complete_type_info";
end;

define C-function g-type-plugin-complete-interface-info
  input parameter plugin :: <GTypePlugin>;
  input parameter instance_type :: <GType>;
  input parameter interface_type :: <GType>;
  input parameter info :: <GInterfaceInfo>;
  c-name: "g_type_plugin_complete_interface_info";
end;

define C-subtype <_GTypeModule> (<C-void*>) end;
define constant <GTypeModule> = <_GTypeModule>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1741>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1742>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1743>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1744>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1745>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1746>"*/
define C-subtype <_GTypeModuleClass> (<C-void*>) end;
define constant <GTypeModuleClass> = <_GTypeModuleClass>;

define C-function g-type-module-get-type
  result res :: <GType>;
  c-name: "g_type_module_get_type";
end;

define C-function g-type-module-use
  input parameter module :: <GTypeModule>;
  result res :: <gboolean>;
  c-name: "g_type_module_use";
end;

define C-function g-type-module-unuse
  input parameter module :: <GTypeModule>;
  c-name: "g_type_module_unuse";
end;

define C-function g-type-module-set-name
  input parameter module :: <GTypeModule>;
  input parameter name :: <c-string>;
  c-name: "g_type_module_set_name";
end;

define C-function g-type-module-register-type
  input parameter module :: <GTypeModule>;
  input parameter parent_type :: <GType>;
  input parameter type_name :: <c-string>;
  input parameter type_info :: <GTypeInfo>;
  input parameter flags :: <GTypeFlags>;
  result res :: <GType>;
  c-name: "g_type_module_register_type";
end;

define C-function g-type-module-add-interface
  input parameter module :: <GTypeModule>;
  input parameter instance_type :: <GType>;
  input parameter interface_type :: <GType>;
  input parameter interface_info :: <GInterfaceInfo>;
  c-name: "g_type_module_add_interface";
end;

define C-subtype <_GEnumValue> (<C-void*>) end;
define constant <GEnumValue> = <_GEnumValue>;

define C-function g-type-module-register-enum
  input parameter module :: <GTypeModule>;
  input parameter name :: <c-string>;
  input parameter const_static_values :: <GEnumValue>;
  result res :: <GType>;
  c-name: "g_type_module_register_enum";
end;

define C-subtype <_GFlagsValue> (<C-void*>) end;
define constant <GFlagsValue> = <_GFlagsValue>;

define C-function g-type-module-register-flags
  input parameter module :: <GTypeModule>;
  input parameter name :: <c-string>;
  input parameter const_static_values :: <GFlagsValue>;
  result res :: <GType>;
  c-name: "g_type_module_register_flags";
end;

define C-subtype <_GEnumClass> (<C-void*>) end;
define constant <GEnumClass> = <_GEnumClass>;

define C-subtype <_GFlagsClass> (<C-void*>) end;
define constant <GFlagsClass> = <_GFlagsClass>;

define C-function g-enum-get-value
  input parameter enum_class :: <GEnumClass>;
  input parameter value :: <gint>;
  result res :: <GEnumValue>;
  c-name: "g_enum_get_value";
end;

define C-function g-enum-get-value-by-name
  input parameter enum_class :: <GEnumClass>;
  input parameter name :: <c-string>;
  result res :: <GEnumValue>;
  c-name: "g_enum_get_value_by_name";
end;

define C-function g-enum-get-value-by-nick
  input parameter enum_class :: <GEnumClass>;
  input parameter nick :: <c-string>;
  result res :: <GEnumValue>;
  c-name: "g_enum_get_value_by_nick";
end;

define C-function g-flags-get-first-value
  input parameter flags_class :: <GFlagsClass>;
  input parameter value :: <guint>;
  result res :: <GFlagsValue>;
  c-name: "g_flags_get_first_value";
end;

define C-function g-flags-get-value-by-name
  input parameter flags_class :: <GFlagsClass>;
  input parameter name :: <c-string>;
  result res :: <GFlagsValue>;
  c-name: "g_flags_get_value_by_name";
end;

define C-function g-flags-get-value-by-nick
  input parameter flags_class :: <GFlagsClass>;
  input parameter nick :: <c-string>;
  result res :: <GFlagsValue>;
  c-name: "g_flags_get_value_by_nick";
end;

define C-function g-value-set-enum
  input parameter value :: <GValue>;
  input parameter v_enum :: <gint>;
  c-name: "g_value_set_enum";
end;

define C-function g-value-get-enum
  input parameter value :: <GValue>;
  result res :: <gint>;
  c-name: "g_value_get_enum";
end;

define C-function g-value-set-flags
  input parameter value :: <GValue>;
  input parameter v_flags :: <guint>;
  c-name: "g_value_set_flags";
end;

define C-function g-value-get-flags
  input parameter value :: <GValue>;
  result res :: <guint>;
  c-name: "g_value_get_flags";
end;

define C-function g-enum-register-static
  input parameter name :: <c-string>;
  input parameter const_static_values :: <GEnumValue>;
  result res :: <GType>;
  c-name: "g_enum_register_static";
end;

define C-function g-flags-register-static
  input parameter name :: <c-string>;
  input parameter const_static_values :: <GFlagsValue>;
  result res :: <GType>;
  c-name: "g_flags_register_static";
end;

define C-function g-enum-complete-type-info
  input parameter g_enum_type :: <GType>;
  input parameter info :: <GTypeInfo>;
  input parameter const_values :: <GEnumValue>;
  c-name: "g_enum_complete_type_info";
end;

define C-function g-flags-complete-type-info
  input parameter g_flags_type :: <GType>;
  input parameter info :: <GTypeInfo>;
  input parameter const_values :: <GFlagsValue>;
  c-name: "g_flags_complete_type_info";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1649>"*/
define constant <GObjectGetPropertyFunc> = <anonymous-1649>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1650>"*/
define constant <GObjectSetPropertyFunc> = <anonymous-1650>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1651>"*/
define constant <GObjectFinalizeFunc> = <anonymous-1651>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1652>"*/
define constant <GWeakNotify> = <anonymous-1652>;

define C-function g-initially-unowned-get-type
  result res :: <GType>;
  c-name: "g_initially_unowned_get_type";
end;

define C-function g-object-class-install-property
  input parameter oclass :: <GObjectClass>;
  input parameter property_id :: <guint>;
  input parameter pspec :: <GParamSpec>;
  c-name: "g_object_class_install_property";
end;

define C-function g-object-class-find-property
  input parameter oclass :: <GObjectClass>;
  input parameter property_name :: <c-string>;
  result res :: <GParamSpec>;
  c-name: "g_object_class_find_property";
end;

define C-function g-object-class-list-properties
  input parameter oclass :: <GObjectClass>;
  input parameter n_properties :: <guint*>;
  result res :: <GParamSpec*>;
  c-name: "g_object_class_list_properties";
end;

define C-function g-object-class-override-property
  input parameter oclass :: <GObjectClass>;
  input parameter property_id :: <guint>;
  input parameter name :: <c-string>;
  c-name: "g_object_class_override_property";
end;

define C-function g-object-interface-install-property
  input parameter g_iface :: <gpointer>;
  input parameter pspec :: <GParamSpec>;
  c-name: "g_object_interface_install_property";
end;

define C-function g-object-interface-find-property
  input parameter g_iface :: <gpointer>;
  input parameter property_name :: <c-string>;
  result res :: <GParamSpec>;
  c-name: "g_object_interface_find_property";
end;

define C-function g-object-interface-list-properties
  input parameter g_iface :: <gpointer>;
  input parameter n_properties_p :: <guint*>;
  result res :: <GParamSpec*>;
  c-name: "g_object_interface_list_properties";
end;

define C-function g-object-new
  input parameter object_type :: <GType>;
  input parameter first_property_name :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_object_new";
end;

define C-subtype <_GParameter> (<C-void*>) end;
define constant <GParameter> = <_GParameter>;

define C-function g-object-newv
  input parameter object_type :: <GType>;
  input parameter n_parameters :: <guint>;
  input parameter parameters :: <GParameter>;
  result res :: <gpointer>;
  c-name: "g_object_newv";
end;

define C-function g-object-new-valist
  input parameter object_type :: <GType>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  result res :: <GObject>;
  c-name: "g_object_new_valist";
end;

define C-function g-object-set
  input parameter object :: <gpointer>;
  input parameter first_property_name :: <c-string>;
  c-name: "g_object_set";
end;

define C-function g-object-get
  input parameter object :: <gpointer>;
  input parameter first_property_name :: <c-string>;
  c-name: "g_object_get";
end;

define C-function g-object-connect
  input parameter object :: <gpointer>;
  input parameter signal_spec :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_object_connect";
end;

define C-function g-object-disconnect
  input parameter object :: <gpointer>;
  input parameter signal_spec :: <c-string>;
  c-name: "g_object_disconnect";
end;

define C-function g-object-set-valist
  input parameter object :: <GObject>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  c-name: "g_object_set_valist";
end;

define C-function g-object-get-valist
  input parameter object :: <GObject>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  c-name: "g_object_get_valist";
end;

define C-function g-object-set-property
  input parameter object :: <GObject>;
  input parameter property_name :: <c-string>;
  input parameter value :: <GValue>;
  c-name: "g_object_set_property";
end;

define C-function g-object-get-property
  input parameter object :: <GObject>;
  input parameter property_name :: <c-string>;
  input parameter value :: <GValue>;
  c-name: "g_object_get_property";
end;

define C-function g-object-freeze-notify
  input parameter object :: <GObject>;
  c-name: "g_object_freeze_notify";
end;

define C-function g-object-notify
  input parameter object :: <GObject>;
  input parameter property_name :: <c-string>;
  c-name: "g_object_notify";
end;

define C-function g-object-thaw-notify
  input parameter object :: <GObject>;
  c-name: "g_object_thaw_notify";
end;

define C-function g-object-is-floating
  input parameter object :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_object_is_floating";
end;

define C-function g-object-ref-sink
  input parameter object :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_object_ref_sink";
end;

define C-function g-object-ref
  input parameter object :: <gpointer>;
  result res :: <gpointer>;
  c-name: "g_object_ref";
end;

define C-function g-object-unref
  input parameter object :: <gpointer>;
  c-name: "g_object_unref";
end;

define C-function g-object-weak-ref
  input parameter object :: <GObject>;
  input parameter notify :: <GWeakNotify>;
  input parameter data :: <gpointer>;
  c-name: "g_object_weak_ref";
end;

define C-function g-object-weak-unref
  input parameter object :: <GObject>;
  input parameter notify :: <GWeakNotify>;
  input parameter data :: <gpointer>;
  c-name: "g_object_weak_unref";
end;

define C-function g-object-add-weak-pointer
  input parameter object :: <GObject>;
  input parameter weak_pointer_location :: <gpointer*>;
  c-name: "g_object_add_weak_pointer";
end;

define C-function g-object-remove-weak-pointer
  input parameter object :: <GObject>;
  input parameter weak_pointer_location :: <gpointer*>;
  c-name: "g_object_remove_weak_pointer";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1690>"*/
define constant <GToggleNotify> = <anonymous-1690>;

define C-function g-object-add-toggle-ref
  input parameter object :: <GObject>;
  input parameter notify :: <GToggleNotify>;
  input parameter data :: <gpointer>;
  c-name: "g_object_add_toggle_ref";
end;

define C-function g-object-remove-toggle-ref
  input parameter object :: <GObject>;
  input parameter notify :: <GToggleNotify>;
  input parameter data :: <gpointer>;
  c-name: "g_object_remove_toggle_ref";
end;

define C-function g-object-get-qdata
  input parameter object :: <GObject>;
  input parameter quark :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_object_get_qdata";
end;

define C-function g-object-set-qdata
  input parameter object :: <GObject>;
  input parameter quark :: <GQuark>;
  input parameter data :: <gpointer>;
  c-name: "g_object_set_qdata";
end;

define C-function g-object-set-qdata-full
  input parameter object :: <GObject>;
  input parameter quark :: <GQuark>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "g_object_set_qdata_full";
end;

define C-function g-object-steal-qdata
  input parameter object :: <GObject>;
  input parameter quark :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_object_steal_qdata";
end;

define C-function g-object-get-data
  input parameter object :: <GObject>;
  input parameter key :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_object_get_data";
end;

define C-function g-object-set-data
  input parameter object :: <GObject>;
  input parameter key :: <c-string>;
  input parameter data :: <gpointer>;
  c-name: "g_object_set_data";
end;

define C-function g-object-set-data-full
  input parameter object :: <GObject>;
  input parameter key :: <c-string>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "g_object_set_data_full";
end;

define C-function g-object-steal-data
  input parameter object :: <GObject>;
  input parameter key :: <c-string>;
  result res :: <gpointer>;
  c-name: "g_object_steal_data";
end;

define C-function g-object-watch-closure
  input parameter object :: <GObject>;
  input parameter closure :: <GClosure>;
  c-name: "g_object_watch_closure";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1560>"*/
define constant <GCallback> = <anonymous-1560>;

define C-function g-cclosure-new-object
  input parameter callback_func :: <GCallback>;
  input parameter object :: <GObject>;
  result res :: <GClosure>;
  c-name: "g_cclosure_new_object";
end;

define C-function g-cclosure-new-object-swap
  input parameter callback_func :: <GCallback>;
  input parameter object :: <GObject>;
  result res :: <GClosure>;
  c-name: "g_cclosure_new_object_swap";
end;

define C-function g-closure-new-object
  input parameter sizeof_closure :: <guint>;
  input parameter object :: <GObject>;
  result res :: <GClosure>;
  c-name: "g_closure_new_object";
end;

define C-function g-value-set-object
  input parameter value :: <GValue>;
  input parameter v_object :: <gpointer>;
  c-name: "g_value_set_object";
end;

define C-function g-value-get-object
  input parameter value :: <GValue>;
  result res :: <gpointer>;
  c-name: "g_value_get_object";
end;

define C-function g-value-dup-object
  input parameter value :: <GValue>;
  result res :: <GObject>;
  c-name: "g_value_dup_object";
end;

define constant <GConnectFlags> = limited(<integer>, min: 1, max: 2);
define constant $G-CONNECT-AFTER :: <GConnectFlags> = 1;
define constant $G-CONNECT-SWAPPED :: <GConnectFlags> = 2;

define C-function g-signal-connect-object
  input parameter instance :: <gpointer>;
  input parameter detailed_signal :: <c-string>;
  input parameter c_handler :: <GCallback>;
  input parameter gobject :: <gpointer>;
  input parameter connect_flags :: <GConnectFlags>;
  result res :: <gulong>;
  c-name: "g_signal_connect_object";
end;

define C-function g-object-force-floating
  input parameter object :: <GObject>;
  c-name: "g_object_force_floating";
end;

define C-function g-object-run-dispose
  input parameter object :: <GObject>;
  c-name: "g_object_run_dispose";
end;

define C-function g-value-take-object
  input parameter value :: <GValue>;
  input parameter v_object :: <gpointer>;
  c-name: "g_value_take_object";
end;

define C-function g-value-set-object-take-ownership
  input parameter value :: <GValue>;
  input parameter v_object :: <gpointer>;
  c-name: "g_value_set_object_take_ownership";
end;

define C-function g-object-compat-control
  input parameter what :: <gsize>;
  input parameter data :: <gpointer>;
  result res :: <gsize>;
  c-name: "g_object_compat_control";
end;

define constant <GSignalFlags> = limited(<integer>, min: 1, max: 64);
define constant $G-SIGNAL-RUN-FIRST :: <GSignalFlags> = 1;
define constant $G-SIGNAL-RUN-LAST :: <GSignalFlags> = 2;
define constant $G-SIGNAL-RUN-CLEANUP :: <GSignalFlags> = 4;
define constant $G-SIGNAL-NO-RECURSE :: <GSignalFlags> = 8;
define constant $G-SIGNAL-DETAILED :: <GSignalFlags> = 16;
define constant $G-SIGNAL-ACTION :: <GSignalFlags> = 32;
define constant $G-SIGNAL-NO-HOOKS :: <GSignalFlags> = 64;

define C-subtype <_GSignalQuery> (<C-void*>) end;
define constant <GSignalQuery> = <_GSignalQuery>;

define C-subtype <_GSignalInvocationHint> (<C-void*>) end;
define constant <GSignalInvocationHint> = <_GSignalInvocationHint>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1562>"*/
define constant <GClosureMarshal> = <anonymous-1562>;

define constant <GSignalCMarshaller> = <GClosureMarshal>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1610>"*/
define constant <GSignalEmissionHook> = <anonymous-1610>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1611>"*/
define constant <GSignalAccumulator> = <anonymous-1611>;

define constant <GSignalMatchType> = limited(<integer>, min: 1, max: 32);
define constant $G-SIGNAL-MATCH-ID :: <GSignalMatchType> = 1;
define constant $G-SIGNAL-MATCH-DETAIL :: <GSignalMatchType> = 2;
define constant $G-SIGNAL-MATCH-CLOSURE :: <GSignalMatchType> = 4;
define constant $G-SIGNAL-MATCH-FUNC :: <GSignalMatchType> = 8;
define constant $G-SIGNAL-MATCH-DATA :: <GSignalMatchType> = 16;
define constant $G-SIGNAL-MATCH-UNBLOCKED :: <GSignalMatchType> = 32;

define C-function g-signal-newv
  input parameter signal_name :: <c-string>;
  input parameter itype :: <GType>;
  input parameter signal_flags :: <GSignalFlags>;
  input parameter class_closure :: <GClosure>;
  input parameter accumulator :: <GSignalAccumulator>;
  input parameter accu_data :: <gpointer>;
  input parameter c_marshaller :: <GSignalCMarshaller>;
  input parameter return_type :: <GType>;
  input parameter n_params :: <guint>;
  input parameter param_types :: <GType*>;
  result res :: <guint>;
  c-name: "g_signal_newv";
end;

define C-function g-signal-new-valist
  input parameter signal_name :: <c-string>;
  input parameter itype :: <GType>;
  input parameter signal_flags :: <GSignalFlags>;
  input parameter class_closure :: <GClosure>;
  input parameter accumulator :: <GSignalAccumulator>;
  input parameter accu_data :: <gpointer>;
  input parameter c_marshaller :: <GSignalCMarshaller>;
  input parameter return_type :: <GType>;
  input parameter n_params :: <guint>;
  input parameter args :: <va-list>;
  result res :: <guint>;
  c-name: "g_signal_new_valist";
end;

define C-function g-signal-new
  input parameter signal_name :: <c-string>;
  input parameter itype :: <GType>;
  input parameter signal_flags :: <GSignalFlags>;
  input parameter class_offset :: <guint>;
  input parameter accumulator :: <GSignalAccumulator>;
  input parameter accu_data :: <gpointer>;
  input parameter c_marshaller :: <GSignalCMarshaller>;
  input parameter return_type :: <GType>;
  input parameter n_params :: <guint>;
  result res :: <guint>;
  c-name: "g_signal_new";
end;

define C-function g-signal-emitv
  input parameter instance_and_params :: <GValue>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter return_value :: <GValue>;
  c-name: "g_signal_emitv";
end;

define C-function g-signal-emit-valist
  input parameter instance :: <gpointer>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter var_args :: <va-list>;
  c-name: "g_signal_emit_valist";
end;

define C-function g-signal-emit
  input parameter instance :: <gpointer>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  c-name: "g_signal_emit";
end;

define C-function g-signal-emit-by-name
  input parameter instance :: <gpointer>;
  input parameter detailed_signal :: <c-string>;
  c-name: "g_signal_emit_by_name";
end;

define C-function g-signal-lookup
  input parameter name :: <c-string>;
  input parameter itype :: <GType>;
  result res :: <guint>;
  c-name: "g_signal_lookup";
end;

define C-function g-signal-name
  input parameter signal_id :: <guint>;
  result res :: <c-string>;
  c-name: "g_signal_name";
end;

define C-function g-signal-query
  input parameter signal_id :: <guint>;
  input parameter query :: <GSignalQuery>;
  c-name: "g_signal_query";
end;

define C-function g-signal-list-ids
  input parameter itype :: <GType>;
  input parameter n_ids :: <guint*>;
  result res :: <guint*>;
  c-name: "g_signal_list_ids";
end;

define C-pointer-type <GQuark*> => <GQuark>;
define C-function g-signal-parse-name
  input parameter detailed_signal :: <c-string>;
  input parameter itype :: <GType>;
  input parameter signal_id_p :: <guint*>;
  input parameter detail_p :: <GQuark*>;
  input parameter force_detail_quark :: <gboolean>;
  result res :: <gboolean>;
  c-name: "g_signal_parse_name";
end;

define C-function g-signal-get-invocation-hint
  input parameter instance :: <gpointer>;
  result res :: <GSignalInvocationHint>;
  c-name: "g_signal_get_invocation_hint";
end;

define C-function g-signal-stop-emission
  input parameter instance :: <gpointer>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  c-name: "g_signal_stop_emission";
end;

define C-function g-signal-stop-emission-by-name
  input parameter instance :: <gpointer>;
  input parameter detailed_signal :: <c-string>;
  c-name: "g_signal_stop_emission_by_name";
end;

define C-function g-signal-add-emission-hook
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter hook_func :: <GSignalEmissionHook>;
  input parameter hook_data :: <gpointer>;
  input parameter data_destroy :: <GDestroyNotify>;
  result res :: <gulong>;
  c-name: "g_signal_add_emission_hook";
end;

define C-function g-signal-remove-emission-hook
  input parameter signal_id :: <guint>;
  input parameter hook_id :: <gulong>;
  c-name: "g_signal_remove_emission_hook";
end;

define C-function g-signal-has-handler-pending
  input parameter instance :: <gpointer>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter may_be_blocked :: <gboolean>;
  result res :: <gboolean>;
  c-name: "g_signal_has_handler_pending";
end;

define C-function g-signal-connect-closure-by-id
  input parameter instance :: <gpointer>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter closure :: <GClosure>;
  input parameter after :: <gboolean>;
  result res :: <gulong>;
  c-name: "g_signal_connect_closure_by_id";
end;

define C-function g-signal-connect-closure
  input parameter instance :: <GObject>;
  input parameter detailed_signal :: <c-string>;
  input parameter closure :: <GClosure>;
  input parameter after :: <gboolean>;
  result res :: <gulong>;
  c-name: "g_signal_connect_closure";
end;

define C-function g-signal-connect-data
  input parameter instance :: <GObject>;
  input parameter detailed_signal :: <c-string>;
  input parameter c_handler :: <GCallback>;
  input parameter data :: <gpointer>;
  input parameter destroy_data :: <GClosureNotify>;
  input parameter connect_flags :: <integer>;
  result res :: <gulong>;
  c-name: "g_signal_connect_data";
end;

define C-function g-signal-handler-block
  input parameter instance :: <gpointer>;
  input parameter handler_id :: <gulong>;
  c-name: "g_signal_handler_block";
end;

define C-function g-signal-handler-unblock
  input parameter instance :: <gpointer>;
  input parameter handler_id :: <gulong>;
  c-name: "g_signal_handler_unblock";
end;

define C-function g-signal-handler-disconnect
  input parameter instance :: <gpointer>;
  input parameter handler_id :: <gulong>;
  c-name: "g_signal_handler_disconnect";
end;

define C-function g-signal-handler-is-connected
  input parameter instance :: <gpointer>;
  input parameter handler_id :: <gulong>;
  result res :: <gboolean>;
  c-name: "g_signal_handler_is_connected";
end;

define C-function g-signal-handler-find
  input parameter instance :: <gpointer>;
  input parameter mask :: <GSignalMatchType>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter closure :: <GClosure>;
  input parameter func :: <gpointer>;
  input parameter data :: <gpointer>;
  result res :: <gulong>;
  c-name: "g_signal_handler_find";
end;

define C-function g-signal-handlers-block-matched
  input parameter instance :: <gpointer>;
  input parameter mask :: <GSignalMatchType>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter closure :: <GClosure>;
  input parameter func :: <gpointer>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_signal_handlers_block_matched";
end;

define C-function g-signal-handlers-unblock-matched
  input parameter instance :: <gpointer>;
  input parameter mask :: <GSignalMatchType>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter closure :: <GClosure>;
  input parameter func :: <gpointer>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_signal_handlers_unblock_matched";
end;

define C-function g-signal-handlers-disconnect-matched
  input parameter instance :: <gpointer>;
  input parameter mask :: <GSignalMatchType>;
  input parameter signal_id :: <guint>;
  input parameter detail :: <GQuark>;
  input parameter closure :: <GClosure>;
  input parameter func :: <gpointer>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "g_signal_handlers_disconnect_matched";
end;

define C-function g-signal-override-class-closure
  input parameter signal_id :: <guint>;
  input parameter instance_type :: <GType>;
  input parameter class_closure :: <GClosure>;
  c-name: "g_signal_override_class_closure";
end;

define C-function g-signal-chain-from-overridden
  input parameter instance_and_params :: <GValue>;
  input parameter return_value :: <GValue>;
  c-name: "g_signal_chain_from_overridden";
end;

define C-function g-signal-accumulator-true-handled
  input parameter ihint :: <GSignalInvocationHint>;
  input parameter return_accu :: <GValue>;
  input parameter handler_return :: <GValue>;
  input parameter dummy :: <gpointer>;
  result res :: <gboolean>;
  c-name: "g_signal_accumulator_true_handled";
end;

define C-function g-signal-handlers-destroy
  input parameter instance :: <gpointer>;
  c-name: "g_signal_handlers_destroy";
end;

define C-function _g-signals-destroy
  input parameter itype :: <GType>;
  c-name: "_g_signals_destroy";
end;

define constant $G-SIGNAL-FLAGS-MASK = 127;

define constant $G-SIGNAL-MATCH-MASK = 63;

define constant $G-SIGNAL-TYPE-STATIC-SCOPE = 1;

define C-function g-cclosure-marshal-VOID--VOID
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__VOID";
end;

define C-function g-cclosure-marshal-VOID--BOOLEAN
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__BOOLEAN";
end;

define C-function g-cclosure-marshal-VOID--CHAR
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__CHAR";
end;

define C-function g-cclosure-marshal-VOID--UCHAR
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__UCHAR";
end;

define C-function g-cclosure-marshal-VOID--INT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__INT";
end;

define C-function g-cclosure-marshal-VOID--UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__UINT";
end;

define C-function g-cclosure-marshal-VOID--LONG
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__LONG";
end;

define C-function g-cclosure-marshal-VOID--ULONG
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__ULONG";
end;

define C-function g-cclosure-marshal-VOID--ENUM
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__ENUM";
end;

define C-function g-cclosure-marshal-VOID--FLAGS
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__FLAGS";
end;

define C-function g-cclosure-marshal-VOID--FLOAT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__FLOAT";
end;

define C-function g-cclosure-marshal-VOID--DOUBLE
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__DOUBLE";
end;

define C-function g-cclosure-marshal-VOID--STRING
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__STRING";
end;

define C-function g-cclosure-marshal-VOID--PARAM
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__PARAM";
end;

define C-function g-cclosure-marshal-VOID--BOXED
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__BOXED";
end;

define C-function g-cclosure-marshal-VOID--POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__POINTER";
end;

define C-function g-cclosure-marshal-VOID--OBJECT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__OBJECT";
end;

define C-function g-cclosure-marshal-VOID--UINT-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_VOID__UINT_POINTER";
end;

define C-function g-cclosure-marshal-BOOLEAN--FLAGS
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_BOOLEAN__FLAGS";
end;

define C-function g-cclosure-marshal-STRING--OBJECT-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "g_cclosure_marshal_STRING__OBJECT_POINTER";
end;

define constant g-cclosure-marshal-BOOL--FLAGS = g-cclosure-marshal-BOOLEAN--FLAGS;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1520>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1521>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1522>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1523>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<gpointer<@4>>"*/
define C-subtype <_GParamSpecClass> (<C-void*>) end;
define constant <GParamSpecClass> = <_GParamSpecClass>;

define C-subtype <_GParamSpecPool> (<C-void*>) end;
define constant <GParamSpecPool> = <_GParamSpecPool>;

define C-function g-param-spec-ref
  input parameter pspec :: <GParamSpec>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_ref";
end;

define C-function g-param-spec-unref
  input parameter pspec :: <GParamSpec>;
  c-name: "g_param_spec_unref";
end;

define C-function g-param-spec-sink
  input parameter pspec :: <GParamSpec>;
  c-name: "g_param_spec_sink";
end;

define C-function g-param-spec-ref-sink
  input parameter pspec :: <GParamSpec>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_ref_sink";
end;

define C-function g-param-spec-get-qdata
  input parameter pspec :: <GParamSpec>;
  input parameter quark :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_param_spec_get_qdata";
end;

define C-function g-param-spec-set-qdata
  input parameter pspec :: <GParamSpec>;
  input parameter quark :: <GQuark>;
  input parameter data :: <gpointer>;
  c-name: "g_param_spec_set_qdata";
end;

define C-function g-param-spec-set-qdata-full
  input parameter pspec :: <GParamSpec>;
  input parameter quark :: <GQuark>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "g_param_spec_set_qdata_full";
end;

define C-function g-param-spec-steal-qdata
  input parameter pspec :: <GParamSpec>;
  input parameter quark :: <GQuark>;
  result res :: <gpointer>;
  c-name: "g_param_spec_steal_qdata";
end;

define C-function g-param-spec-get-redirect-target
  input parameter pspec :: <GParamSpec>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_get_redirect_target";
end;

define C-function g-param-value-set-default
  input parameter pspec :: <GParamSpec>;
  input parameter value :: <GValue>;
  c-name: "g_param_value_set_default";
end;

define C-function g-param-value-defaults
  input parameter pspec :: <GParamSpec>;
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_param_value_defaults";
end;

define C-function g-param-value-validate
  input parameter pspec :: <GParamSpec>;
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "g_param_value_validate";
end;

define C-function g-param-value-convert
  input parameter pspec :: <GParamSpec>;
  input parameter src_value :: <GValue>;
  input parameter dest_value :: <GValue>;
  input parameter strict_validation :: <gboolean>;
  result res :: <gboolean>;
  c-name: "g_param_value_convert";
end;

define C-function g-param-values-cmp
  input parameter pspec :: <GParamSpec>;
  input parameter value1 :: <GValue>;
  input parameter value2 :: <GValue>;
  result res :: <gint>;
  c-name: "g_param_values_cmp";
end;

define C-function g-param-spec-get-name
  input parameter pspec :: <GParamSpec>;
  result res :: <c-string>;
  c-name: "g_param_spec_get_name";
end;

define C-function g-param-spec-get-nick
  input parameter pspec :: <GParamSpec>;
  result res :: <c-string>;
  c-name: "g_param_spec_get_nick";
end;

define C-function g-param-spec-get-blurb
  input parameter pspec :: <GParamSpec>;
  result res :: <c-string>;
  c-name: "g_param_spec_get_blurb";
end;

define C-function g-value-set-param
  input parameter value :: <GValue>;
  input parameter param :: <GParamSpec>;
  c-name: "g_value_set_param";
end;

define C-function g-value-get-param
  input parameter value :: <GValue>;
  result res :: <GParamSpec>;
  c-name: "g_value_get_param";
end;

define C-function g-value-dup-param
  input parameter value :: <GValue>;
  result res :: <GParamSpec>;
  c-name: "g_value_dup_param";
end;

define C-function g-value-take-param
  input parameter value :: <GValue>;
  input parameter param :: <GParamSpec>;
  c-name: "g_value_take_param";
end;

define C-function g-value-set-param-take-ownership
  input parameter value :: <GValue>;
  input parameter param :: <GParamSpec>;
  c-name: "g_value_set_param_take_ownership";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1546>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1547>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1548>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1549>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1550>"*/
define C-subtype <_GParamSpecTypeInfo> (<C-void*>) end;
define constant <GParamSpecTypeInfo> = <_GParamSpecTypeInfo>;

define C-function g-param-type-register-static
  input parameter name :: <c-string>;
  input parameter pspec_info :: <GParamSpecTypeInfo>;
  result res :: <GType>;
  c-name: "g_param_type_register_static";
end;

define C-function g-param-spec-internal
  input parameter param_type :: <GType>;
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter flags :: <GParamFlags>;
  result res :: <gpointer>;
  c-name: "g_param_spec_internal";
end;

define C-function g-param-spec-pool-new
  input parameter type_prefixing :: <gboolean>;
  result res :: <GParamSpecPool>;
  c-name: "g_param_spec_pool_new";
end;

define C-function g-param-spec-pool-insert
  input parameter pool :: <GParamSpecPool>;
  input parameter pspec :: <GParamSpec>;
  input parameter owner_type :: <GType>;
  c-name: "g_param_spec_pool_insert";
end;

define C-function g-param-spec-pool-remove
  input parameter pool :: <GParamSpecPool>;
  input parameter pspec :: <GParamSpec>;
  c-name: "g_param_spec_pool_remove";
end;

define C-function g-param-spec-pool-lookup
  input parameter pool :: <GParamSpecPool>;
  input parameter param_name :: <c-string>;
  input parameter owner_type :: <GType>;
  input parameter walk_ancestors :: <gboolean>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_pool_lookup";
end;

define C-function g-param-spec-pool-list-owned
  input parameter pool :: <GParamSpecPool>;
  input parameter owner_type :: <GType>;
  result res :: <GList>;
  c-name: "g_param_spec_pool_list_owned";
end;

define C-function g-param-spec-pool-list
  input parameter pool :: <GParamSpecPool>;
  input parameter owner_type :: <GType>;
  input parameter n_pspecs_p :: <guint*>;
  result res :: <GParamSpec*>;
  c-name: "g_param_spec_pool_list";
end;

define constant $G-PARAM-READWRITE = 0;

define constant $G-PARAM-MASK = 255;

define constant $G-PARAM-USER-SHIFT = 8;

define C-subtype <_GCClosure> (<C-void*>) end;
define constant <GCClosure> = <_GCClosure>;

define C-function g-cclosure-new
  input parameter callback_func :: <GCallback>;
  input parameter user_data :: <gpointer>;
  input parameter destroy_data :: <GClosureNotify>;
  result res :: <GClosure>;
  c-name: "g_cclosure_new";
end;

define C-function g-cclosure-new-swap
  input parameter callback_func :: <GCallback>;
  input parameter user_data :: <gpointer>;
  input parameter destroy_data :: <GClosureNotify>;
  result res :: <GClosure>;
  c-name: "g_cclosure_new_swap";
end;

define C-function g-signal-type-cclosure-new
  input parameter itype :: <GType>;
  input parameter struct_offset :: <guint>;
  result res :: <GClosure>;
  c-name: "g_signal_type_cclosure_new";
end;

define C-function g-closure-ref
  input parameter closure :: <GClosure>;
  result res :: <GClosure>;
  c-name: "g_closure_ref";
end;

define C-function g-closure-sink
  input parameter closure :: <GClosure>;
  c-name: "g_closure_sink";
end;

define C-function g-closure-unref
  input parameter closure :: <GClosure>;
  c-name: "g_closure_unref";
end;

define C-function g-closure-new-simple
  input parameter sizeof_closure :: <guint>;
  input parameter data :: <gpointer>;
  result res :: <GClosure>;
  c-name: "g_closure_new_simple";
end;

define C-function g-closure-add-finalize-notifier
  input parameter closure :: <GClosure>;
  input parameter notify_data :: <gpointer>;
  input parameter notify_func :: <GClosureNotify>;
  c-name: "g_closure_add_finalize_notifier";
end;

define C-function g-closure-remove-finalize-notifier
  input parameter closure :: <GClosure>;
  input parameter notify_data :: <gpointer>;
  input parameter notify_func :: <GClosureNotify>;
  c-name: "g_closure_remove_finalize_notifier";
end;

define C-function g-closure-add-invalidate-notifier
  input parameter closure :: <GClosure>;
  input parameter notify_data :: <gpointer>;
  input parameter notify_func :: <GClosureNotify>;
  c-name: "g_closure_add_invalidate_notifier";
end;

define C-function g-closure-remove-invalidate-notifier
  input parameter closure :: <GClosure>;
  input parameter notify_data :: <gpointer>;
  input parameter notify_func :: <GClosureNotify>;
  c-name: "g_closure_remove_invalidate_notifier";
end;

define C-function g-closure-add-marshal-guards
  input parameter closure :: <GClosure>;
  input parameter pre_marshal_data :: <gpointer>;
  input parameter pre_marshal_notify :: <GClosureNotify>;
  input parameter post_marshal_data :: <gpointer>;
  input parameter post_marshal_notify :: <GClosureNotify>;
  c-name: "g_closure_add_marshal_guards";
end;

define C-function g-closure-set-marshal
  input parameter closure :: <GClosure>;
  input parameter marshal :: <GClosureMarshal>;
  c-name: "g_closure_set_marshal";
end;

define C-function g-closure-set-meta-marshal
  input parameter closure :: <GClosure>;
  input parameter marshal_data :: <gpointer>;
  input parameter meta_marshal :: <GClosureMarshal>;
  c-name: "g_closure_set_meta_marshal";
end;

define C-function g-closure-invalidate
  input parameter closure :: <GClosure>;
  c-name: "g_closure_invalidate";
end;

define C-function g-closure-invoke
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  c-name: "g_closure_invoke";
end;

define C-function g-source-set-closure
  input parameter source :: <GSource>;
  input parameter closure :: <GClosure>;
  c-name: "g_source_set_closure";
end;

define C-function g-io-channel-get-type
  result res :: <GType>;
  c-name: "g_io_channel_get_type";
end;

define C-function g-io-condition-get-type
  result res :: <GType>;
  c-name: "g_io_condition_get_type";
end;

define C-subtype <_GParamSpecChar> (<C-void*>) end;
define constant <GParamSpecChar> = <_GParamSpecChar>;

define C-subtype <_GParamSpecUChar> (<C-void*>) end;
define constant <GParamSpecUChar> = <_GParamSpecUChar>;

define C-subtype <_GParamSpecBoolean> (<C-void*>) end;
define constant <GParamSpecBoolean> = <_GParamSpecBoolean>;

define C-subtype <_GParamSpecInt> (<C-void*>) end;
define constant <GParamSpecInt> = <_GParamSpecInt>;

define C-subtype <_GParamSpecUInt> (<C-void*>) end;
define constant <GParamSpecUInt> = <_GParamSpecUInt>;

define C-subtype <_GParamSpecLong> (<C-void*>) end;
define constant <GParamSpecLong> = <_GParamSpecLong>;

define C-subtype <_GParamSpecULong> (<C-void*>) end;
define constant <GParamSpecULong> = <_GParamSpecULong>;

define C-subtype <_GParamSpecInt64> (<C-void*>) end;
define constant <GParamSpecInt64> = <_GParamSpecInt64>;

define C-subtype <_GParamSpecUInt64> (<C-void*>) end;
define constant <GParamSpecUInt64> = <_GParamSpecUInt64>;

define C-subtype <_GParamSpecUnichar> (<C-void*>) end;
define constant <GParamSpecUnichar> = <_GParamSpecUnichar>;

define C-subtype <_GParamSpecEnum> (<C-void*>) end;
define constant <GParamSpecEnum> = <_GParamSpecEnum>;

define C-subtype <_GParamSpecFlags> (<C-void*>) end;
define constant <GParamSpecFlags> = <_GParamSpecFlags>;

define C-subtype <_GParamSpecFloat> (<C-void*>) end;
define constant <GParamSpecFloat> = <_GParamSpecFloat>;

define C-subtype <_GParamSpecDouble> (<C-void*>) end;
define constant <GParamSpecDouble> = <_GParamSpecDouble>;

define C-subtype <_GParamSpecString> (<C-void*>) end;
define constant <GParamSpecString> = <_GParamSpecString>;

define C-subtype <_GParamSpecParam> (<C-void*>) end;
define constant <GParamSpecParam> = <_GParamSpecParam>;

define C-subtype <_GParamSpecBoxed> (<C-void*>) end;
define constant <GParamSpecBoxed> = <_GParamSpecBoxed>;

define C-subtype <_GParamSpecPointer> (<C-void*>) end;
define constant <GParamSpecPointer> = <_GParamSpecPointer>;

define C-subtype <_GParamSpecValueArray> (<C-void*>) end;
define constant <GParamSpecValueArray> = <_GParamSpecValueArray>;

define C-subtype <_GParamSpecObject> (<C-void*>) end;
define constant <GParamSpecObject> = <_GParamSpecObject>;

define C-subtype <_GParamSpecOverride> (<C-void*>) end;
define constant <GParamSpecOverride> = <_GParamSpecOverride>;

define C-subtype <_GParamSpecGType> (<C-void*>) end;
define constant <GParamSpecGType> = <_GParamSpecGType>;

define C-function g-param-spec-char
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gint8>;
  input parameter maximum :: <gint8>;
  input parameter default_value :: <gint8>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_char";
end;

define C-function g-param-spec-uchar
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <guint8>;
  input parameter maximum :: <guint8>;
  input parameter default_value :: <guint8>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_uchar";
end;

define C-function g-param-spec-boolean
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter default_value :: <gboolean>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_boolean";
end;

define C-function g-param-spec-int
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gint>;
  input parameter maximum :: <gint>;
  input parameter default_value :: <gint>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_int";
end;

define C-function g-param-spec-uint
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <guint>;
  input parameter maximum :: <guint>;
  input parameter default_value :: <guint>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_uint";
end;

define C-function g-param-spec-long
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <glong>;
  input parameter maximum :: <glong>;
  input parameter default_value :: <glong>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_long";
end;

define C-function g-param-spec-ulong
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gulong>;
  input parameter maximum :: <gulong>;
  input parameter default_value :: <gulong>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_ulong";
end;

define C-function g-param-spec-int64
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gint64>;
  input parameter maximum :: <gint64>;
  input parameter default_value :: <gint64>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_int64";
end;

define C-function g-param-spec-uint64
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <guint64>;
  input parameter maximum :: <guint64>;
  input parameter default_value :: <guint64>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_uint64";
end;

define C-function g-param-spec-unichar
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter default_value :: <gunichar>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_unichar";
end;

define C-function g-param-spec-enum
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter enum_type :: <GType>;
  input parameter default_value :: <gint>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_enum";
end;

define C-function g-param-spec-flags
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter flags_type :: <GType>;
  input parameter default_value :: <guint>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_flags";
end;

define C-function g-param-spec-float
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gfloat>;
  input parameter maximum :: <gfloat>;
  input parameter default_value :: <gfloat>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_float";
end;

define C-function g-param-spec-double
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter minimum :: <gdouble>;
  input parameter maximum :: <gdouble>;
  input parameter default_value :: <gdouble>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_double";
end;

define C-function g-param-spec-string
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter default_value :: <c-string>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_string";
end;

define C-function g-param-spec-param
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter param_type :: <GType>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_param";
end;

define C-function g-param-spec-boxed
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter boxed_type :: <GType>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_boxed";
end;

define C-function g-param-spec-pointer
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_pointer";
end;

define C-function g-param-spec-value-array
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter element_spec :: <GParamSpec>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_value_array";
end;

define C-function g-param-spec-object
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter object_type :: <GType>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_object";
end;

define C-function g-param-spec-override
  input parameter name :: <c-string>;
  input parameter overridden :: <GParamSpec>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_override";
end;

define C-function g-param-spec-gtype
  input parameter name :: <c-string>;
  input parameter nick :: <c-string>;
  input parameter blurb :: <c-string>;
  input parameter is_a_type :: <GType>;
  input parameter flags :: <GParamFlags>;
  result res :: <GParamSpec>;
  c-name: "g_param_spec_gtype";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "g-param-spec-types"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1474>"*/
define constant <GBoxedCopyFunc> = <anonymous-1474>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1475>"*/
define constant <GBoxedFreeFunc> = <anonymous-1475>;

define C-function g-boxed-copy
  input parameter boxed_type :: <GType>;
  input parameter src_boxed :: <gconstpointer>;
  result res :: <gpointer>;
  c-name: "g_boxed_copy";
end;

define C-function g-boxed-free
  input parameter boxed_type :: <GType>;
  input parameter boxed :: <gpointer>;
  c-name: "g_boxed_free";
end;

define C-function g-value-set-boxed
  input parameter value :: <GValue>;
  input parameter v_boxed :: <gconstpointer>;
  c-name: "g_value_set_boxed";
end;

define C-function g-value-set-static-boxed
  input parameter value :: <GValue>;
  input parameter v_boxed :: <gconstpointer>;
  c-name: "g_value_set_static_boxed";
end;

define C-function g-value-get-boxed
  input parameter value :: <GValue>;
  result res :: <gpointer>;
  c-name: "g_value_get_boxed";
end;

define C-function g-value-dup-boxed
  input parameter value :: <GValue>;
  result res :: <gpointer>;
  c-name: "g_value_dup_boxed";
end;

define C-function g-boxed-type-register-static
  input parameter name :: <c-string>;
  input parameter boxed_copy :: <GBoxedCopyFunc>;
  input parameter boxed_free :: <GBoxedFreeFunc>;
  result res :: <GType>;
  c-name: "g_boxed_type_register_static";
end;

define C-function g-value-take-boxed
  input parameter value :: <GValue>;
  input parameter v_boxed :: <gconstpointer>;
  c-name: "g_value_take_boxed";
end;

define C-function g-value-set-boxed-take-ownership
  input parameter value :: <GValue>;
  input parameter v_boxed :: <gconstpointer>;
  c-name: "g_value_set_boxed_take_ownership";
end;

define C-function g-closure-get-type
  result res :: <GType>;
  c-name: "g_closure_get_type";
end;

define C-function g-value-get-type
  result res :: <GType>;
  c-name: "g_value_get_type";
end;

define C-function g-value-array-get-type
  result res :: <GType>;
  c-name: "g_value_array_get_type";
end;

define C-function g-date-get-type
  result res :: <GType>;
  c-name: "g_date_get_type";
end;

define C-function g-strv-get-type
  result res :: <GType>;
  c-name: "g_strv_get_type";
end;

define C-function g-gstring-get-type
  result res :: <GType>;
  c-name: "g_gstring_get_type";
end;

define C-function g-hash-table-get-type
  result res :: <GType>;
  c-name: "g_hash_table_get_type";
end;

define constant <GStrv> = <gchar**>;

define C-subtype <_GtkSettingsClass> (<C-void*>) end;
define constant <GtkSettingsClass> = <_GtkSettingsClass>;

define C-subtype <_GtkSettingsValue> (<C-void*>) end;
define constant <GtkSettingsValue> = <_GtkSettingsValue>;

define C-function gtk-settings-get-type
  result res :: <GType>;
  c-name: "gtk_settings_get_type";
end;

define C-function gtk-settings-get-default
  result res :: <GtkSettings>;
  c-name: "gtk_settings_get_default";
end;

define C-function gtk-settings-get-for-screen
  input parameter screen :: <GdkScreen>;
  result res :: <GtkSettings>;
  c-name: "gtk_settings_get_for_screen";
end;

define C-function gtk-settings-install-property
  input parameter pspec :: <GParamSpec>;
  c-name: "gtk_settings_install_property";
end;

define C-function gtk-settings-install-property-parser
  input parameter pspec :: <GParamSpec>;
  input parameter parser :: <GtkRcPropertyParser>;
  c-name: "gtk_settings_install_property_parser";
end;

define C-function gtk-rc-property-parse-color
  input parameter pspec :: <GParamSpec>;
  input parameter gstring :: <GString>;
  input parameter property_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gtk_rc_property_parse_color";
end;

define C-function gtk-rc-property-parse-enum
  input parameter pspec :: <GParamSpec>;
  input parameter gstring :: <GString>;
  input parameter property_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gtk_rc_property_parse_enum";
end;

define C-function gtk-rc-property-parse-flags
  input parameter pspec :: <GParamSpec>;
  input parameter gstring :: <GString>;
  input parameter property_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gtk_rc_property_parse_flags";
end;

define C-function gtk-rc-property-parse-requisition
  input parameter pspec :: <GParamSpec>;
  input parameter gstring :: <GString>;
  input parameter property_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gtk_rc_property_parse_requisition";
end;

define C-function gtk-rc-property-parse-border
  input parameter pspec :: <GParamSpec>;
  input parameter gstring :: <GString>;
  input parameter property_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gtk_rc_property_parse_border";
end;

define C-function gtk-settings-set-property-value
  input parameter settings :: <GtkSettings>;
  input parameter name :: <c-string>;
  input parameter svalue :: <GtkSettingsValue>;
  c-name: "gtk_settings_set_property_value";
end;

define C-function gtk-settings-set-string-property
  input parameter settings :: <GtkSettings>;
  input parameter name :: <c-string>;
  input parameter v_string :: <c-string>;
  input parameter origin :: <c-string>;
  c-name: "gtk_settings_set_string_property";
end;

define C-function gtk-settings-set-long-property
  input parameter settings :: <GtkSettings>;
  input parameter name :: <c-string>;
  input parameter v_long :: <glong>;
  input parameter origin :: <c-string>;
  c-name: "gtk_settings_set_long_property";
end;

define C-function gtk-settings-set-double-property
  input parameter settings :: <GtkSettings>;
  input parameter name :: <c-string>;
  input parameter v_double :: <gdouble>;
  input parameter origin :: <c-string>;
  c-name: "gtk_settings_set_double_property";
end;

define C-function _gtk-settings-set-property-value-from-rc
  input parameter settings :: <GtkSettings>;
  input parameter name :: <c-string>;
  input parameter svalue :: <GtkSettingsValue>;
  c-name: "_gtk_settings_set_property_value_from_rc";
end;

define C-function _gtk-settings-reset-rc-values
  input parameter settings :: <GtkSettings>;
  c-name: "_gtk_settings_reset_rc_values";
end;

define C-function _gtk-settings-handle-event
  input parameter event :: <GdkEventSetting>;
  c-name: "_gtk_settings_handle_event";
end;

define C-function _gtk-rc-property-parser-from-type
  input parameter type :: <GType>;
  result res :: <GtkRcPropertyParser>;
  c-name: "_gtk_rc_property_parser_from_type";
end;

define C-function _gtk-settings-parse-convert
  input parameter parser :: <GtkRcPropertyParser>;
  input parameter src_value :: <GValue>;
  input parameter pspec :: <GParamSpec>;
  input parameter dest_value :: <GValue>;
  result res :: <gboolean>;
  c-name: "_gtk_settings_parse_convert";
end;

define C-subtype <_GtkIconFactory> (<GObject>) end;
define constant <GtkIconFactory> = <_GtkIconFactory>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3503>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3504>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3505>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3506>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3507>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3508>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3509>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3510>"*/
define C-subtype <_GtkRcStyleClass> (<C-void*>) end;
define constant <GtkRcStyleClass> = <_GtkRcStyleClass>;

define C-function _gtk-rc-init
  c-name: "_gtk_rc_init";
end;

define C-function _gtk-rc-parse-widget-class-path
  input parameter pattern :: <c-string>;
  result res :: <GSList>;
  c-name: "_gtk_rc_parse_widget_class_path";
end;

define C-function _gtk-rc-free-widget-class-path
  input parameter list :: <GSList>;
  c-name: "_gtk_rc_free_widget_class_path";
end;

define C-function _gtk-rc-match-widget-class
  input parameter list :: <GSList>;
  input parameter length :: <gint>;
  input parameter path :: <c-string>;
  input parameter path_reversed :: <c-string>;
  result res :: <gboolean>;
  c-name: "_gtk_rc_match_widget_class";
end;

define C-function gtk-rc-add-default-file-utf8
  input parameter filename :: <c-string>;
  c-name: "gtk_rc_add_default_file_utf8";
end;

define C-function gtk-rc-set-default-files-utf8
  input parameter filenames :: <gchar**>;
  c-name: "gtk_rc_set_default_files_utf8";
end;

define C-function gtk-rc-get-default-files
  result res :: <gchar**>;
  c-name: "gtk_rc_get_default_files";
end;

define C-function gtk-rc-get-style
  input parameter widget :: <GtkWidget>;
  result res :: <GtkStyle>;
  c-name: "gtk_rc_get_style";
end;

define C-function gtk-rc-get-style-by-paths
  input parameter settings :: <GtkSettings>;
  input parameter widget_path :: <c-string>;
  input parameter class_path :: <c-string>;
  input parameter type :: <GType>;
  result res :: <GtkStyle>;
  c-name: "gtk_rc_get_style_by_paths";
end;

define C-function gtk-rc-reparse-all-for-settings
  input parameter settings :: <GtkSettings>;
  input parameter force_load :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_rc_reparse_all_for_settings";
end;

define C-function gtk-rc-reset-styles
  input parameter settings :: <GtkSettings>;
  c-name: "gtk_rc_reset_styles";
end;

define C-function gtk-rc-find-pixmap-in-path
  input parameter settings :: <GtkSettings>;
  input parameter scanner :: <GScanner>;
  input parameter pixmap_file :: <c-string>;
  result res :: <c-string>;
  c-name: "gtk_rc_find_pixmap_in_path";
end;

define C-function gtk-rc-parse-utf8
  input parameter filename :: <c-string>;
  c-name: "gtk_rc_parse_utf8";
end;

define C-function gtk-rc-parse-string
  input parameter rc_string :: <c-string>;
  c-name: "gtk_rc_parse_string";
end;

define C-function gtk-rc-reparse-all
  result res :: <gboolean>;
  c-name: "gtk_rc_reparse_all";
end;

define C-function gtk-rc-add-widget-name-style
  input parameter rc_style :: <GtkRcStyle>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_rc_add_widget_name_style";
end;

define C-function gtk-rc-add-widget-class-style
  input parameter rc_style :: <GtkRcStyle>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_rc_add_widget_class_style";
end;

define C-function gtk-rc-add-class-style
  input parameter rc_style :: <GtkRcStyle>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_rc_add_class_style";
end;

define C-function gtk-rc-style-get-type
  result res :: <GType>;
  c-name: "gtk_rc_style_get_type";
end;

define C-function gtk-rc-style-new
  result res :: <GtkRcStyle>;
  c-name: "gtk_rc_style_new";
end;

define C-function gtk-rc-style-copy
  input parameter orig :: <GtkRcStyle>;
  result res :: <GtkRcStyle>;
  c-name: "gtk_rc_style_copy";
end;

define C-function gtk-rc-style-ref
  input parameter rc_style :: <GtkRcStyle>;
  c-name: "gtk_rc_style_ref";
end;

define C-function gtk-rc-style-unref
  input parameter rc_style :: <GtkRcStyle>;
  c-name: "gtk_rc_style_unref";
end;

define C-function gtk-rc-find-module-in-path
  input parameter module_file :: <c-string>;
  result res :: <c-string>;
  c-name: "gtk_rc_find_module_in_path";
end;

define C-function gtk-rc-get-theme-dir
  result res :: <c-string>;
  c-name: "gtk_rc_get_theme_dir";
end;

define C-function gtk-rc-get-module-dir
  result res :: <c-string>;
  c-name: "gtk_rc_get_module_dir";
end;

define C-function gtk-rc-get-im-module-path
  result res :: <c-string>;
  c-name: "gtk_rc_get_im_module_path";
end;

define C-function gtk-rc-get-im-module-file
  result res :: <c-string>;
  c-name: "gtk_rc_get_im_module_file";
end;

define constant <GtkRcTokenType> = limited(<integer>, min: 270, max: 308);
define constant $GTK-RC-TOKEN-INVALID :: <GtkRcTokenType> = 270;
define constant $GTK-RC-TOKEN-INCLUDE :: <GtkRcTokenType> = 271;
define constant $GTK-RC-TOKEN-NORMAL :: <GtkRcTokenType> = 272;
define constant $GTK-RC-TOKEN-ACTIVE :: <GtkRcTokenType> = 273;
define constant $GTK-RC-TOKEN-PRELIGHT :: <GtkRcTokenType> = 274;
define constant $GTK-RC-TOKEN-SELECTED :: <GtkRcTokenType> = 275;
define constant $GTK-RC-TOKEN-INSENSITIVE :: <GtkRcTokenType> = 276;
define constant $GTK-RC-TOKEN-FG :: <GtkRcTokenType> = 277;
define constant $GTK-RC-TOKEN-BG :: <GtkRcTokenType> = 278;
define constant $GTK-RC-TOKEN-TEXT :: <GtkRcTokenType> = 279;
define constant $GTK-RC-TOKEN-BASE :: <GtkRcTokenType> = 280;
define constant $GTK-RC-TOKEN-XTHICKNESS :: <GtkRcTokenType> = 281;
define constant $GTK-RC-TOKEN-YTHICKNESS :: <GtkRcTokenType> = 282;
define constant $GTK-RC-TOKEN-FONT :: <GtkRcTokenType> = 283;
define constant $GTK-RC-TOKEN-FONTSET :: <GtkRcTokenType> = 284;
define constant $GTK-RC-TOKEN-FONT-NAME :: <GtkRcTokenType> = 285;
define constant $GTK-RC-TOKEN-BG-PIXMAP :: <GtkRcTokenType> = 286;
define constant $GTK-RC-TOKEN-PIXMAP-PATH :: <GtkRcTokenType> = 287;
define constant $GTK-RC-TOKEN-STYLE :: <GtkRcTokenType> = 288;
define constant $GTK-RC-TOKEN-BINDING :: <GtkRcTokenType> = 289;
define constant $GTK-RC-TOKEN-BIND :: <GtkRcTokenType> = 290;
define constant $GTK-RC-TOKEN-WIDGET :: <GtkRcTokenType> = 291;
define constant $GTK-RC-TOKEN-WIDGET-CLASS :: <GtkRcTokenType> = 292;
define constant $GTK-RC-TOKEN-CLASS :: <GtkRcTokenType> = 293;
define constant $GTK-RC-TOKEN-LOWEST :: <GtkRcTokenType> = 294;
define constant $GTK-RC-TOKEN-GTK :: <GtkRcTokenType> = 295;
define constant $GTK-RC-TOKEN-APPLICATION :: <GtkRcTokenType> = 296;
define constant $GTK-RC-TOKEN-THEME :: <GtkRcTokenType> = 297;
define constant $GTK-RC-TOKEN-RC :: <GtkRcTokenType> = 298;
define constant $GTK-RC-TOKEN-HIGHEST :: <GtkRcTokenType> = 299;
define constant $GTK-RC-TOKEN-ENGINE :: <GtkRcTokenType> = 300;
define constant $GTK-RC-TOKEN-MODULE-PATH :: <GtkRcTokenType> = 301;
define constant $GTK-RC-TOKEN-IM-MODULE-PATH :: <GtkRcTokenType> = 302;
define constant $GTK-RC-TOKEN-IM-MODULE-FILE :: <GtkRcTokenType> = 303;
define constant $GTK-RC-TOKEN-STOCK :: <GtkRcTokenType> = 304;
define constant $GTK-RC-TOKEN-LTR :: <GtkRcTokenType> = 305;
define constant $GTK-RC-TOKEN-RTL :: <GtkRcTokenType> = 306;
define constant $GTK-RC-TOKEN-COLOR :: <GtkRcTokenType> = 307;
define constant $GTK-RC-TOKEN-LAST :: <GtkRcTokenType> = 308;

define C-function gtk-rc-scanner-new
  result res :: <GScanner>;
  c-name: "gtk_rc_scanner_new";
end;

define C-function gtk-rc-parse-color
  input parameter scanner :: <GScanner>;
  input parameter color :: <GdkColor>;
  result res :: <guint>;
  c-name: "gtk_rc_parse_color";
end;

define C-pointer-type <GtkStateType*> => <GtkStateType>;
define C-function gtk-rc-parse-state
  input parameter scanner :: <GScanner>;
  input parameter state :: <GtkStateType*>;
  result res :: <guint>;
  c-name: "gtk_rc_parse_state";
end;

define constant <GtkPathPriorityType> = limited(<integer>, min: 0, max: 15);
define constant $GTK-PATH-PRIO-LOWEST :: <GtkPathPriorityType> = 0;
define constant $GTK-PATH-PRIO-GTK :: <GtkPathPriorityType> = 4;
define constant $GTK-PATH-PRIO-APPLICATION :: <GtkPathPriorityType> = 8;
define constant $GTK-PATH-PRIO-THEME :: <GtkPathPriorityType> = 10;
define constant $GTK-PATH-PRIO-RC :: <GtkPathPriorityType> = 12;
define constant $GTK-PATH-PRIO-HIGHEST :: <GtkPathPriorityType> = 15;

define C-pointer-type <GtkPathPriorityType*> => <GtkPathPriorityType>;
define C-function gtk-rc-parse-priority
  input parameter scanner :: <GScanner>;
  input parameter priority :: <GtkPathPriorityType*>;
  result res :: <guint>;
  c-name: "gtk_rc_parse_priority";
end;

define C-subtype <_GtkRcProperty> (<C-void*>) end;
define constant <GtkRcProperty> = <_GtkRcProperty>;

define C-function _gtk-rc-style-lookup-rc-property
  input parameter rc_style :: <GtkRcStyle>;
  input parameter type_name :: <GQuark>;
  input parameter property_name :: <GQuark>;
  result res :: <GtkRcProperty>;
  c-name: "_gtk_rc_style_lookup_rc_property";
end;

define C-function _gtk-rc-style-get-color-hashes
  input parameter rc_style :: <GtkRcStyle>;
  result res :: <GSList>;
  c-name: "_gtk_rc_style_get_color_hashes";
end;

define C-function _gtk-rc-context-get-default-font-name
  input parameter settings :: <GtkSettings>;
  result res :: <c-string>;
  c-name: "_gtk_rc_context_get_default_font_name";
end;

define C-function _gtk-rc-context-destroy
  input parameter settings :: <GtkSettings>;
  c-name: "_gtk_rc_context_destroy";
end;

define constant gtk-rc-add-default-file = gtk-rc-add-default-file-utf8;

define constant gtk-rc-set-default-files = gtk-rc-set-default-files-utf8;

define constant gtk-rc-parse = gtk-rc-parse-utf8;

define C-subtype <_GtkBorder> (<C-void*>) end;
define constant <GtkBorder> = <_GtkBorder>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3398>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3399>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3400>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3401>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3402>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3403>"*/
define C-subtype <_GtkIconSource> (<C-void*>) end;
define constant <GtkIconSource> = <_GtkIconSource>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3404>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3405>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3406>"*/
define constant <GtkShadowType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-SHADOW-NONE :: <GtkShadowType> = 0;
define constant $GTK-SHADOW-IN :: <GtkShadowType> = 1;
define constant $GTK-SHADOW-OUT :: <GtkShadowType> = 2;
define constant $GTK-SHADOW-ETCHED-IN :: <GtkShadowType> = 3;
define constant $GTK-SHADOW-ETCHED-OUT :: <GtkShadowType> = 4;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3407>"*/
define C-subtype <_GdkPoint> (<C-void*>) end;
define constant <GdkPoint> = <_GdkPoint>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3408>"*/
define constant <GtkArrowType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-ARROW-UP :: <GtkArrowType> = 0;
define constant $GTK-ARROW-DOWN :: <GtkArrowType> = 1;
define constant $GTK-ARROW-LEFT :: <GtkArrowType> = 2;
define constant $GTK-ARROW-RIGHT :: <GtkArrowType> = 3;
define constant $GTK-ARROW-NONE :: <GtkArrowType> = 4;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3409>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3410>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3411>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3412>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3413>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3414>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3415>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3416>"*/
define constant <GtkPositionType> = limited(<integer>, min: 0, max: 3);
define constant $GTK-POS-LEFT :: <GtkPositionType> = 0;
define constant $GTK-POS-RIGHT :: <GtkPositionType> = 1;
define constant $GTK-POS-TOP :: <GtkPositionType> = 2;
define constant $GTK-POS-BOTTOM :: <GtkPositionType> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3417>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3418>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3419>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3420>"*/
define constant <GtkOrientation> = limited(<integer>, min: 0, max: 1);
define constant $GTK-ORIENTATION-HORIZONTAL :: <GtkOrientation> = 0;
define constant $GTK-ORIENTATION-VERTICAL :: <GtkOrientation> = 1;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3421>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3422>"*/
define constant <GtkExpanderStyle> = limited(<integer>, min: 0, max: 3);
define constant $GTK-EXPANDER-COLLAPSED :: <GtkExpanderStyle> = 0;
define constant $GTK-EXPANDER-SEMI-COLLAPSED :: <GtkExpanderStyle> = 1;
define constant $GTK-EXPANDER-SEMI-EXPANDED :: <GtkExpanderStyle> = 2;
define constant $GTK-EXPANDER-EXPANDED :: <GtkExpanderStyle> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3423>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3424>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3425>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3426>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3427>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3428>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3429>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3430>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3431>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3432>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3433>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3434>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3435>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3436>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3437>"*/
define C-subtype <_GtkStyleClass> (<C-void*>) end;
define constant <GtkStyleClass> = <_GtkStyleClass>;

define C-subtype <_GtkThemeEngine> (<C-void*>) end;
define constant <GtkThemeEngine> = <_GtkThemeEngine>;

define C-subtype <_GtkIconSet> (<C-void*>) end;
define constant <GtkIconSet> = <_GtkIconSet>;

define C-function gtk-style-get-type
  result res :: <GType>;
  c-name: "gtk_style_get_type";
end;

define C-function gtk-style-new
  result res :: <GtkStyle>;
  c-name: "gtk_style_new";
end;

define C-function gtk-style-copy
  input parameter style :: <GtkStyle>;
  result res :: <GtkStyle>;
  c-name: "gtk_style_copy";
end;

define C-function gtk-style-attach
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  result res :: <GtkStyle>;
  c-name: "gtk_style_attach";
end;

define C-function gtk-style-detach
  input parameter style :: <GtkStyle>;
  c-name: "gtk_style_detach";
end;

define C-function gtk-style-ref
  input parameter style :: <GtkStyle>;
  result res :: <GtkStyle>;
  c-name: "gtk_style_ref";
end;

define C-function gtk-style-unref
  input parameter style :: <GtkStyle>;
  c-name: "gtk_style_unref";
end;

define C-function gtk-style-get-font
  input parameter style :: <GtkStyle>;
  result res :: <GdkFont>;
  c-name: "gtk_style_get_font";
end;

define C-function gtk-style-set-font
  input parameter style :: <GtkStyle>;
  input parameter font :: <GdkFont>;
  c-name: "gtk_style_set_font";
end;

define C-function gtk-style-set-background
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  c-name: "gtk_style_set_background";
end;

define C-function gtk-style-apply-default-background
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter set_bg :: <gboolean>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_style_apply_default_background";
end;

define C-function gtk-style-lookup-icon-set
  input parameter style :: <GtkStyle>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkIconSet>;
  c-name: "gtk_style_lookup_icon_set";
end;

define C-function gtk-style-lookup-color
  input parameter style :: <GtkStyle>;
  input parameter color_name :: <c-string>;
  input parameter color :: <GdkColor>;
  result res :: <gboolean>;
  c-name: "gtk_style_lookup_color";
end;

define C-function gtk-style-render-icon
  input parameter style :: <GtkStyle>;
  input parameter source :: <GtkIconSource>;
  input parameter direction :: <GtkTextDirection>;
  input parameter state :: <GtkStateType>;
  input parameter size :: <GtkIconSize>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_style_render_icon";
end;

define C-function gtk-draw-hline
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter x1 :: <gint>;
  input parameter x2 :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_draw_hline";
end;

define C-function gtk-draw-vline
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter y1_ :: <gint>;
  input parameter y2_ :: <gint>;
  input parameter x :: <gint>;
  c-name: "gtk_draw_vline";
end;

define C-function gtk-draw-shadow
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_shadow";
end;

define C-function gtk-draw-polygon
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  input parameter fill :: <gboolean>;
  c-name: "gtk_draw_polygon";
end;

define C-function gtk-draw-arrow
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter arrow_type :: <GtkArrowType>;
  input parameter fill :: <gboolean>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_arrow";
end;

define C-function gtk-draw-diamond
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_diamond";
end;

define C-function gtk-draw-box
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_box";
end;

define C-function gtk-draw-flat-box
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_flat_box";
end;

define C-function gtk-draw-check
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_check";
end;

define C-function gtk-draw-option
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_option";
end;

define C-function gtk-draw-tab
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_tab";
end;

define C-function gtk-draw-shadow-gap
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  input parameter gap_x :: <gint>;
  input parameter gap_width :: <gint>;
  c-name: "gtk_draw_shadow_gap";
end;

define C-function gtk-draw-box-gap
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  input parameter gap_x :: <gint>;
  input parameter gap_width :: <gint>;
  c-name: "gtk_draw_box_gap";
end;

define C-function gtk-draw-extension
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  c-name: "gtk_draw_extension";
end;

define C-function gtk-draw-focus
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_focus";
end;

define C-function gtk-draw-slider
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_draw_slider";
end;

define C-function gtk-draw-handle
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_draw_handle";
end;

define C-function gtk-draw-expander
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter expander_style :: <GtkExpanderStyle>;
  c-name: "gtk_draw_expander";
end;

define C-function gtk-draw-layout
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter use_text :: <gboolean>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter layout :: <PangoLayout>;
  c-name: "gtk_draw_layout";
end;

define C-function gtk-draw-resize-grip
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter edge :: <GdkWindowEdge>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_draw_resize_grip";
end;

define C-function gtk-paint-hline
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x1 :: <gint>;
  input parameter x2 :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_paint_hline";
end;

define C-function gtk-paint-vline
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter y1_ :: <gint>;
  input parameter y2_ :: <gint>;
  input parameter x :: <gint>;
  c-name: "gtk_paint_vline";
end;

define C-function gtk-paint-shadow
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_shadow";
end;

define C-function gtk-paint-polygon
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  input parameter fill :: <gboolean>;
  c-name: "gtk_paint_polygon";
end;

define C-function gtk-paint-arrow
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter arrow_type :: <GtkArrowType>;
  input parameter fill :: <gboolean>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_arrow";
end;

define C-function gtk-paint-diamond
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_diamond";
end;

define C-function gtk-paint-box
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_box";
end;

define C-function gtk-paint-flat-box
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_flat_box";
end;

define C-function gtk-paint-check
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_check";
end;

define C-function gtk-paint-option
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_option";
end;

define C-function gtk-paint-tab
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_tab";
end;

define C-function gtk-paint-shadow-gap
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  input parameter gap_x :: <gint>;
  input parameter gap_width :: <gint>;
  c-name: "gtk_paint_shadow_gap";
end;

define C-function gtk-paint-box-gap
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  input parameter gap_x :: <gint>;
  input parameter gap_width :: <gint>;
  c-name: "gtk_paint_box_gap";
end;

define C-function gtk-paint-extension
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter gap_side :: <GtkPositionType>;
  c-name: "gtk_paint_extension";
end;

define C-function gtk-paint-focus
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_focus";
end;

define C-function gtk-paint-slider
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_paint_slider";
end;

define C-function gtk-paint-handle
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_paint_handle";
end;

define C-function gtk-paint-expander
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter expander_style :: <GtkExpanderStyle>;
  c-name: "gtk_paint_expander";
end;

define C-function gtk-paint-layout
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter use_text :: <gboolean>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter layout :: <PangoLayout>;
  c-name: "gtk_paint_layout";
end;

define C-function gtk-paint-resize-grip
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter edge :: <GdkWindowEdge>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_paint_resize_grip";
end;

define C-function gtk-border-get-type
  result res :: <GType>;
  c-name: "gtk_border_get_type";
end;

define C-function gtk-border-copy
  input parameter border_ :: <GtkBorder>;
  result res :: <GtkBorder>;
  c-name: "gtk_border_copy";
end;

define C-function gtk-border-free
  input parameter border_ :: <GtkBorder>;
  c-name: "gtk_border_free";
end;

define C-function _gtk-style-peek-property-value
  input parameter style :: <GtkStyle>;
  input parameter widget_type :: <GType>;
  input parameter pspec :: <GParamSpec>;
  input parameter parser :: <GtkRcPropertyParser>;
  result res :: <GValue>;
  c-name: "_gtk_style_peek_property_value";
end;

define C-function _gtk-style-init-for-settings
  input parameter style :: <GtkStyle>;
  input parameter settings :: <GtkSettings>;
  c-name: "_gtk_style_init_for_settings";
end;

define C-function _gtk-style-shade
  input parameter a :: <GdkColor>;
  input parameter b :: <GdkColor>;
  input parameter k :: <gdouble>;
  c-name: "_gtk_style_shade";
end;

define C-function gtk-draw-string
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter string :: <c-string>;
  c-name: "gtk_draw_string";
end;

define C-function gtk-paint-string
  input parameter style :: <GtkStyle>;
  input parameter window :: <GdkWindow>;
  input parameter state_type :: <GtkStateType>;
  input parameter area :: <GdkRectangle>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter string :: <c-string>;
  c-name: "gtk_paint_string";
end;

define constant <GdkDrawable> = <_GdkDrawable>;

define C-function gtk-draw-insertion-cursor
  input parameter widget :: <GtkWidget>;
  input parameter drawable :: <GdkDrawable>;
  input parameter area :: <GdkRectangle>;
  input parameter location :: <GdkRectangle>;
  input parameter is_primary :: <gboolean>;
  input parameter direction :: <GtkTextDirection>;
  input parameter draw_arrow :: <gboolean>;
  c-name: "gtk_draw_insertion_cursor";
end;

define C-function pango-split-file-list
  input parameter str :: <c-string>;
  result res :: <c-string-vector>;
  c-name: "pango_split_file_list";
end;

define C-function pango-trim-string
  input parameter str :: <c-string>;
  result res :: <c-string>;
  c-name: "pango_trim_string";
end;

define C-subtype <_iobuf> (<C-void*>) end;
define constant <FILE> = <_iobuf>;

define C-function pango-read-line
  input parameter stream :: <FILE>;
  input parameter str :: <GString>;
  result res :: <gint>;
  c-name: "pango_read_line";
end;

define C-function pango-skip-space
  input parameter pos :: <c-string-vector>;
  result res :: <gboolean>;
  c-name: "pango_skip_space";
end;

define C-function pango-scan-word
  input parameter pos :: <c-string-vector>;
  input parameter out :: <GString>;
  result res :: <gboolean>;
  c-name: "pango_scan_word";
end;

define C-function pango-scan-string
  input parameter pos :: <c-string-vector>;
  input parameter out :: <GString>;
  result res :: <gboolean>;
  c-name: "pango_scan_string";
end;

define C-function pango-scan-int
  input parameter pos :: <c-string-vector>;
  input parameter out :: <int*>;
  result res :: <gboolean>;
  c-name: "pango_scan_int";
end;

define C-function pango-parse-enum
  input parameter type :: <GType>;
  input parameter str :: <c-string>;
  input parameter value :: <int*>;
  input parameter warn :: <gboolean>;
  input parameter possible_values :: <c-string-vector>;
  result res :: <gboolean>;
  c-name: "pango_parse_enum";
end;

define constant <PangoStyle> = limited(<integer>, min: 0, max: 2);
define constant $PANGO-STYLE-NORMAL :: <PangoStyle> = 0;
define constant $PANGO-STYLE-OBLIQUE :: <PangoStyle> = 1;
define constant $PANGO-STYLE-ITALIC :: <PangoStyle> = 2;

define C-pointer-type <PangoStyle*> => <PangoStyle>;
define C-function pango-parse-style
  input parameter str :: <c-string>;
  input parameter style :: <PangoStyle*>;
  input parameter warn :: <gboolean>;
  result res :: <gboolean>;
  c-name: "pango_parse_style";
end;

define constant <PangoVariant> = limited(<integer>, min: 0, max: 1);
define constant $PANGO-VARIANT-NORMAL :: <PangoVariant> = 0;
define constant $PANGO-VARIANT-SMALL-CAPS :: <PangoVariant> = 1;

define C-pointer-type <PangoVariant*> => <PangoVariant>;
define C-function pango-parse-variant
  input parameter str :: <c-string>;
  input parameter variant :: <PangoVariant*>;
  input parameter warn :: <gboolean>;
  result res :: <gboolean>;
  c-name: "pango_parse_variant";
end;

define constant <PangoWeight> = limited(<integer>, min: 200, max: 900);
define constant $PANGO-WEIGHT-ULTRALIGHT :: <PangoWeight> = 200;
define constant $PANGO-WEIGHT-LIGHT :: <PangoWeight> = 300;
define constant $PANGO-WEIGHT-NORMAL :: <PangoWeight> = 400;
define constant $PANGO-WEIGHT-SEMIBOLD :: <PangoWeight> = 600;
define constant $PANGO-WEIGHT-BOLD :: <PangoWeight> = 700;
define constant $PANGO-WEIGHT-ULTRABOLD :: <PangoWeight> = 800;
define constant $PANGO-WEIGHT-HEAVY :: <PangoWeight> = 900;

define C-pointer-type <PangoWeight*> => <PangoWeight>;
define C-function pango-parse-weight
  input parameter str :: <c-string>;
  input parameter weight :: <PangoWeight*>;
  input parameter warn :: <gboolean>;
  result res :: <gboolean>;
  c-name: "pango_parse_weight";
end;

define constant <PangoStretch> = limited(<integer>, min: 0, max: 8);
define constant $PANGO-STRETCH-ULTRA-CONDENSED :: <PangoStretch> = 0;
define constant $PANGO-STRETCH-EXTRA-CONDENSED :: <PangoStretch> = 1;
define constant $PANGO-STRETCH-CONDENSED :: <PangoStretch> = 2;
define constant $PANGO-STRETCH-SEMI-CONDENSED :: <PangoStretch> = 3;
define constant $PANGO-STRETCH-NORMAL :: <PangoStretch> = 4;
define constant $PANGO-STRETCH-SEMI-EXPANDED :: <PangoStretch> = 5;
define constant $PANGO-STRETCH-EXPANDED :: <PangoStretch> = 6;
define constant $PANGO-STRETCH-EXTRA-EXPANDED :: <PangoStretch> = 7;
define constant $PANGO-STRETCH-ULTRA-EXPANDED :: <PangoStretch> = 8;

define C-pointer-type <PangoStretch*> => <PangoStretch>;
define C-function pango-parse-stretch
  input parameter str :: <c-string>;
  input parameter stretch :: <PangoStretch*>;
  input parameter warn :: <gboolean>;
  result res :: <gboolean>;
  c-name: "pango_parse_stretch";
end;

define C-function pango-quantize-line-geometry
  input parameter thickness :: <int*>;
  input parameter position :: <int*>;
  c-name: "pango_quantize_line_geometry";
end;

define constant <PangoDirection> = limited(<integer>, min: 0, max: 6);
define constant $PANGO-DIRECTION-LTR :: <PangoDirection> = 0;
define constant $PANGO-DIRECTION-RTL :: <PangoDirection> = 1;
define constant $PANGO-DIRECTION-TTB-LTR :: <PangoDirection> = 2;
define constant $PANGO-DIRECTION-TTB-RTL :: <PangoDirection> = 3;
define constant $PANGO-DIRECTION-WEAK-LTR :: <PangoDirection> = 4;
define constant $PANGO-DIRECTION-WEAK-RTL :: <PangoDirection> = 5;
define constant $PANGO-DIRECTION-NEUTRAL :: <PangoDirection> = 6;

define C-pointer-type <PangoDirection*> => <PangoDirection>;
define C-function pango-log2vis-get-embedding-levels
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter pbase_dir :: <PangoDirection*>;
  result res :: <guint8*>;
  c-name: "pango_log2vis_get_embedding_levels";
end;

define C-function pango-is-zero-width
  input parameter ch :: <gunichar>;
  result res :: <gboolean>;
  c-name: "pango_is_zero_width";
end;

define C-function pango-version
  result res :: <integer>;
  c-name: "pango_version";
end;

define C-function pango-version-string
  result res :: <c-string>;
  c-name: "pango_version_string";
end;

define C-function pango-version-check
  input parameter required_major :: <integer>;
  input parameter required_minor :: <integer>;
  input parameter required_micro :: <integer>;
  result res :: <c-string>;
  c-name: "pango_version_check";
end;

define constant $PANGO-VERSION = 11601;

define C-subtype <_PangoFontMetrics> (<C-void*>) end;
define constant <PangoFontMetrics> = <_PangoFontMetrics>;

define constant <PangoFontMask> = limited(<integer>, min: 1, max: 64);
define constant $PANGO-FONT-MASK-FAMILY :: <PangoFontMask> = 1;
define constant $PANGO-FONT-MASK-STYLE :: <PangoFontMask> = 2;
define constant $PANGO-FONT-MASK-VARIANT :: <PangoFontMask> = 4;
define constant $PANGO-FONT-MASK-WEIGHT :: <PangoFontMask> = 8;
define constant $PANGO-FONT-MASK-STRETCH :: <PangoFontMask> = 16;
define constant $PANGO-FONT-MASK-SIZE :: <PangoFontMask> = 32;
define constant $PANGO-FONT-MASK-GRAVITY :: <PangoFontMask> = 64;

define C-function pango-font-description-get-type
  result res :: <GType>;
  c-name: "pango_font_description_get_type";
end;

define C-function pango-font-description-new
  result res :: <PangoFontDescription>;
  c-name: "pango_font_description_new";
end;

define C-function pango-font-description-copy
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_description_copy";
end;

define C-function pango-font-description-copy-static
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_description_copy_static";
end;

define C-function pango-font-description-hash
  input parameter desc :: <PangoFontDescription>;
  result res :: <guint>;
  c-name: "pango_font_description_hash";
end;

define C-function pango-font-description-equal
  input parameter desc1 :: <PangoFontDescription>;
  input parameter desc2 :: <PangoFontDescription>;
  result res :: <gboolean>;
  c-name: "pango_font_description_equal";
end;

define C-function pango-font-description-free
  input parameter desc :: <PangoFontDescription>;
  c-name: "pango_font_description_free";
end;

define C-pointer-type <PangoFontDescription*> => <PangoFontDescription>;
define C-function pango-font-descriptions-free
  input parameter descs :: <PangoFontDescription*>;
  input parameter n_descs :: <integer>;
  c-name: "pango_font_descriptions_free";
end;

define C-function pango-font-description-set-family
  input parameter desc :: <PangoFontDescription>;
  input parameter family :: <c-string>;
  c-name: "pango_font_description_set_family";
end;

define C-function pango-font-description-set-family-static
  input parameter desc :: <PangoFontDescription>;
  input parameter family :: <c-string>;
  c-name: "pango_font_description_set_family_static";
end;

define C-function pango-font-description-get-family
  input parameter desc :: <PangoFontDescription>;
  result res :: <c-string>;
  c-name: "pango_font_description_get_family";
end;

define C-function pango-font-description-set-style
  input parameter desc :: <PangoFontDescription>;
  input parameter style :: <PangoStyle>;
  c-name: "pango_font_description_set_style";
end;

define C-function pango-font-description-get-style
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoStyle>;
  c-name: "pango_font_description_get_style";
end;

define C-function pango-font-description-set-variant
  input parameter desc :: <PangoFontDescription>;
  input parameter variant :: <PangoVariant>;
  c-name: "pango_font_description_set_variant";
end;

define C-function pango-font-description-get-variant
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoVariant>;
  c-name: "pango_font_description_get_variant";
end;

define C-function pango-font-description-set-weight
  input parameter desc :: <PangoFontDescription>;
  input parameter weight :: <PangoWeight>;
  c-name: "pango_font_description_set_weight";
end;

define C-function pango-font-description-get-weight
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoWeight>;
  c-name: "pango_font_description_get_weight";
end;

define C-function pango-font-description-set-stretch
  input parameter desc :: <PangoFontDescription>;
  input parameter stretch :: <PangoStretch>;
  c-name: "pango_font_description_set_stretch";
end;

define C-function pango-font-description-get-stretch
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoStretch>;
  c-name: "pango_font_description_get_stretch";
end;

define C-function pango-font-description-set-size
  input parameter desc :: <PangoFontDescription>;
  input parameter size :: <gint>;
  c-name: "pango_font_description_set_size";
end;

define C-function pango-font-description-get-size
  input parameter desc :: <PangoFontDescription>;
  result res :: <gint>;
  c-name: "pango_font_description_get_size";
end;

define C-function pango-font-description-set-absolute-size
  input parameter desc :: <PangoFontDescription>;
  input parameter size :: <double-float>;
  c-name: "pango_font_description_set_absolute_size";
end;

define C-function pango-font-description-get-size-is-absolute
  input parameter desc :: <PangoFontDescription>;
  result res :: <gboolean>;
  c-name: "pango_font_description_get_size_is_absolute";
end;

define constant <PangoGravity> = limited(<integer>, min: 0, max: 4);
define constant $PANGO-GRAVITY-SOUTH :: <PangoGravity> = 0;
define constant $PANGO-GRAVITY-EAST :: <PangoGravity> = 1;
define constant $PANGO-GRAVITY-NORTH :: <PangoGravity> = 2;
define constant $PANGO-GRAVITY-WEST :: <PangoGravity> = 3;
define constant $PANGO-GRAVITY-AUTO :: <PangoGravity> = 4;

define C-function pango-font-description-set-gravity
  input parameter desc :: <PangoFontDescription>;
  input parameter gravity :: <PangoGravity>;
  c-name: "pango_font_description_set_gravity";
end;

define C-function pango-font-description-get-gravity
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoGravity>;
  c-name: "pango_font_description_get_gravity";
end;

define C-function pango-font-description-get-set-fields
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoFontMask>;
  c-name: "pango_font_description_get_set_fields";
end;

define C-function pango-font-description-unset-fields
  input parameter desc :: <PangoFontDescription>;
  input parameter to_unset :: <PangoFontMask>;
  c-name: "pango_font_description_unset_fields";
end;

define C-function pango-font-description-merge
  input parameter desc :: <PangoFontDescription>;
  input parameter desc_to_merge :: <PangoFontDescription>;
  input parameter replace_existing :: <gboolean>;
  c-name: "pango_font_description_merge";
end;

define C-function pango-font-description-merge-static
  input parameter desc :: <PangoFontDescription>;
  input parameter desc_to_merge :: <PangoFontDescription>;
  input parameter replace_existing :: <gboolean>;
  c-name: "pango_font_description_merge_static";
end;

define C-function pango-font-description-better-match
  input parameter desc :: <PangoFontDescription>;
  input parameter old_match :: <PangoFontDescription>;
  input parameter new_match :: <PangoFontDescription>;
  result res :: <gboolean>;
  c-name: "pango_font_description_better_match";
end;

define C-function pango-font-description-from-string
  input parameter str :: <c-string>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_description_from_string";
end;

define C-function pango-font-description-to-string
  input parameter desc :: <PangoFontDescription>;
  result res :: <c-string>;
  c-name: "pango_font_description_to_string";
end;

define C-function pango-font-description-to-filename
  input parameter desc :: <PangoFontDescription>;
  result res :: <c-string>;
  c-name: "pango_font_description_to_filename";
end;

define C-function pango-font-metrics-get-type
  result res :: <GType>;
  c-name: "pango_font_metrics_get_type";
end;

define C-function pango-font-metrics-ref
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <PangoFontMetrics>;
  c-name: "pango_font_metrics_ref";
end;

define C-function pango-font-metrics-unref
  input parameter metrics :: <PangoFontMetrics>;
  c-name: "pango_font_metrics_unref";
end;

define C-function pango-font-metrics-get-ascent
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_ascent";
end;

define C-function pango-font-metrics-get-descent
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_descent";
end;

define C-function pango-font-metrics-get-approximate-char-width
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_approximate_char_width";
end;

define C-function pango-font-metrics-get-approximate-digit-width
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_approximate_digit_width";
end;

define C-function pango-font-metrics-get-underline-position
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_underline_position";
end;

define C-function pango-font-metrics-get-underline-thickness
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_underline_thickness";
end;

define C-function pango-font-metrics-get-strikethrough-position
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_strikethrough_position";
end;

define C-function pango-font-metrics-get-strikethrough-thickness
  input parameter metrics :: <PangoFontMetrics>;
  result res :: <integer>;
  c-name: "pango_font_metrics_get_strikethrough_thickness";
end;

define C-subtype <_PangoFontFamily> (<C-void*>) end;
define constant <PangoFontFamily> = <_PangoFontFamily>;

define C-subtype <_PangoFontFace> (<C-void*>) end;
define constant <PangoFontFace> = <_PangoFontFace>;

define C-function pango-font-family-get-type
  result res :: <GType>;
  c-name: "pango_font_family_get_type";
end;

define C-pointer-type <PangoFontFace*> => <PangoFontFace>;
define C-pointer-type <PangoFontFace**> => <PangoFontFace*>;
define C-function pango-font-family-list-faces
  input parameter family :: <PangoFontFamily>;
  input parameter faces :: <PangoFontFace**>;
  input parameter n_faces :: <int*>;
  c-name: "pango_font_family_list_faces";
end;

define C-function pango-font-family-get-name
  input parameter family :: <PangoFontFamily>;
  result res :: <c-string>;
  c-name: "pango_font_family_get_name";
end;

define C-function pango-font-family-is-monospace
  input parameter family :: <PangoFontFamily>;
  result res :: <gboolean>;
  c-name: "pango_font_family_is_monospace";
end;

define C-function pango-font-face-get-type
  result res :: <GType>;
  c-name: "pango_font_face_get_type";
end;

define C-function pango-font-face-describe
  input parameter face :: <PangoFontFace>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_face_describe";
end;

define C-function pango-font-face-get-face-name
  input parameter face :: <PangoFontFace>;
  result res :: <c-string>;
  c-name: "pango_font_face_get_face_name";
end;

define C-pointer-type <int**> => <int*>;
define C-function pango-font-face-list-sizes
  input parameter face :: <PangoFontFace>;
  input parameter sizes :: <int**>;
  input parameter n_sizes :: <int*>;
  c-name: "pango_font_face_list_sizes";
end;

define C-function pango-font-get-type
  result res :: <GType>;
  c-name: "pango_font_get_type";
end;

define C-subtype <_PangoFont> (<C-void*>) end;
define constant <PangoFont> = <_PangoFont>;

define C-function pango-font-describe
  input parameter font :: <PangoFont>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_describe";
end;

define C-function pango-font-describe-with-absolute-size
  input parameter font :: <PangoFont>;
  result res :: <PangoFontDescription>;
  c-name: "pango_font_describe_with_absolute_size";
end;

define C-subtype <_PangoCoverage> (<C-void*>) end;
define constant <PangoCoverage> = <_PangoCoverage>;

define C-subtype <_PangoLanguage> (<C-void*>) end;
define constant <PangoLanguage> = <_PangoLanguage>;

define C-function pango-font-get-coverage
  input parameter font :: <PangoFont>;
  input parameter language :: <PangoLanguage>;
  result res :: <PangoCoverage>;
  c-name: "pango_font_get_coverage";
end;

define C-subtype <_PangoEngineShape> (<C-void*>) end;
define constant <PangoEngineShape> = <_PangoEngineShape>;

define C-function pango-font-find-shaper
  input parameter font :: <PangoFont>;
  input parameter language :: <PangoLanguage>;
  input parameter ch :: <guint32>;
  result res :: <PangoEngineShape>;
  c-name: "pango_font_find_shaper";
end;

define C-function pango-font-get-metrics
  input parameter font :: <PangoFont>;
  input parameter language :: <PangoLanguage>;
  result res :: <PangoFontMetrics>;
  c-name: "pango_font_get_metrics";
end;

define constant <PangoGlyph> = <guint32>;

define C-subtype <_PangoRectangle> (<C-void*>) end;
define constant <PangoRectangle> = <_PangoRectangle>;

define C-function pango-font-get-glyph-extents
  input parameter font :: <PangoFont>;
  input parameter glyph :: <PangoGlyph>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_font_get_glyph_extents";
end;

define C-subtype <_PangoFontMap> (<C-void*>) end;
define constant <PangoFontMap> = <_PangoFontMap>;

define C-function pango-font-get-font-map
  input parameter font :: <PangoFont>;
  result res :: <PangoFontMap>;
  c-name: "pango_font_get_font_map";
end;

define C-subtype <_PangoLogAttr> (<C-void*>) end;
define constant <PangoLogAttr> = <_PangoLogAttr>;

define C-subtype <_PangoEngineLang> (<C-void*>) end;
define constant <PangoEngineLang> = <_PangoEngineLang>;

define C-function pango-units-from-double
  input parameter d :: <double-float>;
  result res :: <integer>;
  c-name: "pango_units_from_double";
end;

define C-function pango-units-to-double
  input parameter i :: <integer>;
  result res :: <double-float>;
  c-name: "pango_units_to_double";
end;

define C-function pango-language-get-type
  result res :: <GType>;
  c-name: "pango_language_get_type";
end;

define C-function pango-language-from-string
  input parameter language :: <c-string>;
  result res :: <PangoLanguage>;
  c-name: "pango_language_from_string";
end;

define C-function pango-language-get-sample-string
  input parameter language :: <PangoLanguage>;
  result res :: <c-string>;
  c-name: "pango_language_get_sample_string";
end;

define C-function pango-language-get-default
  result res :: <PangoLanguage>;
  c-name: "pango_language_get_default";
end;

define C-function pango-language-matches
  input parameter language :: <PangoLanguage>;
  input parameter range_list :: <c-string>;
  result res :: <gboolean>;
  c-name: "pango_language_matches";
end;

define C-function pango-extents-to-pixels
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_extents_to_pixels";
end;

define C-function pango-unichar-direction
  input parameter ch :: <gunichar>;
  result res :: <PangoDirection>;
  c-name: "pango_unichar_direction";
end;

define C-function pango-find-base-dir
  input parameter text :: <c-string>;
  input parameter length :: <gint>;
  result res :: <PangoDirection>;
  c-name: "pango_find_base_dir";
end;

define C-function pango-get-mirror-char
  input parameter ch :: <gunichar>;
  input parameter mirrored_ch :: <gunichar*>;
  result res :: <gboolean>;
  c-name: "pango_get_mirror_char";
end;

define constant $PANGO-SCALE = 1024;

define constant <PangoGravityHint> = limited(<integer>, min: 0, max: 2);
define constant $PANGO-GRAVITY-HINT-NATURAL :: <PangoGravityHint> = 0;
define constant $PANGO-GRAVITY-HINT-STRONG :: <PangoGravityHint> = 1;
define constant $PANGO-GRAVITY-HINT-LINE :: <PangoGravityHint> = 2;

define C-function pango-gravity-to-rotation
  input parameter gravity :: <PangoGravity>;
  result res :: <double-float>;
  c-name: "pango_gravity_to_rotation";
end;

define C-subtype <_PangoMatrix> (<C-void*>) end;
define constant <PangoMatrix> = <_PangoMatrix>;

define C-function pango-gravity-get-for-matrix
  input parameter matrix :: <PangoMatrix>;
  result res :: <PangoGravity>;
  c-name: "pango_gravity_get_for_matrix";
end;

define constant <PangoScript> = limited(<integer>, min: -1, max: 66);
define constant $PANGO-SCRIPT-INVALID-CODE :: <PangoScript> = -1;
define constant $PANGO-SCRIPT-COMMON :: <PangoScript> = 0;
define constant $PANGO-SCRIPT-INHERITED :: <PangoScript> = 1;
define constant $PANGO-SCRIPT-ARABIC :: <PangoScript> = 2;
define constant $PANGO-SCRIPT-ARMENIAN :: <PangoScript> = 3;
define constant $PANGO-SCRIPT-BENGALI :: <PangoScript> = 4;
define constant $PANGO-SCRIPT-BOPOMOFO :: <PangoScript> = 5;
define constant $PANGO-SCRIPT-CHEROKEE :: <PangoScript> = 6;
define constant $PANGO-SCRIPT-COPTIC :: <PangoScript> = 7;
define constant $PANGO-SCRIPT-CYRILLIC :: <PangoScript> = 8;
define constant $PANGO-SCRIPT-DESERET :: <PangoScript> = 9;
define constant $PANGO-SCRIPT-DEVANAGARI :: <PangoScript> = 10;
define constant $PANGO-SCRIPT-ETHIOPIC :: <PangoScript> = 11;
define constant $PANGO-SCRIPT-GEORGIAN :: <PangoScript> = 12;
define constant $PANGO-SCRIPT-GOTHIC :: <PangoScript> = 13;
define constant $PANGO-SCRIPT-GREEK :: <PangoScript> = 14;
define constant $PANGO-SCRIPT-GUJARATI :: <PangoScript> = 15;
define constant $PANGO-SCRIPT-GURMUKHI :: <PangoScript> = 16;
define constant $PANGO-SCRIPT-HAN :: <PangoScript> = 17;
define constant $PANGO-SCRIPT-HANGUL :: <PangoScript> = 18;
define constant $PANGO-SCRIPT-HEBREW :: <PangoScript> = 19;
define constant $PANGO-SCRIPT-HIRAGANA :: <PangoScript> = 20;
define constant $PANGO-SCRIPT-KANNADA :: <PangoScript> = 21;
define constant $PANGO-SCRIPT-KATAKANA :: <PangoScript> = 22;
define constant $PANGO-SCRIPT-KHMER :: <PangoScript> = 23;
define constant $PANGO-SCRIPT-LAO :: <PangoScript> = 24;
define constant $PANGO-SCRIPT-LATIN :: <PangoScript> = 25;
define constant $PANGO-SCRIPT-MALAYALAM :: <PangoScript> = 26;
define constant $PANGO-SCRIPT-MONGOLIAN :: <PangoScript> = 27;
define constant $PANGO-SCRIPT-MYANMAR :: <PangoScript> = 28;
define constant $PANGO-SCRIPT-OGHAM :: <PangoScript> = 29;
define constant $PANGO-SCRIPT-OLD-ITALIC :: <PangoScript> = 30;
define constant $PANGO-SCRIPT-ORIYA :: <PangoScript> = 31;
define constant $PANGO-SCRIPT-RUNIC :: <PangoScript> = 32;
define constant $PANGO-SCRIPT-SINHALA :: <PangoScript> = 33;
define constant $PANGO-SCRIPT-SYRIAC :: <PangoScript> = 34;
define constant $PANGO-SCRIPT-TAMIL :: <PangoScript> = 35;
define constant $PANGO-SCRIPT-TELUGU :: <PangoScript> = 36;
define constant $PANGO-SCRIPT-THAANA :: <PangoScript> = 37;
define constant $PANGO-SCRIPT-THAI :: <PangoScript> = 38;
define constant $PANGO-SCRIPT-TIBETAN :: <PangoScript> = 39;
define constant $PANGO-SCRIPT-CANADIAN-ABORIGINAL :: <PangoScript> = 40;
define constant $PANGO-SCRIPT-YI :: <PangoScript> = 41;
define constant $PANGO-SCRIPT-TAGALOG :: <PangoScript> = 42;
define constant $PANGO-SCRIPT-HANUNOO :: <PangoScript> = 43;
define constant $PANGO-SCRIPT-BUHID :: <PangoScript> = 44;
define constant $PANGO-SCRIPT-TAGBANWA :: <PangoScript> = 45;
define constant $PANGO-SCRIPT-BRAILLE :: <PangoScript> = 46;
define constant $PANGO-SCRIPT-CYPRIOT :: <PangoScript> = 47;
define constant $PANGO-SCRIPT-LIMBU :: <PangoScript> = 48;
define constant $PANGO-SCRIPT-OSMANYA :: <PangoScript> = 49;
define constant $PANGO-SCRIPT-SHAVIAN :: <PangoScript> = 50;
define constant $PANGO-SCRIPT-LINEAR-B :: <PangoScript> = 51;
define constant $PANGO-SCRIPT-TAI-LE :: <PangoScript> = 52;
define constant $PANGO-SCRIPT-UGARITIC :: <PangoScript> = 53;
define constant $PANGO-SCRIPT-NEW-TAI-LUE :: <PangoScript> = 54;
define constant $PANGO-SCRIPT-BUGINESE :: <PangoScript> = 55;
define constant $PANGO-SCRIPT-GLAGOLITIC :: <PangoScript> = 56;
define constant $PANGO-SCRIPT-TIFINAGH :: <PangoScript> = 57;
define constant $PANGO-SCRIPT-SYLOTI-NAGRI :: <PangoScript> = 58;
define constant $PANGO-SCRIPT-OLD-PERSIAN :: <PangoScript> = 59;
define constant $PANGO-SCRIPT-KHAROSHTHI :: <PangoScript> = 60;
define constant $PANGO-SCRIPT-UNKNOWN :: <PangoScript> = 61;
define constant $PANGO-SCRIPT-BALINESE :: <PangoScript> = 62;
define constant $PANGO-SCRIPT-CUNEIFORM :: <PangoScript> = 63;
define constant $PANGO-SCRIPT-PHOENICIAN :: <PangoScript> = 64;
define constant $PANGO-SCRIPT-PHAGS-PA :: <PangoScript> = 65;
define constant $PANGO-SCRIPT-NKO :: <PangoScript> = 66;

define C-function pango-gravity-get-for-script
  input parameter script :: <PangoScript>;
  input parameter base_gravity :: <PangoGravity>;
  input parameter hint :: <PangoGravityHint>;
  result res :: <PangoGravity>;
  c-name: "pango_gravity_get_for_script";
end;

define C-subtype <_PangoScriptIter> (<C-void*>) end;
define constant <PangoScriptIter> = <_PangoScriptIter>;

define C-function pango-script-for-unichar
  input parameter ch :: <gunichar>;
  result res :: <PangoScript>;
  c-name: "pango_script_for_unichar";
end;

define C-function pango-script-iter-new
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  result res :: <PangoScriptIter>;
  c-name: "pango_script_iter_new";
end;

define C-pointer-type <PangoScript*> => <PangoScript>;
define C-function pango-script-iter-get-range
  input parameter iter :: <PangoScriptIter>;
  input parameter start :: <c-string-vector>;
  input parameter end :: <c-string-vector>;
  input parameter script :: <PangoScript*>;
  c-name: "pango_script_iter_get_range";
end;

define C-function pango-script-iter-next
  input parameter iter :: <PangoScriptIter>;
  result res :: <gboolean>;
  c-name: "pango_script_iter_next";
end;

define C-function pango-script-iter-free
  input parameter iter :: <PangoScriptIter>;
  c-name: "pango_script_iter_free";
end;

define C-function pango-script-get-sample-language
  input parameter script :: <PangoScript>;
  result res :: <PangoLanguage>;
  c-name: "pango_script_get_sample_language";
end;

define C-function pango-language-includes-script
  input parameter language :: <PangoLanguage>;
  input parameter script :: <PangoScript>;
  result res :: <gboolean>;
  c-name: "pango_language_includes_script";
end;

define C-function pango-matrix-get-type
  result res :: <GType>;
  c-name: "pango_matrix_get_type";
end;

define C-function pango-matrix-copy
  input parameter matrix :: <PangoMatrix>;
  result res :: <PangoMatrix>;
  c-name: "pango_matrix_copy";
end;

define C-function pango-matrix-free
  input parameter matrix :: <PangoMatrix>;
  c-name: "pango_matrix_free";
end;

define C-function pango-matrix-translate
  input parameter matrix :: <PangoMatrix>;
  input parameter tx :: <double-float>;
  input parameter ty :: <double-float>;
  c-name: "pango_matrix_translate";
end;

define C-function pango-matrix-scale
  input parameter matrix :: <PangoMatrix>;
  input parameter scale_x :: <double-float>;
  input parameter scale_y :: <double-float>;
  c-name: "pango_matrix_scale";
end;

define C-function pango-matrix-rotate
  input parameter matrix :: <PangoMatrix>;
  input parameter degrees :: <double-float>;
  c-name: "pango_matrix_rotate";
end;

define C-function pango-matrix-concat
  input parameter matrix :: <PangoMatrix>;
  input parameter new_matrix :: <PangoMatrix>;
  c-name: "pango_matrix_concat";
end;

define C-pointer-type <double*> => <double-float>;
define C-function pango-matrix-transform-point
  input parameter matrix :: <PangoMatrix>;
  input parameter x :: <double*>;
  input parameter y :: <double*>;
  c-name: "pango_matrix_transform_point";
end;

define C-function pango-matrix-transform-distance
  input parameter matrix :: <PangoMatrix>;
  input parameter dx :: <double*>;
  input parameter dy :: <double*>;
  c-name: "pango_matrix_transform_distance";
end;

define C-function pango-matrix-transform-rectangle
  input parameter matrix :: <PangoMatrix>;
  input parameter rect :: <PangoRectangle>;
  c-name: "pango_matrix_transform_rectangle";
end;

define C-function pango-matrix-transform-pixel-rectangle
  input parameter matrix :: <PangoMatrix>;
  input parameter rect :: <PangoRectangle>;
  c-name: "pango_matrix_transform_pixel_rectangle";
end;

define C-function pango-matrix-get-font-scale-factor
  input parameter matrix :: <PangoMatrix>;
  result res :: <double-float>;
  c-name: "pango_matrix_get_font_scale_factor";
end;

define constant <PangoCoverageLevel> = limited(<integer>, min: 0, max: 3);
define constant $PANGO-COVERAGE-NONE :: <PangoCoverageLevel> = 0;
define constant $PANGO-COVERAGE-FALLBACK :: <PangoCoverageLevel> = 1;
define constant $PANGO-COVERAGE-APPROXIMATE :: <PangoCoverageLevel> = 2;
define constant $PANGO-COVERAGE-EXACT :: <PangoCoverageLevel> = 3;

define C-function pango-coverage-new
  result res :: <PangoCoverage>;
  c-name: "pango_coverage_new";
end;

define C-function pango-coverage-ref
  input parameter coverage :: <PangoCoverage>;
  result res :: <PangoCoverage>;
  c-name: "pango_coverage_ref";
end;

define C-function pango-coverage-unref
  input parameter coverage :: <PangoCoverage>;
  c-name: "pango_coverage_unref";
end;

define C-function pango-coverage-copy
  input parameter coverage :: <PangoCoverage>;
  result res :: <PangoCoverage>;
  c-name: "pango_coverage_copy";
end;

define C-function pango-coverage-get
  input parameter coverage :: <PangoCoverage>;
  input parameter index_ :: <integer>;
  result res :: <PangoCoverageLevel>;
  c-name: "pango_coverage_get";
end;

define C-function pango-coverage-set
  input parameter coverage :: <PangoCoverage>;
  input parameter index_ :: <integer>;
  input parameter level :: <PangoCoverageLevel>;
  c-name: "pango_coverage_set";
end;

define C-function pango-coverage-max
  input parameter coverage :: <PangoCoverage>;
  input parameter other :: <PangoCoverage>;
  c-name: "pango_coverage_max";
end;

define C-pointer-type <guchar**> => <guchar*>;
define C-function pango-coverage-to-bytes
  input parameter coverage :: <PangoCoverage>;
  input parameter bytes :: <guchar**>;
  input parameter n_bytes :: <int*>;
  c-name: "pango_coverage_to_bytes";
end;

define C-function pango-coverage-from-bytes
  input parameter bytes :: <guchar*>;
  input parameter n_bytes :: <integer>;
  result res :: <PangoCoverage>;
  c-name: "pango_coverage_from_bytes";
end;

define constant <wint-t> = <wchar-t>;

define constant <wctype-t> = <wchar-t>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<FILE<@>>"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "_iob"*/
define constant <fpos-t> = <integer>;

define C-function _filbuf
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "_filbuf";
end;

define C-function _flsbuf
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "_flsbuf";
end;

define C-function _fsopen
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <FILE>;
  c-name: "_fsopen";
end;

define C-function clearerr
  input parameter  :: <FILE>;
  c-name: "clearerr";
end;

define C-function fclose
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fclose";
end;

define C-function _fcloseall
  result res :: <integer>;
  c-name: "_fcloseall";
end;

define C-function fdopen
  input parameter  :: <integer>;
  input parameter  :: <c-string>;
  result res :: <FILE>;
  c-name: "fdopen";
end;

define C-function feof
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "feof";
end;

define C-function ferror
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "ferror";
end;

define C-function fflush
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fflush";
end;

define C-function fgetc
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fgetc";
end;

define C-function _fgetchar
  result res :: <integer>;
  c-name: "_fgetchar";
end;

define C-pointer-type <fpos-t*> => <fpos-t>;
define C-function fgetpos
  input parameter  :: <FILE>;
  input parameter  :: <fpos-t*>;
  result res :: <integer>;
  c-name: "fgetpos";
end;

define C-function fgets
  input parameter  :: <c-string>;
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <c-string>;
  c-name: "fgets";
end;

define C-function fileno
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fileno";
end;

define C-function _flushall
  result res :: <integer>;
  c-name: "_flushall";
end;

define C-function fopen
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <FILE>;
  c-name: "fopen";
end;

define C-function fprintf
  input parameter  :: <FILE>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "fprintf";
end;

define C-function fputc
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fputc";
end;

define C-function _fputchar
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "_fputchar";
end;

define C-function fputs
  input parameter  :: <c-string>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fputs";
end;

define C-function fread
  input parameter  :: <machine-pointer>;
  input parameter  :: <size-t>;
  input parameter  :: <size-t>;
  input parameter  :: <FILE>;
  result res :: <size-t>;
  c-name: "fread";
end;

define C-function freopen
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  input parameter  :: <FILE>;
  result res :: <FILE>;
  c-name: "freopen";
end;

define C-function fscanf
  input parameter  :: <FILE>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "fscanf";
end;

define C-function fsetpos
  input parameter  :: <FILE>;
  input parameter  :: <fpos-t*>;
  result res :: <integer>;
  c-name: "fsetpos";
end;

define C-function fseek
  input parameter  :: <FILE>;
  input parameter  :: <integer>;
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "fseek";
end;

define C-function ftell
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "ftell";
end;

define C-function fwrite
  input parameter  :: <machine-pointer>;
  input parameter  :: <size-t>;
  input parameter  :: <size-t>;
  input parameter  :: <FILE>;
  result res :: <size-t>;
  c-name: "fwrite";
end;

define C-function getc
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "getc";
end;

define C-function getchar
  result res :: <integer>;
  c-name: "getchar";
end;

define C-function _getmaxstdio
  result res :: <integer>;
  c-name: "_getmaxstdio";
end;

define C-function gets
  input parameter  :: <c-string>;
  result res :: <c-string>;
  c-name: "gets";
end;

define C-function _getw
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "_getw";
end;

define C-function perror
  input parameter  :: <c-string>;
  c-name: "perror";
end;

define C-function _pclose
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "_pclose";
end;

define C-function _popen
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <FILE>;
  c-name: "_popen";
end;

define C-function printf
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "printf";
end;

define C-function putc
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "putc";
end;

define C-function putchar
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "putchar";
end;

define C-function puts
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "puts";
end;

define C-function _putw
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "_putw";
end;

define C-function remove
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "remove";
end;

define C-function rename
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "rename";
end;

define C-function rewind
  input parameter  :: <FILE>;
  c-name: "rewind";
end;

define C-function _rmtmp
  result res :: <integer>;
  c-name: "_rmtmp";
end;

define C-function scanf
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "scanf";
end;

define C-function setbuf
  input parameter  :: <FILE>;
  input parameter  :: <c-string>;
  c-name: "setbuf";
end;

define C-function _setmaxstdio
  input parameter  :: <integer>;
  result res :: <integer>;
  c-name: "_setmaxstdio";
end;

define C-function setvbuf
  input parameter  :: <FILE>;
  input parameter  :: <c-string>;
  input parameter  :: <integer>;
  input parameter  :: <size-t>;
  result res :: <integer>;
  c-name: "setvbuf";
end;

define C-function _snprintf
  input parameter  :: <c-string>;
  input parameter  :: <size-t>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "_snprintf";
end;

define C-function sprintf
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "sprintf";
end;

define C-function sscanf
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "sscanf";
end;

define C-function _tempnam
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  result res :: <c-string>;
  c-name: "_tempnam";
end;

define C-function tmpfile
  result res :: <FILE>;
  c-name: "tmpfile";
end;

define C-function tmpnam
  input parameter  :: <c-string>;
  result res :: <c-string>;
  c-name: "tmpnam";
end;

define C-function ungetc
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "ungetc";
end;

define C-function _unlink
  input parameter  :: <c-string>;
  result res :: <integer>;
  c-name: "_unlink";
end;

define C-function vfprintf
  input parameter  :: <FILE>;
  input parameter  :: <c-string>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vfprintf";
end;

define C-function vprintf
  input parameter  :: <c-string>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vprintf";
end;

define C-function _vsnprintf
  input parameter  :: <c-string>;
  input parameter  :: <size-t>;
  input parameter  :: <c-string>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "_vsnprintf";
end;

define C-function vsprintf
  input parameter  :: <c-string>;
  input parameter  :: <c-string>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vsprintf";
end;

define C-function _wfsopen
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <FILE>;
  c-name: "_wfsopen";
end;

define C-function fgetwc
  input parameter  :: <FILE>;
  result res :: <wint-t>;
  c-name: "fgetwc";
end;

define C-function _fgetwchar
  result res :: <wint-t>;
  c-name: "_fgetwchar";
end;

define C-function fputwc
  input parameter  :: <wint-t>;
  input parameter  :: <FILE>;
  result res :: <wint-t>;
  c-name: "fputwc";
end;

define C-function _fputwchar
  input parameter  :: <wint-t>;
  result res :: <wint-t>;
  c-name: "_fputwchar";
end;

define C-function getwc
  input parameter  :: <FILE>;
  result res :: <wint-t>;
  c-name: "getwc";
end;

define C-function getwchar
  result res :: <wint-t>;
  c-name: "getwchar";
end;

define C-function putwc
  input parameter  :: <wint-t>;
  input parameter  :: <FILE>;
  result res :: <wint-t>;
  c-name: "putwc";
end;

define C-function putwchar
  input parameter  :: <wint-t>;
  result res :: <wint-t>;
  c-name: "putwchar";
end;

define C-function ungetwc
  input parameter  :: <wint-t>;
  input parameter  :: <FILE>;
  result res :: <wint-t>;
  c-name: "ungetwc";
end;

define C-function fgetws
  input parameter  :: <wchar-t*>;
  input parameter  :: <integer>;
  input parameter  :: <FILE>;
  result res :: <wchar-t*>;
  c-name: "fgetws";
end;

define C-function fputws
  input parameter  :: <wchar-t*>;
  input parameter  :: <FILE>;
  result res :: <integer>;
  c-name: "fputws";
end;

define C-function _getws
  input parameter  :: <wchar-t*>;
  result res :: <wchar-t*>;
  c-name: "_getws";
end;

define C-function _putws
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "_putws";
end;

define C-function fwprintf
  input parameter  :: <FILE>;
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "fwprintf";
end;

define C-function wprintf
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "wprintf";
end;

define C-function _snwprintf
  input parameter  :: <wchar-t*>;
  input parameter  :: <size-t>;
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "_snwprintf";
end;

define C-function swprintf
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "swprintf";
end;

define C-function vfwprintf
  input parameter  :: <FILE>;
  input parameter  :: <wchar-t*>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vfwprintf";
end;

define C-function vwprintf
  input parameter  :: <wchar-t*>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vwprintf";
end;

define C-function _vsnwprintf
  input parameter  :: <wchar-t*>;
  input parameter  :: <size-t>;
  input parameter  :: <wchar-t*>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "_vsnwprintf";
end;

define C-function vswprintf
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  input parameter  :: <va-list>;
  result res :: <integer>;
  c-name: "vswprintf";
end;

define C-function fwscanf
  input parameter  :: <FILE>;
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "fwscanf";
end;

define C-function swscanf
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "swscanf";
end;

define C-function wscanf
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "wscanf";
end;

define C-function _wfdopen
  input parameter  :: <integer>;
  input parameter  :: <wchar-t*>;
  result res :: <FILE>;
  c-name: "_wfdopen";
end;

define C-function _wfopen
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <FILE>;
  c-name: "_wfopen";
end;

define C-function _wfreopen
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  input parameter  :: <FILE>;
  result res :: <FILE>;
  c-name: "_wfreopen";
end;

define C-function _wperror
  input parameter  :: <wchar-t*>;
  c-name: "_wperror";
end;

define C-function _wpopen
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <FILE>;
  c-name: "_wpopen";
end;

define C-function _wremove
  input parameter  :: <wchar-t*>;
  result res :: <integer>;
  c-name: "_wremove";
end;

define C-function _wtempnam
  input parameter  :: <wchar-t*>;
  input parameter  :: <wchar-t*>;
  result res :: <wchar-t*>;
  c-name: "_wtempnam";
end;

define C-function _wtmpnam
  input parameter  :: <wchar-t*>;
  result res :: <wchar-t*>;
  c-name: "_wtmpnam";
end;

define constant $BUFSIZ = 512;

define constant $_NFILE = 512;

define constant $_NSTREAM- = 512;

define constant $_IOB-ENTRIES = 20;

define constant $EOF = -1;

define constant $_P-tmpdir = "/";

define constant $L-ctermid = 9;

define constant $L-cuserid = 32;

define constant $SEEK-CUR = 1;

define constant $SEEK-END = 2;

define constant $SEEK-SET = 0;

define constant $FILENAME-MAX = 260;

define constant $FOPEN-MAX = 20;

define constant $_SYS-OPEN = 20;

define constant $TMP-MAX = 32767;

define constant $_IOREAD = 1;

define constant $_IOWRT = 2;

define constant $_IOFBF = 0;

define constant $_IOLBF = 64;

define constant $_IONBF = 4;

define constant $_IOMYBUF = 8;

define constant $_IOEOF = 16;

define constant $_IOERR = 32;

define constant $_IOSTRG = 64;

define constant $_IORW = 128;

define constant $_IOAPPEND = 512;

define constant $WEOF = 65535;

define C-subtype <_PangoTabArray> (<C-void*>) end;
define constant <PangoTabArray> = <_PangoTabArray>;

define constant <PangoTabAlign> = limited(<integer>, min: 0, max: 0);
define constant $PANGO-TAB-LEFT :: <PangoTabAlign> = 0;

define C-function pango-tab-array-new
  input parameter initial_size :: <gint>;
  input parameter positions_in_pixels :: <gboolean>;
  result res :: <PangoTabArray>;
  c-name: "pango_tab_array_new";
end;

define C-function pango-tab-array-new-with-positions
  input parameter size :: <gint>;
  input parameter positions_in_pixels :: <gboolean>;
  input parameter first_alignment :: <PangoTabAlign>;
  input parameter first_position :: <gint>;
  result res :: <PangoTabArray>;
  c-name: "pango_tab_array_new_with_positions";
end;

define C-function pango-tab-array-get-type
  result res :: <GType>;
  c-name: "pango_tab_array_get_type";
end;

define C-function pango-tab-array-copy
  input parameter src :: <PangoTabArray>;
  result res :: <PangoTabArray>;
  c-name: "pango_tab_array_copy";
end;

define C-function pango-tab-array-free
  input parameter tab_array :: <PangoTabArray>;
  c-name: "pango_tab_array_free";
end;

define C-function pango-tab-array-get-size
  input parameter tab_array :: <PangoTabArray>;
  result res :: <gint>;
  c-name: "pango_tab_array_get_size";
end;

define C-function pango-tab-array-resize
  input parameter tab_array :: <PangoTabArray>;
  input parameter new_size :: <gint>;
  c-name: "pango_tab_array_resize";
end;

define C-function pango-tab-array-set-tab
  input parameter tab_array :: <PangoTabArray>;
  input parameter tab_index :: <gint>;
  input parameter alignment :: <PangoTabAlign>;
  input parameter location :: <gint>;
  c-name: "pango_tab_array_set_tab";
end;

define C-pointer-type <PangoTabAlign*> => <PangoTabAlign>;
define C-function pango-tab-array-get-tab
  input parameter tab_array :: <PangoTabArray>;
  input parameter tab_index :: <gint>;
  input parameter alignment :: <PangoTabAlign*>;
  input parameter location :: <gint*>;
  c-name: "pango_tab_array_get_tab";
end;

define C-pointer-type <PangoTabAlign**> => <PangoTabAlign*>;
define C-pointer-type <gint**> => <gint*>;
define C-function pango-tab-array-get-tabs
  input parameter tab_array :: <PangoTabArray>;
  input parameter alignments :: <PangoTabAlign**>;
  input parameter locations :: <gint**>;
  c-name: "pango_tab_array_get_tabs";
end;

define C-function pango-tab-array-get-positions-in-pixels
  input parameter tab_array :: <PangoTabArray>;
  result res :: <gboolean>;
  c-name: "pango_tab_array_get_positions_in_pixels";
end;

define constant <PangoUnderline> = limited(<integer>, min: 0, max: 4);
define constant $PANGO-UNDERLINE-NONE :: <PangoUnderline> = 0;
define constant $PANGO-UNDERLINE-SINGLE :: <PangoUnderline> = 1;
define constant $PANGO-UNDERLINE-DOUBLE :: <PangoUnderline> = 2;
define constant $PANGO-UNDERLINE-LOW :: <PangoUnderline> = 3;
define constant $PANGO-UNDERLINE-ERROR :: <PangoUnderline> = 4;

define C-subtype <_PangoRendererPrivate> (<C-void*>) end;
define constant <PangoRendererPrivate> = <_PangoRendererPrivate>;

define C-subtype <_PangoRenderer> (<C-void*>) end;
define constant <PangoRenderer> = <_PangoRenderer>;

define constant <PangoGlyphUnit> = <gint32>;

define C-subtype <_PangoGlyphGeometry> (<C-void*>) end;
define constant <PangoGlyphGeometry> = <_PangoGlyphGeometry>;

define C-subtype <_PangoGlyphVisAttr> (<C-void*>) end;
define constant <PangoGlyphVisAttr> = <_PangoGlyphVisAttr>;

define C-subtype <_PangoGlyphInfo> (<C-void*>) end;
define constant <PangoGlyphInfo> = <_PangoGlyphInfo>;

define C-subtype <_PangoGlyphString> (<C-void*>) end;
define constant <PangoGlyphString> = <_PangoGlyphString>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2151>"*/
define constant <PangoRenderPart> = limited(<integer>, min: 0, max: 3);
define constant $PANGO-RENDER-PART-FOREGROUND :: <PangoRenderPart> = 0;
define constant $PANGO-RENDER-PART-BACKGROUND :: <PangoRenderPart> = 1;
define constant $PANGO-RENDER-PART-UNDERLINE :: <PangoRenderPart> = 2;
define constant $PANGO-RENDER-PART-STRIKETHROUGH :: <PangoRenderPart> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2152>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2153>"*/
define constant <PangoAttrType> = limited(<integer>, min: 0, max: 22);
define constant $PANGO-ATTR-INVALID :: <PangoAttrType> = 0;
define constant $PANGO-ATTR-LANGUAGE :: <PangoAttrType> = 1;
define constant $PANGO-ATTR-FAMILY :: <PangoAttrType> = 2;
define constant $PANGO-ATTR-STYLE :: <PangoAttrType> = 3;
define constant $PANGO-ATTR-WEIGHT :: <PangoAttrType> = 4;
define constant $PANGO-ATTR-VARIANT :: <PangoAttrType> = 5;
define constant $PANGO-ATTR-STRETCH :: <PangoAttrType> = 6;
define constant $PANGO-ATTR-SIZE :: <PangoAttrType> = 7;
define constant $PANGO-ATTR-FONT-DESC :: <PangoAttrType> = 8;
define constant $PANGO-ATTR-FOREGROUND :: <PangoAttrType> = 9;
define constant $PANGO-ATTR-BACKGROUND :: <PangoAttrType> = 10;
define constant $PANGO-ATTR-UNDERLINE :: <PangoAttrType> = 11;
define constant $PANGO-ATTR-STRIKETHROUGH :: <PangoAttrType> = 12;
define constant $PANGO-ATTR-RISE :: <PangoAttrType> = 13;
define constant $PANGO-ATTR-SHAPE :: <PangoAttrType> = 14;
define constant $PANGO-ATTR-SCALE :: <PangoAttrType> = 15;
define constant $PANGO-ATTR-FALLBACK :: <PangoAttrType> = 16;
define constant $PANGO-ATTR-LETTER-SPACING :: <PangoAttrType> = 17;
define constant $PANGO-ATTR-UNDERLINE-COLOR :: <PangoAttrType> = 18;
define constant $PANGO-ATTR-STRIKETHROUGH-COLOR :: <PangoAttrType> = 19;
define constant $PANGO-ATTR-ABSOLUTE-SIZE :: <PangoAttrType> = 20;
define constant $PANGO-ATTR-GRAVITY :: <PangoAttrType> = 21;
define constant $PANGO-ATTR-GRAVITY-HINT :: <PangoAttrType> = 22;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1920>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1921>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1922>"*/
define C-subtype <_PangoAttrClass> (<C-void*>) end;
define constant <PangoAttrClass> = <_PangoAttrClass>;

define C-subtype <_PangoAttribute> (<C-void*>) end;
define constant <PangoAttribute> = <_PangoAttribute>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1919>"*/
define constant <PangoAttrDataCopyFunc> = <anonymous-1919>;

define C-subtype <_PangoAttrShape> (<C-void*>) end;
define constant <PangoAttrShape> = <_PangoAttrShape>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2154>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2155>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2156>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2157>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2158>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2159>"*/
define C-subtype <_PangoAnalysis> (<C-void*>) end;
define constant <PangoAnalysis> = <_PangoAnalysis>;

define C-subtype <_PangoItem> (<C-void*>) end;
define constant <PangoItem> = <_PangoItem>;

define C-subtype <_PangoGlyphItem> (<C-void*>) end;
define constant <PangoGlyphItem> = <_PangoGlyphItem>;

define constant <PangoLayoutRun> = <PangoGlyphItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2160>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2161>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2162>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2163>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2164>"*/
define C-subtype <_PangoRendererClass> (<C-void*>) end;
define constant <PangoRendererClass> = <_PangoRendererClass>;

define C-function pango-renderer-get-type
  result res :: <GType>;
  c-name: "pango_renderer_get_type";
end;

define C-function pango-renderer-draw-layout
  input parameter renderer :: <PangoRenderer>;
  input parameter layout :: <PangoLayout>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  c-name: "pango_renderer_draw_layout";
end;

define C-subtype <_PangoLayoutLine> (<C-void*>) end;
define constant <PangoLayoutLine> = <_PangoLayoutLine>;

define C-function pango-renderer-draw-layout-line
  input parameter renderer :: <PangoRenderer>;
  input parameter line :: <PangoLayoutLine>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  c-name: "pango_renderer_draw_layout_line";
end;

define C-function pango-renderer-draw-glyphs
  input parameter renderer :: <PangoRenderer>;
  input parameter font :: <PangoFont>;
  input parameter glyphs :: <PangoGlyphString>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  c-name: "pango_renderer_draw_glyphs";
end;

define C-function pango-renderer-draw-rectangle
  input parameter renderer :: <PangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  c-name: "pango_renderer_draw_rectangle";
end;

define C-function pango-renderer-draw-error-underline
  input parameter renderer :: <PangoRenderer>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  c-name: "pango_renderer_draw_error_underline";
end;

define C-function pango-renderer-draw-trapezoid
  input parameter renderer :: <PangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  input parameter y1_ :: <double-float>;
  input parameter x11 :: <double-float>;
  input parameter x21 :: <double-float>;
  input parameter y2 :: <double-float>;
  input parameter x12 :: <double-float>;
  input parameter x22 :: <double-float>;
  c-name: "pango_renderer_draw_trapezoid";
end;

define C-function pango-renderer-draw-glyph
  input parameter renderer :: <PangoRenderer>;
  input parameter font :: <PangoFont>;
  input parameter glyph :: <PangoGlyph>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  c-name: "pango_renderer_draw_glyph";
end;

define C-function pango-renderer-activate
  input parameter renderer :: <PangoRenderer>;
  c-name: "pango_renderer_activate";
end;

define C-function pango-renderer-deactivate
  input parameter renderer :: <PangoRenderer>;
  c-name: "pango_renderer_deactivate";
end;

define C-function pango-renderer-part-changed
  input parameter renderer :: <PangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  c-name: "pango_renderer_part_changed";
end;

define C-subtype <_PangoColor> (<C-void*>) end;
define constant <PangoColor> = <_PangoColor>;

define C-function pango-renderer-set-color
  input parameter renderer :: <PangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  input parameter color :: <PangoColor>;
  c-name: "pango_renderer_set_color";
end;

define C-function pango-renderer-get-color
  input parameter renderer :: <PangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  result res :: <PangoColor>;
  c-name: "pango_renderer_get_color";
end;

define C-function pango-renderer-set-matrix
  input parameter renderer :: <PangoRenderer>;
  input parameter matrix :: <PangoMatrix>;
  c-name: "pango_renderer_set_matrix";
end;

define C-function pango-renderer-get-matrix
  input parameter renderer :: <PangoRenderer>;
  result res :: <PangoMatrix>;
  c-name: "pango_renderer_get_matrix";
end;

define C-subtype <_PangoLayoutClass> (<C-void*>) end;
define constant <PangoLayoutClass> = <_PangoLayoutClass>;

define constant <PangoAlignment> = limited(<integer>, min: 0, max: 2);
define constant $PANGO-ALIGN-LEFT :: <PangoAlignment> = 0;
define constant $PANGO-ALIGN-CENTER :: <PangoAlignment> = 1;
define constant $PANGO-ALIGN-RIGHT :: <PangoAlignment> = 2;

define constant <PangoWrapMode> = limited(<integer>, min: 0, max: 2);
define constant $PANGO-WRAP-WORD :: <PangoWrapMode> = 0;
define constant $PANGO-WRAP-CHAR :: <PangoWrapMode> = 1;
define constant $PANGO-WRAP-WORD-CHAR :: <PangoWrapMode> = 2;

define constant <PangoEllipsizeMode> = limited(<integer>, min: 0, max: 3);
define constant $PANGO-ELLIPSIZE-NONE :: <PangoEllipsizeMode> = 0;
define constant $PANGO-ELLIPSIZE-START :: <PangoEllipsizeMode> = 1;
define constant $PANGO-ELLIPSIZE-MIDDLE :: <PangoEllipsizeMode> = 2;
define constant $PANGO-ELLIPSIZE-END :: <PangoEllipsizeMode> = 3;

define C-function pango-layout-get-type
  result res :: <GType>;
  c-name: "pango_layout_get_type";
end;

define C-function pango-layout-new
  input parameter context :: <PangoContext>;
  result res :: <PangoLayout>;
  c-name: "pango_layout_new";
end;

define C-function pango-layout-copy
  input parameter src :: <PangoLayout>;
  result res :: <PangoLayout>;
  c-name: "pango_layout_copy";
end;

define C-function pango-layout-get-context
  input parameter layout :: <PangoLayout>;
  result res :: <PangoContext>;
  c-name: "pango_layout_get_context";
end;

define C-subtype <_PangoAttrList> (<C-void*>) end;
define constant <PangoAttrList> = <_PangoAttrList>;

define C-function pango-layout-set-attributes
  input parameter layout :: <PangoLayout>;
  input parameter attrs :: <PangoAttrList>;
  c-name: "pango_layout_set_attributes";
end;

define C-function pango-layout-get-attributes
  input parameter layout :: <PangoLayout>;
  result res :: <PangoAttrList>;
  c-name: "pango_layout_get_attributes";
end;

define C-function pango-layout-set-text
  input parameter layout :: <PangoLayout>;
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  c-name: "pango_layout_set_text";
end;

define C-function pango-layout-get-text
  input parameter layout :: <PangoLayout>;
  result res :: <c-string>;
  c-name: "pango_layout_get_text";
end;

define C-function pango-layout-set-markup
  input parameter layout :: <PangoLayout>;
  input parameter markup :: <c-string>;
  input parameter length :: <integer>;
  c-name: "pango_layout_set_markup";
end;

define C-function pango-layout-set-markup-with-accel
  input parameter layout :: <PangoLayout>;
  input parameter markup :: <c-string>;
  input parameter length :: <integer>;
  input parameter accel_marker :: <gunichar>;
  input parameter accel_char :: <gunichar*>;
  c-name: "pango_layout_set_markup_with_accel";
end;

define C-function pango-layout-set-font-description
  input parameter layout :: <PangoLayout>;
  input parameter desc :: <PangoFontDescription>;
  c-name: "pango_layout_set_font_description";
end;

define C-function pango-layout-get-font-description
  input parameter layout :: <PangoLayout>;
  result res :: <PangoFontDescription>;
  c-name: "pango_layout_get_font_description";
end;

define C-function pango-layout-set-width
  input parameter layout :: <PangoLayout>;
  input parameter width :: <integer>;
  c-name: "pango_layout_set_width";
end;

define C-function pango-layout-get-width
  input parameter layout :: <PangoLayout>;
  result res :: <integer>;
  c-name: "pango_layout_get_width";
end;

define C-function pango-layout-set-wrap
  input parameter layout :: <PangoLayout>;
  input parameter wrap :: <PangoWrapMode>;
  c-name: "pango_layout_set_wrap";
end;

define C-function pango-layout-get-wrap
  input parameter layout :: <PangoLayout>;
  result res :: <PangoWrapMode>;
  c-name: "pango_layout_get_wrap";
end;

define C-function pango-layout-is-wrapped
  input parameter layout :: <PangoLayout>;
  result res :: <gboolean>;
  c-name: "pango_layout_is_wrapped";
end;

define C-function pango-layout-set-indent
  input parameter layout :: <PangoLayout>;
  input parameter indent :: <integer>;
  c-name: "pango_layout_set_indent";
end;

define C-function pango-layout-get-indent
  input parameter layout :: <PangoLayout>;
  result res :: <integer>;
  c-name: "pango_layout_get_indent";
end;

define C-function pango-layout-set-spacing
  input parameter layout :: <PangoLayout>;
  input parameter spacing :: <integer>;
  c-name: "pango_layout_set_spacing";
end;

define C-function pango-layout-get-spacing
  input parameter layout :: <PangoLayout>;
  result res :: <integer>;
  c-name: "pango_layout_get_spacing";
end;

define C-function pango-layout-set-justify
  input parameter layout :: <PangoLayout>;
  input parameter justify :: <gboolean>;
  c-name: "pango_layout_set_justify";
end;

define C-function pango-layout-get-justify
  input parameter layout :: <PangoLayout>;
  result res :: <gboolean>;
  c-name: "pango_layout_get_justify";
end;

define C-function pango-layout-set-auto-dir
  input parameter layout :: <PangoLayout>;
  input parameter auto_dir :: <gboolean>;
  c-name: "pango_layout_set_auto_dir";
end;

define C-function pango-layout-get-auto-dir
  input parameter layout :: <PangoLayout>;
  result res :: <gboolean>;
  c-name: "pango_layout_get_auto_dir";
end;

define C-function pango-layout-set-alignment
  input parameter layout :: <PangoLayout>;
  input parameter alignment :: <PangoAlignment>;
  c-name: "pango_layout_set_alignment";
end;

define C-function pango-layout-get-alignment
  input parameter layout :: <PangoLayout>;
  result res :: <PangoAlignment>;
  c-name: "pango_layout_get_alignment";
end;

define C-function pango-layout-set-tabs
  input parameter layout :: <PangoLayout>;
  input parameter tabs :: <PangoTabArray>;
  c-name: "pango_layout_set_tabs";
end;

define C-function pango-layout-get-tabs
  input parameter layout :: <PangoLayout>;
  result res :: <PangoTabArray>;
  c-name: "pango_layout_get_tabs";
end;

define C-function pango-layout-set-single-paragraph-mode
  input parameter layout :: <PangoLayout>;
  input parameter setting :: <gboolean>;
  c-name: "pango_layout_set_single_paragraph_mode";
end;

define C-function pango-layout-get-single-paragraph-mode
  input parameter layout :: <PangoLayout>;
  result res :: <gboolean>;
  c-name: "pango_layout_get_single_paragraph_mode";
end;

define C-function pango-layout-set-ellipsize
  input parameter layout :: <PangoLayout>;
  input parameter ellipsize :: <PangoEllipsizeMode>;
  c-name: "pango_layout_set_ellipsize";
end;

define C-function pango-layout-get-ellipsize
  input parameter layout :: <PangoLayout>;
  result res :: <PangoEllipsizeMode>;
  c-name: "pango_layout_get_ellipsize";
end;

define C-function pango-layout-is-ellipsized
  input parameter layout :: <PangoLayout>;
  result res :: <gboolean>;
  c-name: "pango_layout_is_ellipsized";
end;

define C-function pango-layout-get-unknown-glyphs-count
  input parameter layout :: <PangoLayout>;
  result res :: <integer>;
  c-name: "pango_layout_get_unknown_glyphs_count";
end;

define C-function pango-layout-context-changed
  input parameter layout :: <PangoLayout>;
  c-name: "pango_layout_context_changed";
end;

define C-pointer-type <PangoLogAttr*> => <PangoLogAttr>;
define C-function pango-layout-get-log-attrs
  input parameter layout :: <PangoLayout>;
  input parameter attrs :: <PangoLogAttr*>;
  input parameter n_attrs :: <gint*>;
  c-name: "pango_layout_get_log_attrs";
end;

define C-function pango-layout-index-to-pos
  input parameter layout :: <PangoLayout>;
  input parameter index_ :: <integer>;
  input parameter pos :: <PangoRectangle>;
  c-name: "pango_layout_index_to_pos";
end;

define C-function pango-layout-index-to-line-x
  input parameter layout :: <PangoLayout>;
  input parameter index_ :: <integer>;
  input parameter trailing :: <gboolean>;
  input parameter line :: <int*>;
  input parameter x_pos :: <int*>;
  c-name: "pango_layout_index_to_line_x";
end;

define C-function pango-layout-get-cursor-pos
  input parameter layout :: <PangoLayout>;
  input parameter index_ :: <integer>;
  input parameter strong_pos :: <PangoRectangle>;
  input parameter weak_pos :: <PangoRectangle>;
  c-name: "pango_layout_get_cursor_pos";
end;

define C-function pango-layout-move-cursor-visually
  input parameter layout :: <PangoLayout>;
  input parameter strong :: <gboolean>;
  input parameter old_index :: <integer>;
  input parameter old_trailing :: <integer>;
  input parameter direction :: <integer>;
  input parameter new_index :: <int*>;
  input parameter new_trailing :: <int*>;
  c-name: "pango_layout_move_cursor_visually";
end;

define C-function pango-layout-xy-to-index
  input parameter layout :: <PangoLayout>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  input parameter index_ :: <int*>;
  input parameter trailing :: <int*>;
  result res :: <gboolean>;
  c-name: "pango_layout_xy_to_index";
end;

define C-function pango-layout-get-extents
  input parameter layout :: <PangoLayout>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_get_extents";
end;

define C-function pango-layout-get-pixel-extents
  input parameter layout :: <PangoLayout>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_get_pixel_extents";
end;

define C-function pango-layout-get-size
  input parameter layout :: <PangoLayout>;
  input parameter width :: <int*>;
  input parameter height :: <int*>;
  c-name: "pango_layout_get_size";
end;

define C-function pango-layout-get-pixel-size
  input parameter layout :: <PangoLayout>;
  input parameter width :: <int*>;
  input parameter height :: <int*>;
  c-name: "pango_layout_get_pixel_size";
end;

define C-function pango-layout-get-line-count
  input parameter layout :: <PangoLayout>;
  result res :: <integer>;
  c-name: "pango_layout_get_line_count";
end;

define C-function pango-layout-get-line
  input parameter layout :: <PangoLayout>;
  input parameter line :: <integer>;
  result res :: <PangoLayoutLine>;
  c-name: "pango_layout_get_line";
end;

define C-function pango-layout-get-line-readonly
  input parameter layout :: <PangoLayout>;
  input parameter line :: <integer>;
  result res :: <PangoLayoutLine>;
  c-name: "pango_layout_get_line_readonly";
end;

define C-function pango-layout-get-lines
  input parameter layout :: <PangoLayout>;
  result res :: <GSList>;
  c-name: "pango_layout_get_lines";
end;

define C-function pango-layout-get-lines-readonly
  input parameter layout :: <PangoLayout>;
  result res :: <GSList>;
  c-name: "pango_layout_get_lines_readonly";
end;

define C-function pango-layout-line-get-type
  result res :: <GType>;
  c-name: "pango_layout_line_get_type";
end;

define C-function pango-layout-line-ref
  input parameter line :: <PangoLayoutLine>;
  result res :: <PangoLayoutLine>;
  c-name: "pango_layout_line_ref";
end;

define C-function pango-layout-line-unref
  input parameter line :: <PangoLayoutLine>;
  c-name: "pango_layout_line_unref";
end;

define C-function pango-layout-line-x-to-index
  input parameter line :: <PangoLayoutLine>;
  input parameter x_pos :: <integer>;
  input parameter index_ :: <int*>;
  input parameter trailing :: <int*>;
  result res :: <gboolean>;
  c-name: "pango_layout_line_x_to_index";
end;

define C-function pango-layout-line-index-to-x
  input parameter line :: <PangoLayoutLine>;
  input parameter index_ :: <integer>;
  input parameter trailing :: <gboolean>;
  input parameter x_pos :: <int*>;
  c-name: "pango_layout_line_index_to_x";
end;

define C-function pango-layout-line-get-x-ranges
  input parameter line :: <PangoLayoutLine>;
  input parameter start_index :: <integer>;
  input parameter end_index :: <integer>;
  input parameter ranges :: <int**>;
  input parameter n_ranges :: <int*>;
  c-name: "pango_layout_line_get_x_ranges";
end;

define C-function pango-layout-line-get-extents
  input parameter line :: <PangoLayoutLine>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_line_get_extents";
end;

define C-function pango-layout-line-get-pixel-extents
  input parameter layout_line :: <PangoLayoutLine>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_line_get_pixel_extents";
end;

define C-subtype <_PangoLayoutIter> (<C-void*>) end;
define constant <PangoLayoutIter> = <_PangoLayoutIter>;

define C-function pango-layout-iter-get-type
  result res :: <GType>;
  c-name: "pango_layout_iter_get_type";
end;

define C-function pango-layout-get-iter
  input parameter layout :: <PangoLayout>;
  result res :: <PangoLayoutIter>;
  c-name: "pango_layout_get_iter";
end;

define C-function pango-layout-iter-free
  input parameter iter :: <PangoLayoutIter>;
  c-name: "pango_layout_iter_free";
end;

define C-function pango-layout-iter-get-index
  input parameter iter :: <PangoLayoutIter>;
  result res :: <integer>;
  c-name: "pango_layout_iter_get_index";
end;

define C-function pango-layout-iter-get-run
  input parameter iter :: <PangoLayoutIter>;
  result res :: <PangoLayoutRun>;
  c-name: "pango_layout_iter_get_run";
end;

define C-function pango-layout-iter-get-run-readonly
  input parameter iter :: <PangoLayoutIter>;
  result res :: <PangoLayoutRun>;
  c-name: "pango_layout_iter_get_run_readonly";
end;

define C-function pango-layout-iter-get-line
  input parameter iter :: <PangoLayoutIter>;
  result res :: <PangoLayoutLine>;
  c-name: "pango_layout_iter_get_line";
end;

define C-function pango-layout-iter-get-line-readonly
  input parameter iter :: <PangoLayoutIter>;
  result res :: <PangoLayoutLine>;
  c-name: "pango_layout_iter_get_line_readonly";
end;

define C-function pango-layout-iter-at-last-line
  input parameter iter :: <PangoLayoutIter>;
  result res :: <gboolean>;
  c-name: "pango_layout_iter_at_last_line";
end;

define C-function pango-layout-iter-next-char
  input parameter iter :: <PangoLayoutIter>;
  result res :: <gboolean>;
  c-name: "pango_layout_iter_next_char";
end;

define C-function pango-layout-iter-next-cluster
  input parameter iter :: <PangoLayoutIter>;
  result res :: <gboolean>;
  c-name: "pango_layout_iter_next_cluster";
end;

define C-function pango-layout-iter-next-run
  input parameter iter :: <PangoLayoutIter>;
  result res :: <gboolean>;
  c-name: "pango_layout_iter_next_run";
end;

define C-function pango-layout-iter-next-line
  input parameter iter :: <PangoLayoutIter>;
  result res :: <gboolean>;
  c-name: "pango_layout_iter_next_line";
end;

define C-function pango-layout-iter-get-char-extents
  input parameter iter :: <PangoLayoutIter>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_iter_get_char_extents";
end;

define C-function pango-layout-iter-get-cluster-extents
  input parameter iter :: <PangoLayoutIter>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_iter_get_cluster_extents";
end;

define C-function pango-layout-iter-get-run-extents
  input parameter iter :: <PangoLayoutIter>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_iter_get_run_extents";
end;

define C-function pango-layout-iter-get-line-extents
  input parameter iter :: <PangoLayoutIter>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_iter_get_line_extents";
end;

define C-function pango-layout-iter-get-line-yrange
  input parameter iter :: <PangoLayoutIter>;
  input parameter y0_ :: <int*>;
  input parameter y1_ :: <int*>;
  c-name: "pango_layout_iter_get_line_yrange";
end;

define C-function pango-layout-iter-get-layout-extents
  input parameter iter :: <PangoLayoutIter>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_layout_iter_get_layout_extents";
end;

define C-function pango-layout-iter-get-baseline
  input parameter iter :: <PangoLayoutIter>;
  result res :: <integer>;
  c-name: "pango_layout_iter_get_baseline";
end;

define C-function pango-glyph-item-split
  input parameter orig :: <PangoGlyphItem>;
  input parameter text :: <c-string>;
  input parameter split_index :: <integer>;
  result res :: <PangoGlyphItem>;
  c-name: "pango_glyph_item_split";
end;

define C-function pango-glyph-item-free
  input parameter glyph_item :: <PangoGlyphItem>;
  c-name: "pango_glyph_item_free";
end;

define C-function pango-glyph-item-apply-attrs
  input parameter glyph_item :: <PangoGlyphItem>;
  input parameter text :: <c-string>;
  input parameter list :: <PangoAttrList>;
  result res :: <GSList>;
  c-name: "pango_glyph_item_apply_attrs";
end;

define C-function pango-glyph-item-letter-space
  input parameter glyph_item :: <PangoGlyphItem>;
  input parameter text :: <c-string>;
  input parameter log_attrs :: <PangoLogAttr>;
  input parameter letter_spacing :: <integer>;
  c-name: "pango_glyph_item_letter_space";
end;

define C-function pango-glyph-string-new
  result res :: <PangoGlyphString>;
  c-name: "pango_glyph_string_new";
end;

define C-function pango-glyph-string-set-size
  input parameter string :: <PangoGlyphString>;
  input parameter new_len :: <gint>;
  c-name: "pango_glyph_string_set_size";
end;

define C-function pango-glyph-string-get-type
  result res :: <GType>;
  c-name: "pango_glyph_string_get_type";
end;

define C-function pango-glyph-string-copy
  input parameter string :: <PangoGlyphString>;
  result res :: <PangoGlyphString>;
  c-name: "pango_glyph_string_copy";
end;

define C-function pango-glyph-string-free
  input parameter string :: <PangoGlyphString>;
  c-name: "pango_glyph_string_free";
end;

define C-function pango-glyph-string-extents
  input parameter glyphs :: <PangoGlyphString>;
  input parameter font :: <PangoFont>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_glyph_string_extents";
end;

define C-function pango-glyph-string-get-width
  input parameter glyphs :: <PangoGlyphString>;
  result res :: <integer>;
  c-name: "pango_glyph_string_get_width";
end;

define C-function pango-glyph-string-extents-range
  input parameter glyphs :: <PangoGlyphString>;
  input parameter start :: <integer>;
  input parameter end :: <integer>;
  input parameter font :: <PangoFont>;
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  c-name: "pango_glyph_string_extents_range";
end;

define C-function pango-glyph-string-get-logical-widths
  input parameter glyphs :: <PangoGlyphString>;
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter embedding_level :: <integer>;
  input parameter logical_widths :: <int*>;
  c-name: "pango_glyph_string_get_logical_widths";
end;

define C-function pango-glyph-string-index-to-x
  input parameter glyphs :: <PangoGlyphString>;
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter analysis :: <PangoAnalysis>;
  input parameter index_ :: <integer>;
  input parameter trailing :: <gboolean>;
  input parameter x_pos :: <int*>;
  c-name: "pango_glyph_string_index_to_x";
end;

define C-function pango-glyph-string-x-to-index
  input parameter glyphs :: <PangoGlyphString>;
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter analysis :: <PangoAnalysis>;
  input parameter x_pos :: <integer>;
  input parameter index_ :: <int*>;
  input parameter trailing :: <int*>;
  c-name: "pango_glyph_string_x_to_index";
end;

define C-function pango-shape
  input parameter text :: <c-string>;
  input parameter length :: <gint>;
  input parameter analysis :: <PangoAnalysis>;
  input parameter glyphs :: <PangoGlyphString>;
  c-name: "pango_shape";
end;

define C-function pango-reorder-items
  input parameter logical_items :: <GList>;
  result res :: <GList>;
  c-name: "pango_reorder_items";
end;

define C-function pango-item-get-type
  result res :: <GType>;
  c-name: "pango_item_get_type";
end;

define C-function pango-item-new
  result res :: <PangoItem>;
  c-name: "pango_item_new";
end;

define C-function pango-item-copy
  input parameter item :: <PangoItem>;
  result res :: <PangoItem>;
  c-name: "pango_item_copy";
end;

define C-function pango-item-free
  input parameter item :: <PangoItem>;
  c-name: "pango_item_free";
end;

define C-function pango-item-split
  input parameter orig :: <PangoItem>;
  input parameter split_index :: <integer>;
  input parameter split_offset :: <integer>;
  result res :: <PangoItem>;
  c-name: "pango_item_split";
end;

define constant $PANGO-ANALYSIS-FLAG-CENTERED-BASELINE = 1;

define C-function pango-break
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter analysis :: <PangoAnalysis>;
  input parameter attrs :: <PangoLogAttr>;
  input parameter attrs_len :: <integer>;
  c-name: "pango_break";
end;

define C-function pango-find-paragraph-boundary
  input parameter text :: <c-string>;
  input parameter length :: <gint>;
  input parameter paragraph_delimiter_index :: <gint*>;
  input parameter next_paragraph_start :: <gint*>;
  c-name: "pango_find_paragraph_boundary";
end;

define C-function pango-get-log-attrs
  input parameter text :: <c-string>;
  input parameter length :: <integer>;
  input parameter level :: <integer>;
  input parameter language :: <PangoLanguage>;
  input parameter log_attrs :: <PangoLogAttr>;
  input parameter attrs_len :: <integer>;
  c-name: "pango_get_log_attrs";
end;

define C-function pango-color-get-type
  result res :: <GType>;
  c-name: "pango_color_get_type";
end;

define C-function pango-color-copy
  input parameter src :: <PangoColor>;
  result res :: <PangoColor>;
  c-name: "pango_color_copy";
end;

define C-function pango-color-free
  input parameter color :: <PangoColor>;
  c-name: "pango_color_free";
end;

define C-function pango-color-parse
  input parameter color :: <PangoColor>;
  input parameter spec :: <c-string>;
  result res :: <gboolean>;
  c-name: "pango_color_parse";
end;

define C-function pango-color-to-string
  input parameter color :: <PangoColor>;
  result res :: <c-string>;
  c-name: "pango_color_to_string";
end;

define C-subtype <_PangoAttrString> (<C-void*>) end;
define constant <PangoAttrString> = <_PangoAttrString>;

define C-subtype <_PangoAttrLanguage> (<C-void*>) end;
define constant <PangoAttrLanguage> = <_PangoAttrLanguage>;

define C-subtype <_PangoAttrInt> (<C-void*>) end;
define constant <PangoAttrInt> = <_PangoAttrInt>;

define C-subtype <_PangoAttrSize> (<C-void*>) end;
define constant <PangoAttrSize> = <_PangoAttrSize>;

define C-subtype <_PangoAttrFloat> (<C-void*>) end;
define constant <PangoAttrFloat> = <_PangoAttrFloat>;

define C-subtype <_PangoAttrColor> (<C-void*>) end;
define constant <PangoAttrColor> = <_PangoAttrColor>;

define C-subtype <_PangoAttrFontDesc> (<C-void*>) end;
define constant <PangoAttrFontDesc> = <_PangoAttrFontDesc>;

define C-subtype <_PangoAttrIterator> (<C-void*>) end;
define constant <PangoAttrIterator> = <_PangoAttrIterator>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1918>"*/
define constant <PangoAttrFilterFunc> = <anonymous-1918>;

define C-function pango-attr-type-register
  input parameter name :: <c-string>;
  result res :: <PangoAttrType>;
  c-name: "pango_attr_type_register";
end;

define C-function pango-attribute-copy
  input parameter attr :: <PangoAttribute>;
  result res :: <PangoAttribute>;
  c-name: "pango_attribute_copy";
end;

define C-function pango-attribute-destroy
  input parameter attr :: <PangoAttribute>;
  c-name: "pango_attribute_destroy";
end;

define C-function pango-attribute-equal
  input parameter attr1 :: <PangoAttribute>;
  input parameter attr2 :: <PangoAttribute>;
  result res :: <gboolean>;
  c-name: "pango_attribute_equal";
end;

define C-function pango-attr-language-new
  input parameter language :: <PangoLanguage>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_language_new";
end;

define C-function pango-attr-family-new
  input parameter family :: <c-string>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_family_new";
end;

define C-function pango-attr-foreground-new
  input parameter red :: <guint16>;
  input parameter green :: <guint16>;
  input parameter blue :: <guint16>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_foreground_new";
end;

define C-function pango-attr-background-new
  input parameter red :: <guint16>;
  input parameter green :: <guint16>;
  input parameter blue :: <guint16>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_background_new";
end;

define C-function pango-attr-size-new
  input parameter size :: <integer>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_size_new";
end;

define C-function pango-attr-size-new-absolute
  input parameter size :: <integer>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_size_new_absolute";
end;

define C-function pango-attr-style-new
  input parameter style :: <PangoStyle>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_style_new";
end;

define C-function pango-attr-weight-new
  input parameter weight :: <PangoWeight>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_weight_new";
end;

define C-function pango-attr-variant-new
  input parameter variant :: <PangoVariant>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_variant_new";
end;

define C-function pango-attr-stretch-new
  input parameter stretch :: <PangoStretch>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_stretch_new";
end;

define C-function pango-attr-font-desc-new
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_font_desc_new";
end;

define C-function pango-attr-underline-new
  input parameter underline :: <PangoUnderline>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_underline_new";
end;

define C-function pango-attr-underline-color-new
  input parameter red :: <guint16>;
  input parameter green :: <guint16>;
  input parameter blue :: <guint16>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_underline_color_new";
end;

define C-function pango-attr-strikethrough-new
  input parameter strikethrough :: <gboolean>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_strikethrough_new";
end;

define C-function pango-attr-strikethrough-color-new
  input parameter red :: <guint16>;
  input parameter green :: <guint16>;
  input parameter blue :: <guint16>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_strikethrough_color_new";
end;

define C-function pango-attr-rise-new
  input parameter rise :: <integer>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_rise_new";
end;

define C-function pango-attr-scale-new
  input parameter scale_factor :: <double-float>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_scale_new";
end;

define C-function pango-attr-fallback-new
  input parameter enable_fallback :: <gboolean>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_fallback_new";
end;

define C-function pango-attr-letter-spacing-new
  input parameter letter_spacing :: <integer>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_letter_spacing_new";
end;

define C-function pango-attr-shape-new
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_shape_new";
end;

define C-function pango-attr-shape-new-with-data
  input parameter ink_rect :: <PangoRectangle>;
  input parameter logical_rect :: <PangoRectangle>;
  input parameter data :: <gpointer>;
  input parameter copy_func :: <PangoAttrDataCopyFunc>;
  input parameter destroy_func :: <GDestroyNotify>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_shape_new_with_data";
end;

define C-function pango-attr-gravity-new
  input parameter gravity :: <PangoGravity>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_gravity_new";
end;

define C-function pango-attr-gravity-hint-new
  input parameter hint :: <PangoGravityHint>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_gravity_hint_new";
end;

define C-function pango-attr-list-get-type
  result res :: <GType>;
  c-name: "pango_attr_list_get_type";
end;

define C-function pango-attr-list-new
  result res :: <PangoAttrList>;
  c-name: "pango_attr_list_new";
end;

define C-function pango-attr-list-ref
  input parameter list :: <PangoAttrList>;
  result res :: <PangoAttrList>;
  c-name: "pango_attr_list_ref";
end;

define C-function pango-attr-list-unref
  input parameter list :: <PangoAttrList>;
  c-name: "pango_attr_list_unref";
end;

define C-function pango-attr-list-copy
  input parameter list :: <PangoAttrList>;
  result res :: <PangoAttrList>;
  c-name: "pango_attr_list_copy";
end;

define C-function pango-attr-list-insert
  input parameter list :: <PangoAttrList>;
  input parameter attr :: <PangoAttribute>;
  c-name: "pango_attr_list_insert";
end;

define C-function pango-attr-list-insert-before
  input parameter list :: <PangoAttrList>;
  input parameter attr :: <PangoAttribute>;
  c-name: "pango_attr_list_insert_before";
end;

define C-function pango-attr-list-change
  input parameter list :: <PangoAttrList>;
  input parameter attr :: <PangoAttribute>;
  c-name: "pango_attr_list_change";
end;

define C-function pango-attr-list-splice
  input parameter list :: <PangoAttrList>;
  input parameter other :: <PangoAttrList>;
  input parameter pos :: <gint>;
  input parameter len :: <gint>;
  c-name: "pango_attr_list_splice";
end;

define C-function pango-attr-list-filter
  input parameter list :: <PangoAttrList>;
  input parameter func :: <PangoAttrFilterFunc>;
  input parameter data :: <gpointer>;
  result res :: <PangoAttrList>;
  c-name: "pango_attr_list_filter";
end;

define C-function pango-attr-list-get-iterator
  input parameter list :: <PangoAttrList>;
  result res :: <PangoAttrIterator>;
  c-name: "pango_attr_list_get_iterator";
end;

define C-function pango-attr-iterator-range
  input parameter iterator :: <PangoAttrIterator>;
  input parameter start :: <gint*>;
  input parameter end :: <gint*>;
  c-name: "pango_attr_iterator_range";
end;

define C-function pango-attr-iterator-next
  input parameter iterator :: <PangoAttrIterator>;
  result res :: <gboolean>;
  c-name: "pango_attr_iterator_next";
end;

define C-function pango-attr-iterator-copy
  input parameter iterator :: <PangoAttrIterator>;
  result res :: <PangoAttrIterator>;
  c-name: "pango_attr_iterator_copy";
end;

define C-function pango-attr-iterator-destroy
  input parameter iterator :: <PangoAttrIterator>;
  c-name: "pango_attr_iterator_destroy";
end;

define C-function pango-attr-iterator-get
  input parameter iterator :: <PangoAttrIterator>;
  input parameter type :: <PangoAttrType>;
  result res :: <PangoAttribute>;
  c-name: "pango_attr_iterator_get";
end;

define C-pointer-type <PangoLanguage*> => <PangoLanguage>;
define C-pointer-type <GSList*> => <GSList>;
define C-function pango-attr-iterator-get-font
  input parameter iterator :: <PangoAttrIterator>;
  input parameter desc :: <PangoFontDescription>;
  input parameter language :: <PangoLanguage*>;
  input parameter extra_attrs :: <GSList*>;
  c-name: "pango_attr_iterator_get_font";
end;

define C-function pango-attr-iterator-get-attrs
  input parameter iterator :: <PangoAttrIterator>;
  result res :: <GSList>;
  c-name: "pango_attr_iterator_get_attrs";
end;

define C-pointer-type <PangoAttrList*> => <PangoAttrList>;
define C-function pango-parse-markup
  input parameter markup_text :: <c-string>;
  input parameter length :: <integer>;
  input parameter accel_marker :: <gunichar>;
  input parameter attr_list :: <PangoAttrList*>;
  input parameter text :: <c-string-vector>;
  input parameter accel_char :: <gunichar*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "pango_parse_markup";
end;

define C-subtype <_PangoContextClass> (<C-void*>) end;
define constant <PangoContextClass> = <_PangoContextClass>;

define C-function pango-context-get-type
  result res :: <GType>;
  c-name: "pango_context_get_type";
end;

define C-function pango-context-get-font-map
  input parameter context :: <PangoContext>;
  result res :: <PangoFontMap>;
  c-name: "pango_context_get_font_map";
end;

define C-pointer-type <PangoFontFamily*> => <PangoFontFamily>;
define C-pointer-type <PangoFontFamily**> => <PangoFontFamily*>;
define C-function pango-context-list-families
  input parameter context :: <PangoContext>;
  input parameter families :: <PangoFontFamily**>;
  input parameter n_families :: <int*>;
  c-name: "pango_context_list_families";
end;

define C-function pango-context-load-font
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoFont>;
  c-name: "pango_context_load_font";
end;

define C-subtype <_PangoFontset> (<C-void*>) end;
define constant <PangoFontset> = <_PangoFontset>;

define C-function pango-context-load-fontset
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  input parameter language :: <PangoLanguage>;
  result res :: <PangoFontset>;
  c-name: "pango_context_load_fontset";
end;

define C-function pango-context-get-metrics
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  input parameter language :: <PangoLanguage>;
  result res :: <PangoFontMetrics>;
  c-name: "pango_context_get_metrics";
end;

define C-function pango-context-set-font-description
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  c-name: "pango_context_set_font_description";
end;

define C-function pango-context-get-font-description
  input parameter context :: <PangoContext>;
  result res :: <PangoFontDescription>;
  c-name: "pango_context_get_font_description";
end;

define C-function pango-context-get-language
  input parameter context :: <PangoContext>;
  result res :: <PangoLanguage>;
  c-name: "pango_context_get_language";
end;

define C-function pango-context-set-language
  input parameter context :: <PangoContext>;
  input parameter language :: <PangoLanguage>;
  c-name: "pango_context_set_language";
end;

define C-function pango-context-set-base-dir
  input parameter context :: <PangoContext>;
  input parameter direction :: <PangoDirection>;
  c-name: "pango_context_set_base_dir";
end;

define C-function pango-context-get-base-dir
  input parameter context :: <PangoContext>;
  result res :: <PangoDirection>;
  c-name: "pango_context_get_base_dir";
end;

define C-function pango-context-set-base-gravity
  input parameter context :: <PangoContext>;
  input parameter gravity :: <PangoGravity>;
  c-name: "pango_context_set_base_gravity";
end;

define C-function pango-context-get-base-gravity
  input parameter context :: <PangoContext>;
  result res :: <PangoGravity>;
  c-name: "pango_context_get_base_gravity";
end;

define C-function pango-context-get-gravity
  input parameter context :: <PangoContext>;
  result res :: <PangoGravity>;
  c-name: "pango_context_get_gravity";
end;

define C-function pango-context-set-gravity-hint
  input parameter context :: <PangoContext>;
  input parameter hint :: <PangoGravityHint>;
  c-name: "pango_context_set_gravity_hint";
end;

define C-function pango-context-get-gravity-hint
  input parameter context :: <PangoContext>;
  result res :: <PangoGravityHint>;
  c-name: "pango_context_get_gravity_hint";
end;

define C-function pango-context-set-matrix
  input parameter context :: <PangoContext>;
  input parameter matrix :: <PangoMatrix>;
  c-name: "pango_context_set_matrix";
end;

define C-function pango-context-get-matrix
  input parameter context :: <PangoContext>;
  result res :: <PangoMatrix>;
  c-name: "pango_context_get_matrix";
end;

define C-function pango-itemize
  input parameter context :: <PangoContext>;
  input parameter text :: <c-string>;
  input parameter start_index :: <integer>;
  input parameter length :: <integer>;
  input parameter attrs :: <PangoAttrList>;
  input parameter cached_iter :: <PangoAttrIterator>;
  result res :: <GList>;
  c-name: "pango_itemize";
end;

define C-function pango-itemize-with-base-dir
  input parameter context :: <PangoContext>;
  input parameter base_dir :: <PangoDirection>;
  input parameter text :: <c-string>;
  input parameter start_index :: <integer>;
  input parameter length :: <integer>;
  input parameter attrs :: <PangoAttrList>;
  input parameter cached_iter :: <PangoAttrIterator>;
  result res :: <GList>;
  c-name: "pango_itemize_with_base_dir";
end;

define C-function pango-font-map-get-type
  result res :: <GType>;
  c-name: "pango_font_map_get_type";
end;

define C-function pango-font-map-load-font
  input parameter fontmap :: <PangoFontMap>;
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  result res :: <PangoFont>;
  c-name: "pango_font_map_load_font";
end;

define C-function pango-font-map-load-fontset
  input parameter fontmap :: <PangoFontMap>;
  input parameter context :: <PangoContext>;
  input parameter desc :: <PangoFontDescription>;
  input parameter language :: <PangoLanguage>;
  result res :: <PangoFontset>;
  c-name: "pango_font_map_load_fontset";
end;

define C-function pango-font-map-list-families
  input parameter fontmap :: <PangoFontMap>;
  input parameter families :: <PangoFontFamily**>;
  input parameter n_families :: <int*>;
  c-name: "pango_font_map_list_families";
end;

define C-function pango-fontset-get-type
  result res :: <GType>;
  c-name: "pango_fontset_get_type";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-1990>"*/
define constant <PangoFontsetForeachFunc> = <anonymous-1990>;

define C-function pango-fontset-get-font
  input parameter fontset :: <PangoFontset>;
  input parameter wc :: <guint>;
  result res :: <PangoFont>;
  c-name: "pango_fontset_get_font";
end;

define C-function pango-fontset-get-metrics
  input parameter fontset :: <PangoFontset>;
  result res :: <PangoFontMetrics>;
  c-name: "pango_fontset_get_metrics";
end;

define C-function pango-fontset-foreach
  input parameter fontset :: <PangoFontset>;
  input parameter func :: <PangoFontsetForeachFunc>;
  input parameter data :: <gpointer>;
  c-name: "pango_fontset_foreach";
end;

define constant $PANGO-VERSION-MAJOR = 1;

define constant $PANGO-VERSION-MINOR = 16;

define constant $PANGO-VERSION-MICRO = 1;

define constant $PANGO-VERSION-STRING = "1.16.1";

define C-function pango-attr-type-get-type
  result res :: <GType>;
  c-name: "pango_attr_type_get_type";
end;

define C-function pango-underline-get-type
  result res :: <GType>;
  c-name: "pango_underline_get_type";
end;

define C-function pango-coverage-level-get-type
  result res :: <GType>;
  c-name: "pango_coverage_level_get_type";
end;

define C-function pango-style-get-type
  result res :: <GType>;
  c-name: "pango_style_get_type";
end;

define C-function pango-variant-get-type
  result res :: <GType>;
  c-name: "pango_variant_get_type";
end;

define C-function pango-weight-get-type
  result res :: <GType>;
  c-name: "pango_weight_get_type";
end;

define C-function pango-stretch-get-type
  result res :: <GType>;
  c-name: "pango_stretch_get_type";
end;

define C-function pango-font-mask-get-type
  result res :: <GType>;
  c-name: "pango_font_mask_get_type";
end;

define C-function pango-gravity-get-type
  result res :: <GType>;
  c-name: "pango_gravity_get_type";
end;

define C-function pango-gravity-hint-get-type
  result res :: <GType>;
  c-name: "pango_gravity_hint_get_type";
end;

define C-function pango-alignment-get-type
  result res :: <GType>;
  c-name: "pango_alignment_get_type";
end;

define C-function pango-wrap-mode-get-type
  result res :: <GType>;
  c-name: "pango_wrap_mode_get_type";
end;

define C-function pango-ellipsize-mode-get-type
  result res :: <GType>;
  c-name: "pango_ellipsize_mode_get_type";
end;

define C-function pango-render-part-get-type
  result res :: <GType>;
  c-name: "pango_render_part_get_type";
end;

define C-function pango-script-get-type
  result res :: <GType>;
  c-name: "pango_script_get_type";
end;

define C-function pango-tab-align-get-type
  result res :: <GType>;
  c-name: "pango_tab_align_get_type";
end;

define C-function pango-direction-get-type
  result res :: <GType>;
  c-name: "pango_direction_get_type";
end;

define constant <GtkAnchorType> = limited(<integer>, min: 0, max: 8);
define constant $GTK-ANCHOR-CENTER :: <GtkAnchorType> = 0;
define constant $GTK-ANCHOR-NORTH :: <GtkAnchorType> = 1;
define constant $GTK-ANCHOR-NORTH-WEST :: <GtkAnchorType> = 2;
define constant $GTK-ANCHOR-NORTH-EAST :: <GtkAnchorType> = 3;
define constant $GTK-ANCHOR-SOUTH :: <GtkAnchorType> = 4;
define constant $GTK-ANCHOR-SOUTH-WEST :: <GtkAnchorType> = 5;
define constant $GTK-ANCHOR-SOUTH-EAST :: <GtkAnchorType> = 6;
define constant $GTK-ANCHOR-WEST :: <GtkAnchorType> = 7;
define constant $GTK-ANCHOR-EAST :: <GtkAnchorType> = 8;
define constant $GTK-ANCHOR-N :: <GtkAnchorType> = 1;
define constant $GTK-ANCHOR-NW :: <GtkAnchorType> = 2;
define constant $GTK-ANCHOR-NE :: <GtkAnchorType> = 3;
define constant $GTK-ANCHOR-S :: <GtkAnchorType> = 4;
define constant $GTK-ANCHOR-SW :: <GtkAnchorType> = 5;
define constant $GTK-ANCHOR-SE :: <GtkAnchorType> = 6;
define constant $GTK-ANCHOR-W :: <GtkAnchorType> = 7;
define constant $GTK-ANCHOR-E :: <GtkAnchorType> = 8;

define constant <GtkAttachOptions> = limited(<integer>, min: 1, max: 4);
define constant $GTK-EXPAND :: <GtkAttachOptions> = 1;
define constant $GTK-SHRINK :: <GtkAttachOptions> = 2;
define constant $GTK-FILL :: <GtkAttachOptions> = 4;

define constant <GtkButtonBoxStyle> = limited(<integer>, min: 0, max: 4);
define constant $GTK-BUTTONBOX-DEFAULT-STYLE :: <GtkButtonBoxStyle> = 0;
define constant $GTK-BUTTONBOX-SPREAD :: <GtkButtonBoxStyle> = 1;
define constant $GTK-BUTTONBOX-EDGE :: <GtkButtonBoxStyle> = 2;
define constant $GTK-BUTTONBOX-START :: <GtkButtonBoxStyle> = 3;
define constant $GTK-BUTTONBOX-END :: <GtkButtonBoxStyle> = 4;

define constant <GtkCurveType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-CURVE-TYPE-LINEAR :: <GtkCurveType> = 0;
define constant $GTK-CURVE-TYPE-SPLINE :: <GtkCurveType> = 1;
define constant $GTK-CURVE-TYPE-FREE :: <GtkCurveType> = 2;

define constant <GtkDeleteType> = limited(<integer>, min: 0, max: 7);
define constant $GTK-DELETE-CHARS :: <GtkDeleteType> = 0;
define constant $GTK-DELETE-WORD-ENDS :: <GtkDeleteType> = 1;
define constant $GTK-DELETE-WORDS :: <GtkDeleteType> = 2;
define constant $GTK-DELETE-DISPLAY-LINES :: <GtkDeleteType> = 3;
define constant $GTK-DELETE-DISPLAY-LINE-ENDS :: <GtkDeleteType> = 4;
define constant $GTK-DELETE-PARAGRAPH-ENDS :: <GtkDeleteType> = 5;
define constant $GTK-DELETE-PARAGRAPHS :: <GtkDeleteType> = 6;
define constant $GTK-DELETE-WHITESPACE :: <GtkDeleteType> = 7;

define constant <GtkSensitivityType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-SENSITIVITY-AUTO :: <GtkSensitivityType> = 0;
define constant $GTK-SENSITIVITY-ON :: <GtkSensitivityType> = 1;
define constant $GTK-SENSITIVITY-OFF :: <GtkSensitivityType> = 2;

define constant <GtkSideType> = limited(<integer>, min: 0, max: 3);
define constant $GTK-SIDE-TOP :: <GtkSideType> = 0;
define constant $GTK-SIDE-BOTTOM :: <GtkSideType> = 1;
define constant $GTK-SIDE-LEFT :: <GtkSideType> = 2;
define constant $GTK-SIDE-RIGHT :: <GtkSideType> = 3;

define constant <GtkJustification> = limited(<integer>, min: 0, max: 3);
define constant $GTK-JUSTIFY-LEFT :: <GtkJustification> = 0;
define constant $GTK-JUSTIFY-RIGHT :: <GtkJustification> = 1;
define constant $GTK-JUSTIFY-CENTER :: <GtkJustification> = 2;
define constant $GTK-JUSTIFY-FILL :: <GtkJustification> = 3;

define constant <GtkMatchType> = limited(<integer>, min: 0, max: 5);
define constant $GTK-MATCH-ALL :: <GtkMatchType> = 0;
define constant $GTK-MATCH-ALL-TAIL :: <GtkMatchType> = 1;
define constant $GTK-MATCH-HEAD :: <GtkMatchType> = 2;
define constant $GTK-MATCH-TAIL :: <GtkMatchType> = 3;
define constant $GTK-MATCH-EXACT :: <GtkMatchType> = 4;
define constant $GTK-MATCH-LAST :: <GtkMatchType> = 5;

define constant <GtkMenuDirectionType> = limited(<integer>, min: 0, max: 3);
define constant $GTK-MENU-DIR-PARENT :: <GtkMenuDirectionType> = 0;
define constant $GTK-MENU-DIR-CHILD :: <GtkMenuDirectionType> = 1;
define constant $GTK-MENU-DIR-NEXT :: <GtkMenuDirectionType> = 2;
define constant $GTK-MENU-DIR-PREV :: <GtkMenuDirectionType> = 3;

define constant <GtkMetricType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PIXELS :: <GtkMetricType> = 0;
define constant $GTK-INCHES :: <GtkMetricType> = 1;
define constant $GTK-CENTIMETERS :: <GtkMetricType> = 2;

define constant <GtkMovementStep> = limited(<integer>, min: 0, max: 9);
define constant $GTK-MOVEMENT-LOGICAL-POSITIONS :: <GtkMovementStep> = 0;
define constant $GTK-MOVEMENT-VISUAL-POSITIONS :: <GtkMovementStep> = 1;
define constant $GTK-MOVEMENT-WORDS :: <GtkMovementStep> = 2;
define constant $GTK-MOVEMENT-DISPLAY-LINES :: <GtkMovementStep> = 3;
define constant $GTK-MOVEMENT-DISPLAY-LINE-ENDS :: <GtkMovementStep> = 4;
define constant $GTK-MOVEMENT-PARAGRAPHS :: <GtkMovementStep> = 5;
define constant $GTK-MOVEMENT-PARAGRAPH-ENDS :: <GtkMovementStep> = 6;
define constant $GTK-MOVEMENT-PAGES :: <GtkMovementStep> = 7;
define constant $GTK-MOVEMENT-BUFFER-ENDS :: <GtkMovementStep> = 8;
define constant $GTK-MOVEMENT-HORIZONTAL-PAGES :: <GtkMovementStep> = 9;

define constant <GtkScrollStep> = limited(<integer>, min: 0, max: 5);
define constant $GTK-SCROLL-STEPS :: <GtkScrollStep> = 0;
define constant $GTK-SCROLL-PAGES :: <GtkScrollStep> = 1;
define constant $GTK-SCROLL-ENDS :: <GtkScrollStep> = 2;
define constant $GTK-SCROLL-HORIZONTAL-STEPS :: <GtkScrollStep> = 3;
define constant $GTK-SCROLL-HORIZONTAL-PAGES :: <GtkScrollStep> = 4;
define constant $GTK-SCROLL-HORIZONTAL-ENDS :: <GtkScrollStep> = 5;

define constant <GtkCornerType> = limited(<integer>, min: 0, max: 3);
define constant $GTK-CORNER-TOP-LEFT :: <GtkCornerType> = 0;
define constant $GTK-CORNER-BOTTOM-LEFT :: <GtkCornerType> = 1;
define constant $GTK-CORNER-TOP-RIGHT :: <GtkCornerType> = 2;
define constant $GTK-CORNER-BOTTOM-RIGHT :: <GtkCornerType> = 3;

define constant <GtkPackType> = limited(<integer>, min: 0, max: 1);
define constant $GTK-PACK-START :: <GtkPackType> = 0;
define constant $GTK-PACK-END :: <GtkPackType> = 1;

define constant <GtkPathType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PATH-WIDGET :: <GtkPathType> = 0;
define constant $GTK-PATH-WIDGET-CLASS :: <GtkPathType> = 1;
define constant $GTK-PATH-CLASS :: <GtkPathType> = 2;

define constant <GtkPolicyType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-POLICY-ALWAYS :: <GtkPolicyType> = 0;
define constant $GTK-POLICY-AUTOMATIC :: <GtkPolicyType> = 1;
define constant $GTK-POLICY-NEVER :: <GtkPolicyType> = 2;

define constant <GtkPreviewType> = limited(<integer>, min: 0, max: 1);
define constant $GTK-PREVIEW-COLOR :: <GtkPreviewType> = 0;
define constant $GTK-PREVIEW-GRAYSCALE :: <GtkPreviewType> = 1;

define constant <GtkReliefStyle> = limited(<integer>, min: 0, max: 2);
define constant $GTK-RELIEF-NORMAL :: <GtkReliefStyle> = 0;
define constant $GTK-RELIEF-HALF :: <GtkReliefStyle> = 1;
define constant $GTK-RELIEF-NONE :: <GtkReliefStyle> = 2;

define constant <GtkResizeMode> = limited(<integer>, min: 0, max: 2);
define constant $GTK-RESIZE-PARENT :: <GtkResizeMode> = 0;
define constant $GTK-RESIZE-QUEUE :: <GtkResizeMode> = 1;
define constant $GTK-RESIZE-IMMEDIATE :: <GtkResizeMode> = 2;

define constant <GtkSignalRunType> = limited(<integer>, min: 1, max: 64);
define constant $GTK-RUN-FIRST :: <GtkSignalRunType> = 1;
define constant $GTK-RUN-LAST :: <GtkSignalRunType> = 2;
define constant $GTK-RUN-BOTH :: <GtkSignalRunType> = 3;
define constant $GTK-RUN-NO-RECURSE :: <GtkSignalRunType> = 8;
define constant $GTK-RUN-ACTION :: <GtkSignalRunType> = 32;
define constant $GTK-RUN-NO-HOOKS :: <GtkSignalRunType> = 64;

define constant <GtkScrollType> = limited(<integer>, min: 0, max: 15);
define constant $GTK-SCROLL-NONE :: <GtkScrollType> = 0;
define constant $GTK-SCROLL-JUMP :: <GtkScrollType> = 1;
define constant $GTK-SCROLL-STEP-BACKWARD :: <GtkScrollType> = 2;
define constant $GTK-SCROLL-STEP-FORWARD :: <GtkScrollType> = 3;
define constant $GTK-SCROLL-PAGE-BACKWARD :: <GtkScrollType> = 4;
define constant $GTK-SCROLL-PAGE-FORWARD :: <GtkScrollType> = 5;
define constant $GTK-SCROLL-STEP-UP :: <GtkScrollType> = 6;
define constant $GTK-SCROLL-STEP-DOWN :: <GtkScrollType> = 7;
define constant $GTK-SCROLL-PAGE-UP :: <GtkScrollType> = 8;
define constant $GTK-SCROLL-PAGE-DOWN :: <GtkScrollType> = 9;
define constant $GTK-SCROLL-STEP-LEFT :: <GtkScrollType> = 10;
define constant $GTK-SCROLL-STEP-RIGHT :: <GtkScrollType> = 11;
define constant $GTK-SCROLL-PAGE-LEFT :: <GtkScrollType> = 12;
define constant $GTK-SCROLL-PAGE-RIGHT :: <GtkScrollType> = 13;
define constant $GTK-SCROLL-START :: <GtkScrollType> = 14;
define constant $GTK-SCROLL-END :: <GtkScrollType> = 15;

define constant <GtkSelectionMode> = limited(<integer>, min: 0, max: 3);
define constant $GTK-SELECTION-NONE :: <GtkSelectionMode> = 0;
define constant $GTK-SELECTION-SINGLE :: <GtkSelectionMode> = 1;
define constant $GTK-SELECTION-BROWSE :: <GtkSelectionMode> = 2;
define constant $GTK-SELECTION-MULTIPLE :: <GtkSelectionMode> = 3;
define constant $GTK-SELECTION-EXTENDED :: <GtkSelectionMode> = 3;

define constant <GtkSubmenuDirection> = limited(<integer>, min: 0, max: 1);
define constant $GTK-DIRECTION-LEFT :: <GtkSubmenuDirection> = 0;
define constant $GTK-DIRECTION-RIGHT :: <GtkSubmenuDirection> = 1;

define constant <GtkSubmenuPlacement> = limited(<integer>, min: 0, max: 1);
define constant $GTK-TOP-BOTTOM :: <GtkSubmenuPlacement> = 0;
define constant $GTK-LEFT-RIGHT :: <GtkSubmenuPlacement> = 1;

define constant <GtkToolbarStyle> = limited(<integer>, min: 0, max: 3);
define constant $GTK-TOOLBAR-ICONS :: <GtkToolbarStyle> = 0;
define constant $GTK-TOOLBAR-TEXT :: <GtkToolbarStyle> = 1;
define constant $GTK-TOOLBAR-BOTH :: <GtkToolbarStyle> = 2;
define constant $GTK-TOOLBAR-BOTH-HORIZ :: <GtkToolbarStyle> = 3;

define constant <GtkUpdateType> = limited(<integer>, min: 0, max: 2);
define constant $GTK-UPDATE-CONTINUOUS :: <GtkUpdateType> = 0;
define constant $GTK-UPDATE-DISCONTINUOUS :: <GtkUpdateType> = 1;
define constant $GTK-UPDATE-DELAYED :: <GtkUpdateType> = 2;

define constant <GtkVisibility> = limited(<integer>, min: 0, max: 2);
define constant $GTK-VISIBILITY-NONE :: <GtkVisibility> = 0;
define constant $GTK-VISIBILITY-PARTIAL :: <GtkVisibility> = 1;
define constant $GTK-VISIBILITY-FULL :: <GtkVisibility> = 2;

define constant <GtkWrapMode> = limited(<integer>, min: 0, max: 3);
define constant $GTK-WRAP-NONE :: <GtkWrapMode> = 0;
define constant $GTK-WRAP-CHAR :: <GtkWrapMode> = 1;
define constant $GTK-WRAP-WORD :: <GtkWrapMode> = 2;
define constant $GTK-WRAP-WORD-CHAR :: <GtkWrapMode> = 3;

define constant <GtkSortType> = limited(<integer>, min: 0, max: 1);
define constant $GTK-SORT-ASCENDING :: <GtkSortType> = 0;
define constant $GTK-SORT-DESCENDING :: <GtkSortType> = 1;

define constant <GtkIMPreeditStyle> = limited(<integer>, min: 0, max: 2);
define constant $GTK-IM-PREEDIT-NOTHING :: <GtkIMPreeditStyle> = 0;
define constant $GTK-IM-PREEDIT-CALLBACK :: <GtkIMPreeditStyle> = 1;
define constant $GTK-IM-PREEDIT-NONE :: <GtkIMPreeditStyle> = 2;

define constant <GtkIMStatusStyle> = limited(<integer>, min: 0, max: 2);
define constant $GTK-IM-STATUS-NOTHING :: <GtkIMStatusStyle> = 0;
define constant $GTK-IM-STATUS-CALLBACK :: <GtkIMStatusStyle> = 1;
define constant $GTK-IM-STATUS-NONE :: <GtkIMStatusStyle> = 2;

define constant <GtkPackDirection> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PACK-DIRECTION-LTR :: <GtkPackDirection> = 0;
define constant $GTK-PACK-DIRECTION-RTL :: <GtkPackDirection> = 1;
define constant $GTK-PACK-DIRECTION-TTB :: <GtkPackDirection> = 2;
define constant $GTK-PACK-DIRECTION-BTT :: <GtkPackDirection> = 3;

define constant <GtkPrintPages> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PRINT-PAGES-ALL :: <GtkPrintPages> = 0;
define constant $GTK-PRINT-PAGES-CURRENT :: <GtkPrintPages> = 1;
define constant $GTK-PRINT-PAGES-RANGES :: <GtkPrintPages> = 2;

define constant <GtkPageSet> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PAGE-SET-ALL :: <GtkPageSet> = 0;
define constant $GTK-PAGE-SET-EVEN :: <GtkPageSet> = 1;
define constant $GTK-PAGE-SET-ODD :: <GtkPageSet> = 2;

define constant <GtkPageOrientation> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PAGE-ORIENTATION-PORTRAIT :: <GtkPageOrientation> = 0;
define constant $GTK-PAGE-ORIENTATION-LANDSCAPE :: <GtkPageOrientation> = 1;
define constant $GTK-PAGE-ORIENTATION-REVERSE-PORTRAIT :: <GtkPageOrientation> = 2;
define constant $GTK-PAGE-ORIENTATION-REVERSE-LANDSCAPE :: <GtkPageOrientation> = 3;

define constant <GtkPrintQuality> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PRINT-QUALITY-LOW :: <GtkPrintQuality> = 0;
define constant $GTK-PRINT-QUALITY-NORMAL :: <GtkPrintQuality> = 1;
define constant $GTK-PRINT-QUALITY-HIGH :: <GtkPrintQuality> = 2;
define constant $GTK-PRINT-QUALITY-DRAFT :: <GtkPrintQuality> = 3;

define constant <GtkPrintDuplex> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PRINT-DUPLEX-SIMPLEX :: <GtkPrintDuplex> = 0;
define constant $GTK-PRINT-DUPLEX-HORIZONTAL :: <GtkPrintDuplex> = 1;
define constant $GTK-PRINT-DUPLEX-VERTICAL :: <GtkPrintDuplex> = 2;

define constant <GtkUnit> = limited(<integer>, min: 0, max: 3);
define constant $GTK-UNIT-PIXEL :: <GtkUnit> = 0;
define constant $GTK-UNIT-POINTS :: <GtkUnit> = 1;
define constant $GTK-UNIT-INCH :: <GtkUnit> = 2;
define constant $GTK-UNIT-MM :: <GtkUnit> = 3;

define constant <GtkTreeViewGridLines> = limited(<integer>, min: 0, max: 3);
define constant $GTK-TREE-VIEW-GRID-LINES-NONE :: <GtkTreeViewGridLines> = 0;
define constant $GTK-TREE-VIEW-GRID-LINES-HORIZONTAL :: <GtkTreeViewGridLines> = 1;
define constant $GTK-TREE-VIEW-GRID-LINES-VERTICAL :: <GtkTreeViewGridLines> = 2;
define constant $GTK-TREE-VIEW-GRID-LINES-BOTH :: <GtkTreeViewGridLines> = 3;

define constant $GTK-PATH-PRIO-MASK = 15;

define C-function gdk-parse-args
  input parameter argc :: <gint*>;
  input parameter argv :: <gchar***>;
  c-name: "gdk_parse_args";
end;

define C-function gdk-init
  input parameter argc :: <gint*>;
  input parameter argv :: <gchar***>;
  c-name: "gdk_init";
end;

define C-function gdk-init-check
  input parameter argc :: <gint*>;
  input parameter argv :: <gchar***>;
  result res :: <gboolean>;
  c-name: "gdk_init_check";
end;

define C-function gdk-add-option-entries-libgtk-only
  input parameter group :: <GOptionGroup>;
  c-name: "gdk_add_option_entries_libgtk_only";
end;

define C-function gdk-pre-parse-libgtk-only
  c-name: "gdk_pre_parse_libgtk_only";
end;

define C-function gdk-exit
  input parameter error_code :: <gint>;
  c-name: "gdk_exit";
end;

define C-function gdk-set-locale
  result res :: <c-string>;
  c-name: "gdk_set_locale";
end;

define C-function gdk-get-program-class
  result res :: <c-string>;
  c-name: "gdk_get_program_class";
end;

define C-function gdk-set-program-class
  input parameter program_class :: <c-string>;
  c-name: "gdk_set_program_class";
end;

define C-function gdk-error-trap-push
  c-name: "gdk_error_trap_push";
end;

define C-function gdk-error-trap-pop
  result res :: <gint>;
  c-name: "gdk_error_trap_pop";
end;

define C-function gdk-set-use-xshm
  input parameter use_xshm :: <gboolean>;
  c-name: "gdk_set_use_xshm";
end;

define C-function gdk-get-use-xshm
  result res :: <gboolean>;
  c-name: "gdk_get_use_xshm";
end;

define C-function gdk-get-display
  result res :: <c-string>;
  c-name: "gdk_get_display";
end;

define C-function gdk-get-display-arg-name
  result res :: <c-string>;
  c-name: "gdk_get_display_arg_name";
end;

define constant <GdkInputCondition> = limited(<integer>, min: 1, max: 4);
define constant $GDK-INPUT-READ :: <GdkInputCondition> = 1;
define constant $GDK-INPUT-WRITE :: <GdkInputCondition> = 2;
define constant $GDK-INPUT-EXCEPTION :: <GdkInputCondition> = 4;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2297>"*/
define constant <GdkInputFunction> = <anonymous-2297>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2298>"*/
define constant <GdkDestroyNotify> = <anonymous-2298>;

define C-function gdk-input-add-full
  input parameter source :: <gint>;
  input parameter condition :: <GdkInputCondition>;
  input parameter function :: <GdkInputFunction>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GdkDestroyNotify>;
  result res :: <gint>;
  c-name: "gdk_input_add_full";
end;

define C-function gdk-input-add
  input parameter source :: <gint>;
  input parameter condition :: <GdkInputCondition>;
  input parameter function :: <GdkInputFunction>;
  input parameter data :: <gpointer>;
  result res :: <gint>;
  c-name: "gdk_input_add";
end;

define C-function gdk-input-remove
  input parameter tag :: <gint>;
  c-name: "gdk_input_remove";
end;

define constant <GdkGrabStatus> = limited(<integer>, min: 0, max: 4);
define constant $GDK-GRAB-SUCCESS :: <GdkGrabStatus> = 0;
define constant $GDK-GRAB-ALREADY-GRABBED :: <GdkGrabStatus> = 1;
define constant $GDK-GRAB-INVALID-TIME :: <GdkGrabStatus> = 2;
define constant $GDK-GRAB-NOT-VIEWABLE :: <GdkGrabStatus> = 3;
define constant $GDK-GRAB-FROZEN :: <GdkGrabStatus> = 4;

define constant <GdkEventMask> = limited(<integer>, min: 2, max: 4194302);
define constant $GDK-EXPOSURE-MASK :: <GdkEventMask> = 2;
define constant $GDK-POINTER-MOTION-MASK :: <GdkEventMask> = 4;
define constant $GDK-POINTER-MOTION-HINT-MASK :: <GdkEventMask> = 8;
define constant $GDK-BUTTON-MOTION-MASK :: <GdkEventMask> = 16;
define constant $GDK-BUTTON1-MOTION-MASK :: <GdkEventMask> = 32;
define constant $GDK-BUTTON2-MOTION-MASK :: <GdkEventMask> = 64;
define constant $GDK-BUTTON3-MOTION-MASK :: <GdkEventMask> = 128;
define constant $GDK-BUTTON-PRESS-MASK :: <GdkEventMask> = 256;
define constant $GDK-BUTTON-RELEASE-MASK :: <GdkEventMask> = 512;
define constant $GDK-KEY-PRESS-MASK :: <GdkEventMask> = 1024;
define constant $GDK-KEY-RELEASE-MASK :: <GdkEventMask> = 2048;
define constant $GDK-ENTER-NOTIFY-MASK :: <GdkEventMask> = 4096;
define constant $GDK-LEAVE-NOTIFY-MASK :: <GdkEventMask> = 8192;
define constant $GDK-FOCUS-CHANGE-MASK :: <GdkEventMask> = 16384;
define constant $GDK-STRUCTURE-MASK :: <GdkEventMask> = 32768;
define constant $GDK-PROPERTY-CHANGE-MASK :: <GdkEventMask> = 65536;
define constant $GDK-VISIBILITY-NOTIFY-MASK :: <GdkEventMask> = 131072;
define constant $GDK-PROXIMITY-IN-MASK :: <GdkEventMask> = 262144;
define constant $GDK-PROXIMITY-OUT-MASK :: <GdkEventMask> = 524288;
define constant $GDK-SUBSTRUCTURE-MASK :: <GdkEventMask> = 1048576;
define constant $GDK-SCROLL-MASK :: <GdkEventMask> = 2097152;
define constant $GDK-ALL-EVENTS-MASK :: <GdkEventMask> = 4194302;

define constant <GdkCursorType> = limited(<integer>, min: -1, max: 153);
define constant $GDK-X-CURSOR :: <GdkCursorType> = 0;
define constant $GDK-ARROW :: <GdkCursorType> = 2;
define constant $GDK-BASED-ARROW-DOWN :: <GdkCursorType> = 4;
define constant $GDK-BASED-ARROW-UP :: <GdkCursorType> = 6;
define constant $GDK-BOAT :: <GdkCursorType> = 8;
define constant $GDK-BOGOSITY :: <GdkCursorType> = 10;
define constant $GDK-BOTTOM-LEFT-CORNER :: <GdkCursorType> = 12;
define constant $GDK-BOTTOM-RIGHT-CORNER :: <GdkCursorType> = 14;
define constant $GDK-BOTTOM-SIDE :: <GdkCursorType> = 16;
define constant $GDK-BOTTOM-TEE :: <GdkCursorType> = 18;
define constant $GDK-BOX-SPIRAL :: <GdkCursorType> = 20;
define constant $GDK-CENTER-PTR :: <GdkCursorType> = 22;
define constant $GDK-CIRCLE :: <GdkCursorType> = 24;
define constant $GDK-CLOCK :: <GdkCursorType> = 26;
define constant $GDK-COFFEE-MUG :: <GdkCursorType> = 28;
define constant $GDK-CROSS :: <GdkCursorType> = 30;
define constant $GDK-CROSS-REVERSE :: <GdkCursorType> = 32;
define constant $GDK-CROSSHAIR :: <GdkCursorType> = 34;
define constant $GDK-DIAMOND-CROSS :: <GdkCursorType> = 36;
define constant $GDK-DOT :: <GdkCursorType> = 38;
define constant $GDK-DOTBOX :: <GdkCursorType> = 40;
define constant $GDK-DOUBLE-ARROW :: <GdkCursorType> = 42;
define constant $GDK-DRAFT-LARGE :: <GdkCursorType> = 44;
define constant $GDK-DRAFT-SMALL :: <GdkCursorType> = 46;
define constant $GDK-DRAPED-BOX :: <GdkCursorType> = 48;
define constant $GDK-EXCHANGE :: <GdkCursorType> = 50;
define constant $GDK-FLEUR :: <GdkCursorType> = 52;
define constant $GDK-GOBBLER :: <GdkCursorType> = 54;
define constant $GDK-GUMBY :: <GdkCursorType> = 56;
define constant $GDK-HAND1 :: <GdkCursorType> = 58;
define constant $GDK-HAND2 :: <GdkCursorType> = 60;
define constant $GDK-HEART :: <GdkCursorType> = 62;
define constant $GDK-ICON :: <GdkCursorType> = 64;
define constant $GDK-IRON-CROSS :: <GdkCursorType> = 66;
define constant $GDK-LEFT-PTR :: <GdkCursorType> = 68;
define constant $GDK-LEFT-SIDE :: <GdkCursorType> = 70;
define constant $GDK-LEFT-TEE :: <GdkCursorType> = 72;
define constant $GDK-LEFTBUTTON :: <GdkCursorType> = 74;
define constant $GDK-LL-ANGLE :: <GdkCursorType> = 76;
define constant $GDK-LR-ANGLE :: <GdkCursorType> = 78;
define constant $GDK-MAN :: <GdkCursorType> = 80;
define constant $GDK-MIDDLEBUTTON :: <GdkCursorType> = 82;
define constant $GDK-MOUSE :: <GdkCursorType> = 84;
define constant $GDK-PENCIL :: <GdkCursorType> = 86;
define constant $GDK-PIRATE :: <GdkCursorType> = 88;
define constant $GDK-PLUS :: <GdkCursorType> = 90;
define constant $GDK-QUESTION-ARROW :: <GdkCursorType> = 92;
define constant $GDK-RIGHT-PTR :: <GdkCursorType> = 94;
define constant $GDK-RIGHT-SIDE :: <GdkCursorType> = 96;
define constant $GDK-RIGHT-TEE :: <GdkCursorType> = 98;
define constant $GDK-RIGHTBUTTON :: <GdkCursorType> = 100;
define constant $GDK-RTL-LOGO :: <GdkCursorType> = 102;
define constant $GDK-SAILBOAT :: <GdkCursorType> = 104;
define constant $GDK-SB-DOWN-ARROW :: <GdkCursorType> = 106;
define constant $GDK-SB-H-DOUBLE-ARROW :: <GdkCursorType> = 108;
define constant $GDK-SB-LEFT-ARROW :: <GdkCursorType> = 110;
define constant $GDK-SB-RIGHT-ARROW :: <GdkCursorType> = 112;
define constant $GDK-SB-UP-ARROW :: <GdkCursorType> = 114;
define constant $GDK-SB-V-DOUBLE-ARROW :: <GdkCursorType> = 116;
define constant $GDK-SHUTTLE :: <GdkCursorType> = 118;
define constant $GDK-SIZING :: <GdkCursorType> = 120;
define constant $GDK-SPIDER :: <GdkCursorType> = 122;
define constant $GDK-SPRAYCAN :: <GdkCursorType> = 124;
define constant $GDK-STAR :: <GdkCursorType> = 126;
define constant $GDK-TARGET :: <GdkCursorType> = 128;
define constant $GDK-TCROSS :: <GdkCursorType> = 130;
define constant $GDK-TOP-LEFT-ARROW :: <GdkCursorType> = 132;
define constant $GDK-TOP-LEFT-CORNER :: <GdkCursorType> = 134;
define constant $GDK-TOP-RIGHT-CORNER :: <GdkCursorType> = 136;
define constant $GDK-TOP-SIDE :: <GdkCursorType> = 138;
define constant $GDK-TOP-TEE :: <GdkCursorType> = 140;
define constant $GDK-TREK :: <GdkCursorType> = 142;
define constant $GDK-UL-ANGLE :: <GdkCursorType> = 144;
define constant $GDK-UMBRELLA :: <GdkCursorType> = 146;
define constant $GDK-UR-ANGLE :: <GdkCursorType> = 148;
define constant $GDK-WATCH :: <GdkCursorType> = 150;
define constant $GDK-XTERM :: <GdkCursorType> = 152;
define constant $GDK-LAST-CURSOR :: <GdkCursorType> = 153;
define constant $GDK-CURSOR-IS-PIXMAP :: <GdkCursorType> = -1;

define C-subtype <_GdkCursor> (<C-void*>) end;
define constant <GdkCursor> = <_GdkCursor>;

define C-function gdk-pointer-grab
  input parameter window :: <GdkWindow>;
  input parameter owner_events :: <gboolean>;
  input parameter event_mask :: <GdkEventMask>;
  input parameter confine_to :: <GdkWindow>;
  input parameter cursor :: <GdkCursor>;
  input parameter time_ :: <guint32>;
  result res :: <GdkGrabStatus>;
  c-name: "gdk_pointer_grab";
end;

define C-function gdk-keyboard-grab
  input parameter window :: <GdkWindow>;
  input parameter owner_events :: <gboolean>;
  input parameter time_ :: <guint32>;
  result res :: <GdkGrabStatus>;
  c-name: "gdk_keyboard_grab";
end;

define C-function gdk-pointer-grab-info-libgtk-only
  input parameter display :: <GdkDisplay>;
  input parameter grab_window :: <GdkWindow*>;
  input parameter owner_events :: <gboolean*>;
  result res :: <gboolean>;
  c-name: "gdk_pointer_grab_info_libgtk_only";
end;

define C-function gdk-keyboard-grab-info-libgtk-only
  input parameter display :: <GdkDisplay>;
  input parameter grab_window :: <GdkWindow*>;
  input parameter owner_events :: <gboolean*>;
  result res :: <gboolean>;
  c-name: "gdk_keyboard_grab_info_libgtk_only";
end;

define C-function gdk-pointer-ungrab
  input parameter time_ :: <guint32>;
  c-name: "gdk_pointer_ungrab";
end;

define C-function gdk-keyboard-ungrab
  input parameter time_ :: <guint32>;
  c-name: "gdk_keyboard_ungrab";
end;

define C-function gdk-pointer-is-grabbed
  result res :: <gboolean>;
  c-name: "gdk_pointer_is_grabbed";
end;

define C-function gdk-screen-width
  result res :: <gint>;
  c-name: "gdk_screen_width";
end;

define C-function gdk-screen-height
  result res :: <gint>;
  c-name: "gdk_screen_height";
end;

define C-function gdk-screen-width-mm
  result res :: <gint>;
  c-name: "gdk_screen_width_mm";
end;

define C-function gdk-screen-height-mm
  result res :: <gint>;
  c-name: "gdk_screen_height_mm";
end;

define C-function gdk-beep
  c-name: "gdk_beep";
end;

define C-function gdk-flush
  c-name: "gdk_flush";
end;

define C-function gdk-set-double-click-time
  input parameter msec :: <guint>;
  c-name: "gdk_set_double_click_time";
end;

define C-function gdk-rectangle-intersect
  input parameter src1 :: <GdkRectangle>;
  input parameter src2 :: <GdkRectangle>;
  input parameter dest :: <GdkRectangle>;
  result res :: <gboolean>;
  c-name: "gdk_rectangle_intersect";
end;

define C-function gdk-rectangle-union
  input parameter src1 :: <GdkRectangle>;
  input parameter src2 :: <GdkRectangle>;
  input parameter dest :: <GdkRectangle>;
  c-name: "gdk_rectangle_union";
end;

define C-function gdk-rectangle-get-type
  result res :: <GType>;
  c-name: "gdk_rectangle_get_type";
end;

define constant <GdkWChar> = <guint32>;

define C-pointer-type <GdkWChar*> => <GdkWChar>;
define C-function gdk-wcstombs
  input parameter src :: <GdkWChar*>;
  result res :: <c-string>;
  c-name: "gdk_wcstombs";
end;

define C-function gdk-mbstowcs
  input parameter dest :: <GdkWChar*>;
  input parameter src :: <c-string>;
  input parameter dest_max :: <gint>;
  result res :: <gint>;
  c-name: "gdk_mbstowcs";
end;

define C-function gdk-event-send-client-message
  input parameter event :: <GdkEvent>;
  input parameter winid :: <GdkNativeWindow>;
  result res :: <gboolean>;
  c-name: "gdk_event_send_client_message";
end;

define C-function gdk-event-send-clientmessage-toall
  input parameter event :: <GdkEvent>;
  c-name: "gdk_event_send_clientmessage_toall";
end;

define C-function gdk-event-send-client-message-for-display
  input parameter display :: <GdkDisplay>;
  input parameter event :: <GdkEvent>;
  input parameter winid :: <GdkNativeWindow>;
  result res :: <gboolean>;
  c-name: "gdk_event_send_client_message_for_display";
end;

define C-function gdk-notify-startup-complete
  c-name: "gdk_notify_startup_complete";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-threads-mutex"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-threads-lock"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-threads-unlock"*/
define C-function gdk-threads-enter
  c-name: "gdk_threads_enter";
end;

define C-function gdk-threads-leave
  c-name: "gdk_threads_leave";
end;

define C-function gdk-threads-init
  c-name: "gdk_threads_init";
end;

define C-function gdk-threads-set-lock-functions
  input parameter enter_fn :: <GCallback>;
  input parameter leave_fn :: <GCallback>;
  c-name: "gdk_threads_set_lock_functions";
end;

define constant $GDK-PRIORITY-EVENTS = 0;

define constant <GdkWindowClass> = limited(<integer>, min: 0, max: 1);
define constant $GDK-INPUT-OUTPUT :: <GdkWindowClass> = 0;
define constant $GDK-INPUT-ONLY :: <GdkWindowClass> = 1;

define constant <GdkWindowType> = limited(<integer>, min: 0, max: 5);
define constant $GDK-WINDOW-ROOT :: <GdkWindowType> = 0;
define constant $GDK-WINDOW-TOPLEVEL :: <GdkWindowType> = 1;
define constant $GDK-WINDOW-CHILD :: <GdkWindowType> = 2;
define constant $GDK-WINDOW-DIALOG :: <GdkWindowType> = 3;
define constant $GDK-WINDOW-TEMP :: <GdkWindowType> = 4;
define constant $GDK-WINDOW-FOREIGN :: <GdkWindowType> = 5;

define C-subtype <_GdkWindowAttr> (<C-void*>) end;
define constant <GdkWindowAttr> = <_GdkWindowAttr>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2978>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2979>"*/
define C-subtype <_GdkPointerHooks> (<C-void*>) end;
define constant <GdkPointerHooks> = <_GdkPointerHooks>;

define constant <GdkWindowAttributesType> = limited(<integer>, min: 2, max: 256);
define constant $GDK-WA-TITLE :: <GdkWindowAttributesType> = 2;
define constant $GDK-WA-X :: <GdkWindowAttributesType> = 4;
define constant $GDK-WA-Y :: <GdkWindowAttributesType> = 8;
define constant $GDK-WA-CURSOR :: <GdkWindowAttributesType> = 16;
define constant $GDK-WA-COLORMAP :: <GdkWindowAttributesType> = 32;
define constant $GDK-WA-VISUAL :: <GdkWindowAttributesType> = 64;
define constant $GDK-WA-WMCLASS :: <GdkWindowAttributesType> = 128;
define constant $GDK-WA-NOREDIR :: <GdkWindowAttributesType> = 256;

define constant <GdkWMDecoration> = limited(<integer>, min: 1, max: 64);
define constant $GDK-DECOR-ALL :: <GdkWMDecoration> = 1;
define constant $GDK-DECOR-BORDER :: <GdkWMDecoration> = 2;
define constant $GDK-DECOR-RESIZEH :: <GdkWMDecoration> = 4;
define constant $GDK-DECOR-TITLE :: <GdkWMDecoration> = 8;
define constant $GDK-DECOR-MENU :: <GdkWMDecoration> = 16;
define constant $GDK-DECOR-MINIMIZE :: <GdkWMDecoration> = 32;
define constant $GDK-DECOR-MAXIMIZE :: <GdkWMDecoration> = 64;

define constant <GdkWMFunction> = limited(<integer>, min: 1, max: 32);
define constant $GDK-FUNC-ALL :: <GdkWMFunction> = 1;
define constant $GDK-FUNC-RESIZE :: <GdkWMFunction> = 2;
define constant $GDK-FUNC-MOVE :: <GdkWMFunction> = 4;
define constant $GDK-FUNC-MINIMIZE :: <GdkWMFunction> = 8;
define constant $GDK-FUNC-MAXIMIZE :: <GdkWMFunction> = 16;
define constant $GDK-FUNC-CLOSE :: <GdkWMFunction> = 32;

define constant <GdkWindowObject> = <_GdkWindowObject>;

define C-subtype <_GdkWindowObject> (<C-void*>) end;
define constant <GdkFunction> = limited(<integer>, min: 0, max: 15);
define constant $GDK-COPY :: <GdkFunction> = 0;
define constant $GDK-INVERT :: <GdkFunction> = 1;
define constant $GDK-XOR :: <GdkFunction> = 2;
define constant $GDK-CLEAR :: <GdkFunction> = 3;
define constant $GDK-AND :: <GdkFunction> = 4;
define constant $GDK-AND-REVERSE :: <GdkFunction> = 5;
define constant $GDK-AND-INVERT :: <GdkFunction> = 6;
define constant $GDK-NOOP :: <GdkFunction> = 7;
define constant $GDK-OR :: <GdkFunction> = 8;
define constant $GDK-EQUIV :: <GdkFunction> = 9;
define constant $GDK-OR-REVERSE :: <GdkFunction> = 10;
define constant $GDK-COPY-INVERT :: <GdkFunction> = 11;
define constant $GDK-OR-INVERT :: <GdkFunction> = 12;
define constant $GDK-NAND :: <GdkFunction> = 13;
define constant $GDK-NOR :: <GdkFunction> = 14;
define constant $GDK-SET :: <GdkFunction> = 15;

define constant <GdkFill> = limited(<integer>, min: 0, max: 3);
define constant $GDK-SOLID :: <GdkFill> = 0;
define constant $GDK-TILED :: <GdkFill> = 1;
define constant $GDK-STIPPLED :: <GdkFill> = 2;
define constant $GDK-OPAQUE-STIPPLED :: <GdkFill> = 3;

define constant <GdkSubwindowMode> = limited(<integer>, min: 0, max: 1);
define constant $GDK-CLIP-BY-CHILDREN :: <GdkSubwindowMode> = 0;
define constant $GDK-INCLUDE-INFERIORS :: <GdkSubwindowMode> = 1;

define constant <GdkLineStyle> = limited(<integer>, min: 0, max: 2);
define constant $GDK-LINE-SOLID :: <GdkLineStyle> = 0;
define constant $GDK-LINE-ON-OFF-DASH :: <GdkLineStyle> = 1;
define constant $GDK-LINE-DOUBLE-DASH :: <GdkLineStyle> = 2;

define constant <GdkCapStyle> = limited(<integer>, min: 0, max: 3);
define constant $GDK-CAP-NOT-LAST :: <GdkCapStyle> = 0;
define constant $GDK-CAP-BUTT :: <GdkCapStyle> = 1;
define constant $GDK-CAP-ROUND :: <GdkCapStyle> = 2;
define constant $GDK-CAP-PROJECTING :: <GdkCapStyle> = 3;

define constant <GdkJoinStyle> = limited(<integer>, min: 0, max: 2);
define constant $GDK-JOIN-MITER :: <GdkJoinStyle> = 0;
define constant $GDK-JOIN-ROUND :: <GdkJoinStyle> = 1;
define constant $GDK-JOIN-BEVEL :: <GdkJoinStyle> = 2;

define C-subtype <_GdkGCValues> (<C-void*>) end;
define constant <GdkGCValues> = <_GdkGCValues>;

define constant <GdkGCValuesMask> = limited(<integer>, min: 1, max: 131072);
define constant $GDK-GC-FOREGROUND :: <GdkGCValuesMask> = 1;
define constant $GDK-GC-BACKGROUND :: <GdkGCValuesMask> = 2;
define constant $GDK-GC-FONT :: <GdkGCValuesMask> = 4;
define constant $GDK-GC-FUNCTION :: <GdkGCValuesMask> = 8;
define constant $GDK-GC-FILL :: <GdkGCValuesMask> = 16;
define constant $GDK-GC-TILE :: <GdkGCValuesMask> = 32;
define constant $GDK-GC-STIPPLE :: <GdkGCValuesMask> = 64;
define constant $GDK-GC-CLIP-MASK :: <GdkGCValuesMask> = 128;
define constant $GDK-GC-SUBWINDOW :: <GdkGCValuesMask> = 256;
define constant $GDK-GC-TS-X-ORIGIN :: <GdkGCValuesMask> = 512;
define constant $GDK-GC-TS-Y-ORIGIN :: <GdkGCValuesMask> = 1024;
define constant $GDK-GC-CLIP-X-ORIGIN :: <GdkGCValuesMask> = 2048;
define constant $GDK-GC-CLIP-Y-ORIGIN :: <GdkGCValuesMask> = 4096;
define constant $GDK-GC-EXPOSURES :: <GdkGCValuesMask> = 8192;
define constant $GDK-GC-LINE-WIDTH :: <GdkGCValuesMask> = 16384;
define constant $GDK-GC-LINE-STYLE :: <GdkGCValuesMask> = 32768;
define constant $GDK-GC-CAP-STYLE :: <GdkGCValuesMask> = 65536;
define constant $GDK-GC-JOIN-STYLE :: <GdkGCValuesMask> = 131072;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2658>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2659>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2660>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2661>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2662>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2663>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2664>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2665>"*/
define C-subtype <_GdkSegment> (<C-void*>) end;
define constant <GdkSegment> = <_GdkSegment>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2666>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2667>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2668>"*/
define constant <GdkImageType> = limited(<integer>, min: 0, max: 2);
define constant $GDK-IMAGE-NORMAL :: <GdkImageType> = 0;
define constant $GDK-IMAGE-SHARED :: <GdkImageType> = 1;
define constant $GDK-IMAGE-FASTEST :: <GdkImageType> = 2;

define C-subtype <_GdkImage> (<C-void*>) end;
define constant <GdkImage> = <_GdkImage>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2669>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2670>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2671>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2672>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2673>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2674>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2675>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2676>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2677>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2678>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2679>"*/
define constant <GdkRgbDither> = limited(<integer>, min: 0, max: 2);
define constant $GDK-RGB-DITHER-NONE :: <GdkRgbDither> = 0;
define constant $GDK-RGB-DITHER-NORMAL :: <GdkRgbDither> = 1;
define constant $GDK-RGB-DITHER-MAX :: <GdkRgbDither> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2680>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2681>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2682>"*/
define C-subtype <_GdkTrapezoid> (<C-void*>) end;
define constant <GdkTrapezoid> = <_GdkTrapezoid>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2683>"*/
define C-subtype <_cairo-surface> (<C-void*>) end;
define constant <cairo-surface-t> = <_cairo-surface>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2684>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2685>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2686>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2687>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2688>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2689>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2690>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2691>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2692>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2693>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2694>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2695>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2696>"*/
define C-subtype <_GdkDrawableClass> (<C-void*>) end;
define constant <GdkDrawableClass> = <_GdkDrawableClass>;

define C-subtype <_GdkWindowObjectClass> (<C-void*>) end;
define constant <GdkWindowObjectClass> = <_GdkWindowObjectClass>;

define C-function gdk-window-object-get-type
  result res :: <GType>;
  c-name: "gdk_window_object_get_type";
end;

define C-function gdk-window-new
  input parameter parent :: <GdkWindow>;
  input parameter attributes :: <GdkWindowAttr>;
  input parameter attributes_mask :: <gint>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_new";
end;

define C-function gdk-window-destroy
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_destroy";
end;

define C-function gdk-window-get-window-type
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindowType>;
  c-name: "gdk_window_get_window_type";
end;

define C-function gdk-window-at-pointer
  input parameter win_x :: <gint*>;
  input parameter win_y :: <gint*>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_at_pointer";
end;

define C-function gdk-window-show
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_show";
end;

define C-function gdk-window-hide
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_hide";
end;

define C-function gdk-window-withdraw
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_withdraw";
end;

define C-function gdk-window-show-unraised
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_show_unraised";
end;

define C-function gdk-window-move
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_window_move";
end;

define C-function gdk-window-resize
  input parameter window :: <GdkWindow>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_window_resize";
end;

define C-function gdk-window-move-resize
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_window_move_resize";
end;

define C-function gdk-window-reparent
  input parameter window :: <GdkWindow>;
  input parameter new_parent :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_window_reparent";
end;

define C-function gdk-window-clear
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_clear";
end;

define C-function gdk-window-clear-area
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_window_clear_area";
end;

define C-function gdk-window-clear-area-e
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_window_clear_area_e";
end;

define C-function gdk-window-raise
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_raise";
end;

define C-function gdk-window-lower
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_lower";
end;

define C-function gdk-window-focus
  input parameter window :: <GdkWindow>;
  input parameter timestamp :: <guint32>;
  c-name: "gdk_window_focus";
end;

define C-function gdk-window-set-user-data
  input parameter window :: <GdkWindow>;
  input parameter user_data :: <gpointer>;
  c-name: "gdk_window_set_user_data";
end;

define C-function gdk-window-set-override-redirect
  input parameter window :: <GdkWindow>;
  input parameter override_redirect :: <gboolean>;
  c-name: "gdk_window_set_override_redirect";
end;

define C-function gdk-window-set-accept-focus
  input parameter window :: <GdkWindow>;
  input parameter accept_focus :: <gboolean>;
  c-name: "gdk_window_set_accept_focus";
end;

define C-function gdk-window-set-focus-on-map
  input parameter window :: <GdkWindow>;
  input parameter focus_on_map :: <gboolean>;
  c-name: "gdk_window_set_focus_on_map";
end;

define constant <GdkFilterReturn> = limited(<integer>, min: 0, max: 2);
define constant $GDK-FILTER-CONTINUE :: <GdkFilterReturn> = 0;
define constant $GDK-FILTER-TRANSLATE :: <GdkFilterReturn> = 1;
define constant $GDK-FILTER-REMOVE :: <GdkFilterReturn> = 2;

define constant <GdkXEvent> = <void>;

define C-pointer-type <GdkXEvent*> => <GdkXEvent>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2533>"*/
define constant <GdkFilterFunc> = <anonymous-2533>;

define C-function gdk-window-add-filter
  input parameter window :: <GdkWindow>;
  input parameter function :: <GdkFilterFunc>;
  input parameter data :: <gpointer>;
  c-name: "gdk_window_add_filter";
end;

define C-function gdk-window-remove-filter
  input parameter window :: <GdkWindow>;
  input parameter function :: <GdkFilterFunc>;
  input parameter data :: <gpointer>;
  c-name: "gdk_window_remove_filter";
end;

define C-function gdk-window-scroll
  input parameter window :: <GdkWindow>;
  input parameter dx :: <gint>;
  input parameter dy :: <gint>;
  c-name: "gdk_window_scroll";
end;

define C-function gdk-window-move-region
  input parameter window :: <GdkWindow>;
  input parameter region :: <GdkRegion>;
  input parameter dx :: <gint>;
  input parameter dy :: <gint>;
  c-name: "gdk_window_move_region";
end;

define C-function gdk-window-shape-combine-mask
  input parameter window :: <GdkWindow>;
  input parameter mask :: <GdkBitmap>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_window_shape_combine_mask";
end;

define C-function gdk-window-shape-combine-region
  input parameter window :: <GdkWindow>;
  input parameter shape_region :: <GdkRegion>;
  input parameter offset_x :: <gint>;
  input parameter offset_y :: <gint>;
  c-name: "gdk_window_shape_combine_region";
end;

define C-function gdk-window-set-child-shapes
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_set_child_shapes";
end;

define C-function gdk-window-merge-child-shapes
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_merge_child_shapes";
end;

define C-function gdk-window-input-shape-combine-mask
  input parameter window :: <GdkWindow>;
  input parameter mask :: <GdkBitmap>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_window_input_shape_combine_mask";
end;

define C-function gdk-window-input-shape-combine-region
  input parameter window :: <GdkWindow>;
  input parameter shape_region :: <GdkRegion>;
  input parameter offset_x :: <gint>;
  input parameter offset_y :: <gint>;
  c-name: "gdk_window_input_shape_combine_region";
end;

define C-function gdk-window-set-child-input-shapes
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_set_child_input_shapes";
end;

define C-function gdk-window-merge-child-input-shapes
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_merge_child_input_shapes";
end;

define C-function gdk-window-is-visible
  input parameter window :: <GdkWindow>;
  result res :: <gboolean>;
  c-name: "gdk_window_is_visible";
end;

define C-function gdk-window-is-viewable
  input parameter window :: <GdkWindow>;
  result res :: <gboolean>;
  c-name: "gdk_window_is_viewable";
end;

define C-function gdk-window-get-state
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindowState>;
  c-name: "gdk_window_get_state";
end;

define C-function gdk-window-set-static-gravities
  input parameter window :: <GdkWindow>;
  input parameter use_static :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gdk_window_set_static_gravities";
end;

define C-function gdk-window-foreign-new
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_foreign_new";
end;

define C-function gdk-window-lookup
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_lookup";
end;

define C-function gdk-window-foreign-new-for-display
  input parameter display :: <GdkDisplay>;
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_foreign_new_for_display";
end;

define C-function gdk-window-lookup-for-display
  input parameter display :: <GdkDisplay>;
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_lookup_for_display";
end;

define C-function gdk-window-set-hints
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter min_width :: <gint>;
  input parameter min_height :: <gint>;
  input parameter max_width :: <gint>;
  input parameter max_height :: <gint>;
  input parameter flags :: <gint>;
  c-name: "gdk_window_set_hints";
end;

define C-function gdk-window-set-type-hint
  input parameter window :: <GdkWindow>;
  input parameter hint :: <GdkWindowTypeHint>;
  c-name: "gdk_window_set_type_hint";
end;

define C-function gdk-window-get-type-hint
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindowTypeHint>;
  c-name: "gdk_window_get_type_hint";
end;

define C-function gdk-window-set-modal-hint
  input parameter window :: <GdkWindow>;
  input parameter modal :: <gboolean>;
  c-name: "gdk_window_set_modal_hint";
end;

define C-function gdk-window-set-skip-taskbar-hint
  input parameter window :: <GdkWindow>;
  input parameter skips_taskbar :: <gboolean>;
  c-name: "gdk_window_set_skip_taskbar_hint";
end;

define C-function gdk-window-set-skip-pager-hint
  input parameter window :: <GdkWindow>;
  input parameter skips_pager :: <gboolean>;
  c-name: "gdk_window_set_skip_pager_hint";
end;

define C-function gdk-window-set-urgency-hint
  input parameter window :: <GdkWindow>;
  input parameter urgent :: <gboolean>;
  c-name: "gdk_window_set_urgency_hint";
end;

define C-function gdk-window-set-geometry-hints
  input parameter window :: <GdkWindow>;
  input parameter geometry :: <GdkGeometry>;
  input parameter geom_mask :: <GdkWindowHints>;
  c-name: "gdk_window_set_geometry_hints";
end;

define C-function gdk-set-sm-client-id
  input parameter sm_client_id :: <c-string>;
  c-name: "gdk_set_sm_client_id";
end;

define C-function gdk-window-begin-paint-rect
  input parameter window :: <GdkWindow>;
  input parameter rectangle :: <GdkRectangle>;
  c-name: "gdk_window_begin_paint_rect";
end;

define C-function gdk-window-begin-paint-region
  input parameter window :: <GdkWindow>;
  input parameter region :: <GdkRegion>;
  c-name: "gdk_window_begin_paint_region";
end;

define C-function gdk-window-end-paint
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_end_paint";
end;

define C-function gdk-window-set-title
  input parameter window :: <GdkWindow>;
  input parameter title :: <c-string>;
  c-name: "gdk_window_set_title";
end;

define C-function gdk-window-set-role
  input parameter window :: <GdkWindow>;
  input parameter role :: <c-string>;
  c-name: "gdk_window_set_role";
end;

define C-function gdk-window-set-transient-for
  input parameter window :: <GdkWindow>;
  input parameter parent :: <GdkWindow>;
  c-name: "gdk_window_set_transient_for";
end;

define C-function gdk-window-set-background
  input parameter window :: <GdkWindow>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_window_set_background";
end;

define C-function gdk-window-set-back-pixmap
  input parameter window :: <GdkWindow>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter parent_relative :: <gboolean>;
  c-name: "gdk_window_set_back_pixmap";
end;

define C-function gdk-window-set-cursor
  input parameter window :: <GdkWindow>;
  input parameter cursor :: <GdkCursor>;
  c-name: "gdk_window_set_cursor";
end;

define C-function gdk-window-get-user-data
  input parameter window :: <GdkWindow>;
  input parameter data :: <gpointer*>;
  c-name: "gdk_window_get_user_data";
end;

define C-function gdk-window-get-geometry
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  input parameter depth :: <gint*>;
  c-name: "gdk_window_get_geometry";
end;

define C-function gdk-window-get-position
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gdk_window_get_position";
end;

define C-function gdk-window-get-origin
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  result res :: <gint>;
  c-name: "gdk_window_get_origin";
end;

define C-function gdk-window-get-deskrelative-origin
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_window_get_deskrelative_origin";
end;

define C-function gdk-window-get-root-origin
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gdk_window_get_root_origin";
end;

define C-function gdk-window-get-frame-extents
  input parameter window :: <GdkWindow>;
  input parameter rect :: <GdkRectangle>;
  c-name: "gdk_window_get_frame_extents";
end;

define C-function gdk-window-get-pointer
  input parameter window :: <GdkWindow>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter mask :: <GdkModifierType*>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_get_pointer";
end;

define C-function gdk-window-get-parent
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_get_parent";
end;

define C-function gdk-window-get-toplevel
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_get_toplevel";
end;

define C-function gdk-window-get-children
  input parameter window :: <GdkWindow>;
  result res :: <GList>;
  c-name: "gdk_window_get_children";
end;

define C-function gdk-window-peek-children
  input parameter window :: <GdkWindow>;
  result res :: <GList>;
  c-name: "gdk_window_peek_children";
end;

define C-function gdk-window-get-events
  input parameter window :: <GdkWindow>;
  result res :: <GdkEventMask>;
  c-name: "gdk_window_get_events";
end;

define C-function gdk-window-set-events
  input parameter window :: <GdkWindow>;
  input parameter event_mask :: <GdkEventMask>;
  c-name: "gdk_window_set_events";
end;

define C-function gdk-window-set-icon-list
  input parameter window :: <GdkWindow>;
  input parameter pixbufs :: <GList>;
  c-name: "gdk_window_set_icon_list";
end;

define C-function gdk-window-set-icon
  input parameter window :: <GdkWindow>;
  input parameter icon_window :: <GdkWindow>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gdk_window_set_icon";
end;

define C-function gdk-window-set-icon-name
  input parameter window :: <GdkWindow>;
  input parameter name :: <c-string>;
  c-name: "gdk_window_set_icon_name";
end;

define C-function gdk-window-set-group
  input parameter window :: <GdkWindow>;
  input parameter leader :: <GdkWindow>;
  c-name: "gdk_window_set_group";
end;

define C-function gdk-window-get-group
  input parameter window :: <GdkWindow>;
  result res :: <GdkWindow>;
  c-name: "gdk_window_get_group";
end;

define C-function gdk-window-set-decorations
  input parameter window :: <GdkWindow>;
  input parameter decorations :: <GdkWMDecoration>;
  c-name: "gdk_window_set_decorations";
end;

define C-pointer-type <GdkWMDecoration*> => <GdkWMDecoration>;
define C-function gdk-window-get-decorations
  input parameter window :: <GdkWindow>;
  input parameter decorations :: <GdkWMDecoration*>;
  result res :: <gboolean>;
  c-name: "gdk_window_get_decorations";
end;

define C-function gdk-window-set-functions
  input parameter window :: <GdkWindow>;
  input parameter functions :: <GdkWMFunction>;
  c-name: "gdk_window_set_functions";
end;

define C-function gdk-window-get-toplevels
  result res :: <GList>;
  c-name: "gdk_window_get_toplevels";
end;

define C-function gdk-window-iconify
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_iconify";
end;

define C-function gdk-window-deiconify
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_deiconify";
end;

define C-function gdk-window-stick
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_stick";
end;

define C-function gdk-window-unstick
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_unstick";
end;

define C-function gdk-window-maximize
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_maximize";
end;

define C-function gdk-window-unmaximize
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_unmaximize";
end;

define C-function gdk-window-fullscreen
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_fullscreen";
end;

define C-function gdk-window-unfullscreen
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_unfullscreen";
end;

define C-function gdk-window-set-keep-above
  input parameter window :: <GdkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gdk_window_set_keep_above";
end;

define C-function gdk-window-set-keep-below
  input parameter window :: <GdkWindow>;
  input parameter setting :: <gboolean>;
  c-name: "gdk_window_set_keep_below";
end;

define C-function gdk-window-register-dnd
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_register_dnd";
end;

define C-function gdk-window-begin-resize-drag
  input parameter window :: <GdkWindow>;
  input parameter edge :: <GdkWindowEdge>;
  input parameter button :: <gint>;
  input parameter root_x :: <gint>;
  input parameter root_y :: <gint>;
  input parameter timestamp :: <guint32>;
  c-name: "gdk_window_begin_resize_drag";
end;

define C-function gdk-window-begin-move-drag
  input parameter window :: <GdkWindow>;
  input parameter button :: <gint>;
  input parameter root_x :: <gint>;
  input parameter root_y :: <gint>;
  input parameter timestamp :: <guint32>;
  c-name: "gdk_window_begin_move_drag";
end;

define C-function gdk-window-invalidate-rect
  input parameter window :: <GdkWindow>;
  input parameter rect :: <GdkRectangle>;
  input parameter invalidate_children :: <gboolean>;
  c-name: "gdk_window_invalidate_rect";
end;

define C-function gdk-window-invalidate-region
  input parameter window :: <GdkWindow>;
  input parameter region :: <GdkRegion>;
  input parameter invalidate_children :: <gboolean>;
  c-name: "gdk_window_invalidate_region";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3086>"*/
define C-function gdk-window-invalidate-maybe-recurse
  input parameter window :: <GdkWindow>;
  input parameter region :: <GdkRegion>;
  input parameter child_func :: <anonymous-3086>;
  input parameter user_data :: <gpointer>;
  c-name: "gdk_window_invalidate_maybe_recurse";
end;

define C-function gdk-window-get-update-area
  input parameter window :: <GdkWindow>;
  result res :: <GdkRegion>;
  c-name: "gdk_window_get_update_area";
end;

define C-function gdk-window-freeze-updates
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_freeze_updates";
end;

define C-function gdk-window-thaw-updates
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_thaw_updates";
end;

define C-function gdk-window-process-all-updates
  c-name: "gdk_window_process_all_updates";
end;

define C-function gdk-window-process-updates
  input parameter window :: <GdkWindow>;
  input parameter update_children :: <gboolean>;
  c-name: "gdk_window_process_updates";
end;

define C-function gdk-window-set-debug-updates
  input parameter setting :: <gboolean>;
  c-name: "gdk_window_set_debug_updates";
end;

define C-function gdk-window-constrain-size
  input parameter geometry :: <GdkGeometry>;
  input parameter flags :: <guint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter new_width :: <gint*>;
  input parameter new_height :: <gint*>;
  c-name: "gdk_window_constrain_size";
end;

define C-pointer-type <GdkDrawable*> => <GdkDrawable>;
define C-function gdk-window-get-internal-paint-info
  input parameter window :: <GdkWindow>;
  input parameter real_drawable :: <GdkDrawable*>;
  input parameter x_offset :: <gint*>;
  input parameter y_offset :: <gint*>;
  c-name: "gdk_window_get_internal_paint_info";
end;

define C-function gdk-window-enable-synchronized-configure
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_enable_synchronized_configure";
end;

define C-function gdk-window-configure-finished
  input parameter window :: <GdkWindow>;
  c-name: "gdk_window_configure_finished";
end;

define C-function gdk-set-pointer-hooks
  input parameter new_hooks :: <GdkPointerHooks>;
  result res :: <GdkPointerHooks>;
  c-name: "gdk_set_pointer_hooks";
end;

define C-function gdk-get-default-root-window
  result res :: <GdkWindow>;
  c-name: "gdk_get_default_root_window";
end;

define C-function gdk-drawable-get-size
  input parameter drawable :: <GdkDrawable>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gdk_drawable_get_size";
end;

define constant gdk-window-get-size = gdk-drawable-get-size;

define constant gdk-window-get-type = gdk-window-get-window-type;

define C-function gdk-drawable-get-colormap
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkColormap>;
  c-name: "gdk_drawable_get_colormap";
end;

define constant gdk-window-get-colormap = gdk-drawable-get-colormap;

define C-function gdk-drawable-set-colormap
  input parameter drawable :: <GdkDrawable>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gdk_drawable_set_colormap";
end;

define constant gdk-window-set-colormap = gdk-drawable-set-colormap;

define C-function gdk-drawable-get-visual
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkVisual>;
  c-name: "gdk_drawable_get_visual";
end;

define constant gdk-window-get-visual = gdk-drawable-get-visual;

define C-function gdk-drawable-ref
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkDrawable>;
  c-name: "gdk_drawable_ref";
end;

define constant gdk-window-ref = gdk-drawable-ref;

define C-function gdk-drawable-unref
  input parameter drawable :: <GdkDrawable>;
  c-name: "gdk_drawable_unref";
end;

define constant gdk-window-unref = gdk-drawable-unref;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2531>"*/
define constant <GdkEventFunc> = <anonymous-2531>;

define constant <GdkPropertyState> = limited(<integer>, min: 0, max: 1);
define constant $GDK-PROPERTY-NEW-VALUE :: <GdkPropertyState> = 0;
define constant $GDK-PROPERTY-DELETE :: <GdkPropertyState> = 1;

define C-function gdk-event-get-type
  result res :: <GType>;
  c-name: "gdk_event_get_type";
end;

define C-function gdk-events-pending
  result res :: <gboolean>;
  c-name: "gdk_events_pending";
end;

define C-function gdk-event-get
  result res :: <GdkEvent>;
  c-name: "gdk_event_get";
end;

define C-function gdk-event-peek
  result res :: <GdkEvent>;
  c-name: "gdk_event_peek";
end;

define C-function gdk-event-get-graphics-expose
  input parameter window :: <GdkWindow>;
  result res :: <GdkEvent>;
  c-name: "gdk_event_get_graphics_expose";
end;

define C-function gdk-event-put
  input parameter event :: <GdkEvent>;
  c-name: "gdk_event_put";
end;

define C-function gdk-event-new
  input parameter type :: <GdkEventType>;
  result res :: <GdkEvent>;
  c-name: "gdk_event_new";
end;

define C-function gdk-event-copy
  input parameter event :: <GdkEvent>;
  result res :: <GdkEvent>;
  c-name: "gdk_event_copy";
end;

define C-function gdk-event-free
  input parameter event :: <GdkEvent>;
  c-name: "gdk_event_free";
end;

define C-function gdk-event-get-time
  input parameter event :: <GdkEvent>;
  result res :: <guint32>;
  c-name: "gdk_event_get_time";
end;

define C-function gdk-event-get-state
  input parameter event :: <GdkEvent>;
  input parameter state :: <GdkModifierType*>;
  result res :: <gboolean>;
  c-name: "gdk_event_get_state";
end;

define C-function gdk-event-get-coords
  input parameter event :: <GdkEvent>;
  input parameter x_win :: <gdouble*>;
  input parameter y_win :: <gdouble*>;
  result res :: <gboolean>;
  c-name: "gdk_event_get_coords";
end;

define C-function gdk-event-get-root-coords
  input parameter event :: <GdkEvent>;
  input parameter x_root :: <gdouble*>;
  input parameter y_root :: <gdouble*>;
  result res :: <gboolean>;
  c-name: "gdk_event_get_root_coords";
end;

define C-function gdk-event-get-axis
  input parameter event :: <GdkEvent>;
  input parameter axis_use :: <GdkAxisUse>;
  input parameter value :: <gdouble*>;
  result res :: <gboolean>;
  c-name: "gdk_event_get_axis";
end;

define C-function gdk-event-handler-set
  input parameter func :: <GdkEventFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  c-name: "gdk_event_handler_set";
end;

define C-function gdk-event-set-screen
  input parameter event :: <GdkEvent>;
  input parameter screen :: <GdkScreen>;
  c-name: "gdk_event_set_screen";
end;

define C-function gdk-event-get-screen
  input parameter event :: <GdkEvent>;
  result res :: <GdkScreen>;
  c-name: "gdk_event_get_screen";
end;

define C-function gdk-set-show-events
  input parameter show_events :: <gboolean>;
  c-name: "gdk_set_show_events";
end;

define C-function gdk-get-show-events
  result res :: <gboolean>;
  c-name: "gdk_get_show_events";
end;

define C-function gdk-add-client-message-filter
  input parameter message_type :: <GdkAtom>;
  input parameter func :: <GdkFilterFunc>;
  input parameter data :: <gpointer>;
  c-name: "gdk_add_client_message_filter";
end;

define C-function gdk-setting-get
  input parameter name :: <c-string>;
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gdk_setting_get";
end;

define constant $GDK-PRIORITY-REDRAW = 120;

define C-subtype <_GdkDeviceClass> (<C-void*>) end;
define constant <GdkDeviceClass> = <_GdkDeviceClass>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gdouble<@128>>"*/
define C-subtype <_GdkTimeCoord> (<C-void*>) end;
define constant <GdkTimeCoord> = <_GdkTimeCoord>;

define C-function gdk-device-get-type
  result res :: <GType>;
  c-name: "gdk_device_get_type";
end;

define C-function gdk-devices-list
  result res :: <GList>;
  c-name: "gdk_devices_list";
end;

define C-function gdk-device-set-source
  input parameter device :: <GdkDevice>;
  input parameter source :: <GdkInputSource>;
  c-name: "gdk_device_set_source";
end;

define C-function gdk-device-set-mode
  input parameter device :: <GdkDevice>;
  input parameter mode :: <GdkInputMode>;
  result res :: <gboolean>;
  c-name: "gdk_device_set_mode";
end;

define C-function gdk-device-set-key
  input parameter device :: <GdkDevice>;
  input parameter index_ :: <guint>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  c-name: "gdk_device_set_key";
end;

define C-function gdk-device-set-axis-use
  input parameter device :: <GdkDevice>;
  input parameter index_ :: <guint>;
  input parameter use :: <GdkAxisUse>;
  c-name: "gdk_device_set_axis_use";
end;

define C-function gdk-device-get-state
  input parameter device :: <GdkDevice>;
  input parameter window :: <GdkWindow>;
  input parameter axes :: <gdouble*>;
  input parameter mask :: <GdkModifierType*>;
  c-name: "gdk_device_get_state";
end;

define C-pointer-type <GdkTimeCoord*> => <GdkTimeCoord>;
define C-pointer-type <GdkTimeCoord**> => <GdkTimeCoord*>;
define C-function gdk-device-get-history
  input parameter device :: <GdkDevice>;
  input parameter window :: <GdkWindow>;
  input parameter start :: <guint32>;
  input parameter stop :: <guint32>;
  input parameter events :: <GdkTimeCoord**>;
  input parameter n_events :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_device_get_history";
end;

define C-function gdk-device-free-history
  input parameter events :: <GdkTimeCoord*>;
  input parameter n_events :: <gint>;
  c-name: "gdk_device_free_history";
end;

define C-function gdk-device-get-axis
  input parameter device :: <GdkDevice>;
  input parameter axes :: <gdouble*>;
  input parameter use :: <GdkAxisUse>;
  input parameter value :: <gdouble*>;
  result res :: <gboolean>;
  c-name: "gdk_device_get_axis";
end;

define C-function gdk-input-set-extension-events
  input parameter window :: <GdkWindow>;
  input parameter mask :: <gint>;
  input parameter mode :: <GdkExtensionMode>;
  c-name: "gdk_input_set_extension_events";
end;

define C-function gdk-device-get-core-pointer
  result res :: <GdkDevice>;
  c-name: "gdk_device_get_core_pointer";
end;

define constant $GDK-MAX-TIMECOORD-AXES = 128;

define C-subtype <_GdkSpan> (<C-void*>) end;
define constant <GdkSpan> = <_GdkSpan>;

define constant <GdkStatus> = limited(<integer>, min: -4, max: 0);
define constant $GDK-OK :: <GdkStatus> = 0;
define constant $GDK-ERROR :: <GdkStatus> = -1;
define constant $GDK-ERROR-PARAM :: <GdkStatus> = -2;
define constant $GDK-ERROR-FILE :: <GdkStatus> = -3;
define constant $GDK-ERROR-MEM :: <GdkStatus> = -4;

define constant $GDK-CURRENT-TIME = 0;

define constant $GDK-PARENT-RELATIVE = 1;

define constant $GDK-HAVE-WCHAR-H = 1;

define constant $GDK-HAVE-WCTYPE-H = 1;

define constant $GDK-HAVE-BROKEN-WCTYPE = 1;

define C-subtype <_GdkDragContextClass> (<C-void*>) end;
define constant <GdkDragContextClass> = <_GdkDragContextClass>;

define C-function gdk-drag-context-get-type
  result res :: <GType>;
  c-name: "gdk_drag_context_get_type";
end;

define C-function gdk-drag-context-new
  result res :: <GdkDragContext>;
  c-name: "gdk_drag_context_new";
end;

define C-function gdk-drag-context-ref
  input parameter context :: <GdkDragContext>;
  c-name: "gdk_drag_context_ref";
end;

define C-function gdk-drag-context-unref
  input parameter context :: <GdkDragContext>;
  c-name: "gdk_drag_context_unref";
end;

define C-function gdk-drag-status
  input parameter context :: <GdkDragContext>;
  input parameter action :: <GdkDragAction>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_drag_status";
end;

define C-function gdk-drop-reply
  input parameter context :: <GdkDragContext>;
  input parameter ok :: <gboolean>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_drop_reply";
end;

define C-function gdk-drop-finish
  input parameter context :: <GdkDragContext>;
  input parameter success :: <gboolean>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_drop_finish";
end;

define C-function gdk-drag-get-selection
  input parameter context :: <GdkDragContext>;
  result res :: <GdkAtom>;
  c-name: "gdk_drag_get_selection";
end;

define C-function gdk-drag-begin
  input parameter window :: <GdkWindow>;
  input parameter targets :: <GList>;
  result res :: <GdkDragContext>;
  c-name: "gdk_drag_begin";
end;

define C-pointer-type <GdkDragProtocol*> => <GdkDragProtocol>;
define C-function gdk-drag-get-protocol-for-display
  input parameter display :: <GdkDisplay>;
  input parameter xid :: <guint32>;
  input parameter protocol :: <GdkDragProtocol*>;
  result res :: <guint32>;
  c-name: "gdk_drag_get_protocol_for_display";
end;

define C-function gdk-drag-find-window-for-screen
  input parameter context :: <GdkDragContext>;
  input parameter drag_window :: <GdkWindow>;
  input parameter screen :: <GdkScreen>;
  input parameter x_root :: <gint>;
  input parameter y_root :: <gint>;
  input parameter dest_window :: <GdkWindow*>;
  input parameter protocol :: <GdkDragProtocol*>;
  c-name: "gdk_drag_find_window_for_screen";
end;

define C-function gdk-drag-get-protocol
  input parameter xid :: <guint32>;
  input parameter protocol :: <GdkDragProtocol*>;
  result res :: <guint32>;
  c-name: "gdk_drag_get_protocol";
end;

define C-function gdk-drag-find-window
  input parameter context :: <GdkDragContext>;
  input parameter drag_window :: <GdkWindow>;
  input parameter x_root :: <gint>;
  input parameter y_root :: <gint>;
  input parameter dest_window :: <GdkWindow*>;
  input parameter protocol :: <GdkDragProtocol*>;
  c-name: "gdk_drag_find_window";
end;

define C-function gdk-drag-motion
  input parameter context :: <GdkDragContext>;
  input parameter dest_window :: <GdkWindow>;
  input parameter protocol :: <GdkDragProtocol>;
  input parameter x_root :: <gint>;
  input parameter y_root :: <gint>;
  input parameter suggested_action :: <GdkDragAction>;
  input parameter possible_actions :: <GdkDragAction>;
  input parameter time_ :: <guint32>;
  result res :: <gboolean>;
  c-name: "gdk_drag_motion";
end;

define C-function gdk-drag-drop
  input parameter context :: <GdkDragContext>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_drag_drop";
end;

define C-function gdk-drag-abort
  input parameter context :: <GdkDragContext>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_drag_abort";
end;

define C-function gdk-drag-drop-succeeded
  input parameter context :: <GdkDragContext>;
  result res :: <gboolean>;
  c-name: "gdk_drag_drop_succeeded";
end;

define C-subtype <_GdkColormapClass> (<C-void*>) end;
define constant <GdkColormapClass> = <_GdkColormapClass>;

define C-function gdk-colormap-get-type
  result res :: <GType>;
  c-name: "gdk_colormap_get_type";
end;

define C-function gdk-colormap-new
  input parameter visual :: <GdkVisual>;
  input parameter allocate :: <gboolean>;
  result res :: <GdkColormap>;
  c-name: "gdk_colormap_new";
end;

define C-function gdk-colormap-ref
  input parameter cmap :: <GdkColormap>;
  result res :: <GdkColormap>;
  c-name: "gdk_colormap_ref";
end;

define C-function gdk-colormap-unref
  input parameter cmap :: <GdkColormap>;
  c-name: "gdk_colormap_unref";
end;

define C-function gdk-colormap-get-system
  result res :: <GdkColormap>;
  c-name: "gdk_colormap_get_system";
end;

define C-function gdk-colormap-get-screen
  input parameter cmap :: <GdkColormap>;
  result res :: <GdkScreen>;
  c-name: "gdk_colormap_get_screen";
end;

define C-function gdk-colormap-get-system-size
  result res :: <gint>;
  c-name: "gdk_colormap_get_system_size";
end;

define C-function gdk-colormap-change
  input parameter colormap :: <GdkColormap>;
  input parameter ncolors :: <gint>;
  c-name: "gdk_colormap_change";
end;

define C-function gdk-colormap-alloc-colors
  input parameter colormap :: <GdkColormap>;
  input parameter colors :: <GdkColor>;
  input parameter ncolors :: <gint>;
  input parameter writeable :: <gboolean>;
  input parameter best_match :: <gboolean>;
  input parameter success :: <gboolean*>;
  result res :: <gint>;
  c-name: "gdk_colormap_alloc_colors";
end;

define C-function gdk-colormap-alloc-color
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  input parameter writeable :: <gboolean>;
  input parameter best_match :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gdk_colormap_alloc_color";
end;

define C-function gdk-colormap-free-colors
  input parameter colormap :: <GdkColormap>;
  input parameter colors :: <GdkColor>;
  input parameter ncolors :: <gint>;
  c-name: "gdk_colormap_free_colors";
end;

define C-function gdk-colormap-query-color
  input parameter colormap :: <GdkColormap>;
  input parameter pixel :: <gulong>;
  input parameter result :: <GdkColor>;
  c-name: "gdk_colormap_query_color";
end;

define C-function gdk-colormap-get-visual
  input parameter colormap :: <GdkColormap>;
  result res :: <GdkVisual>;
  c-name: "gdk_colormap_get_visual";
end;

define C-function gdk-color-copy
  input parameter color :: <GdkColor>;
  result res :: <GdkColor>;
  c-name: "gdk_color_copy";
end;

define C-function gdk-color-free
  input parameter color :: <GdkColor>;
  c-name: "gdk_color_free";
end;

define C-function gdk-color-parse
  input parameter spec :: <c-string>;
  input parameter color :: <GdkColor>;
  result res :: <gboolean>;
  c-name: "gdk_color_parse";
end;

define C-function gdk-color-hash
  input parameter colora :: <GdkColor>;
  result res :: <guint>;
  c-name: "gdk_color_hash";
end;

define C-function gdk-color-equal
  input parameter colora :: <GdkColor>;
  input parameter colorb :: <GdkColor>;
  result res :: <gboolean>;
  c-name: "gdk_color_equal";
end;

define C-function gdk-color-get-type
  result res :: <GType>;
  c-name: "gdk_color_get_type";
end;

define C-function gdk-colors-store
  input parameter colormap :: <GdkColormap>;
  input parameter colors :: <GdkColor>;
  input parameter ncolors :: <gint>;
  c-name: "gdk_colors_store";
end;

define C-function gdk-color-white
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  result res :: <gint>;
  c-name: "gdk_color_white";
end;

define C-function gdk-color-black
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  result res :: <gint>;
  c-name: "gdk_color_black";
end;

define C-function gdk-color-alloc
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  result res :: <gint>;
  c-name: "gdk_color_alloc";
end;

define C-function gdk-color-change
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  result res :: <gint>;
  c-name: "gdk_color_change";
end;

define C-function gdk-colors-alloc
  input parameter colormap :: <GdkColormap>;
  input parameter contiguous :: <gboolean>;
  input parameter planes :: <gulong*>;
  input parameter nplanes :: <gint>;
  input parameter pixels :: <gulong*>;
  input parameter npixels :: <gint>;
  result res :: <gint>;
  c-name: "gdk_colors_alloc";
end;

define C-function gdk-colors-free
  input parameter colormap :: <GdkColormap>;
  input parameter pixels :: <gulong*>;
  input parameter npixels :: <gint>;
  input parameter planes :: <gulong>;
  c-name: "gdk_colors_free";
end;

define C-function cairo-version
  result res :: <integer>;
  c-name: "cairo_version";
end;

define C-function cairo-version-string
  result res :: <c-string>;
  c-name: "cairo_version_string";
end;

define constant <cairo-bool-t> = <integer>;

define C-subtype <_cairo> (<C-void*>) end;
define constant <cairo-t> = <_cairo>;

define C-subtype <_cairo-matrix> (<C-void*>) end;
define constant <cairo-matrix-t> = <_cairo-matrix>;

define C-subtype <_cairo-pattern> (<C-void*>) end;
define constant <cairo-pattern-t> = <_cairo-pattern>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2>"*/
define constant <cairo-destroy-func-t> = <anonymous-2>;

define C-subtype <_cairo-user-data-key> (<C-void*>) end;
define constant <cairo-user-data-key-t> = <_cairo-user-data-key>;

define constant <_cairo-status> = limited(<integer>, min: 0, max: 20);
define constant $CAIRO-STATUS-SUCCESS :: <_cairo-status> = 0;
define constant $CAIRO-STATUS-NO-MEMORY :: <_cairo-status> = 1;
define constant $CAIRO-STATUS-INVALID-RESTORE :: <_cairo-status> = 2;
define constant $CAIRO-STATUS-INVALID-POP-GROUP :: <_cairo-status> = 3;
define constant $CAIRO-STATUS-NO-CURRENT-POINT :: <_cairo-status> = 4;
define constant $CAIRO-STATUS-INVALID-MATRIX :: <_cairo-status> = 5;
define constant $CAIRO-STATUS-INVALID-STATUS :: <_cairo-status> = 6;
define constant $CAIRO-STATUS-NULL-POINTER :: <_cairo-status> = 7;
define constant $CAIRO-STATUS-INVALID-STRING :: <_cairo-status> = 8;
define constant $CAIRO-STATUS-INVALID-PATH-DATA :: <_cairo-status> = 9;
define constant $CAIRO-STATUS-READ-ERROR :: <_cairo-status> = 10;
define constant $CAIRO-STATUS-WRITE-ERROR :: <_cairo-status> = 11;
define constant $CAIRO-STATUS-SURFACE-FINISHED :: <_cairo-status> = 12;
define constant $CAIRO-STATUS-SURFACE-TYPE-MISMATCH :: <_cairo-status> = 13;
define constant $CAIRO-STATUS-PATTERN-TYPE-MISMATCH :: <_cairo-status> = 14;
define constant $CAIRO-STATUS-INVALID-CONTENT :: <_cairo-status> = 15;
define constant $CAIRO-STATUS-INVALID-FORMAT :: <_cairo-status> = 16;
define constant $CAIRO-STATUS-INVALID-VISUAL :: <_cairo-status> = 17;
define constant $CAIRO-STATUS-FILE-NOT-FOUND :: <_cairo-status> = 18;
define constant $CAIRO-STATUS-INVALID-DASH :: <_cairo-status> = 19;
define constant $CAIRO-STATUS-INVALID-DSC-COMMENT :: <_cairo-status> = 20;

define constant <cairo-status-t> = <_cairo-status>;

define constant <_cairo-content> = limited(<integer>, min: 4096, max: 12288);
define constant $CAIRO-CONTENT-COLOR :: <_cairo-content> = 4096;
define constant $CAIRO-CONTENT-ALPHA :: <_cairo-content> = 8192;
define constant $CAIRO-CONTENT-COLOR-ALPHA :: <_cairo-content> = 12288;

define constant <cairo-content-t> = <_cairo-content>;

define C-pointer-type <unsigned-char*> => <integer>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3>"*/
define constant <cairo-write-func-t> = <anonymous-3>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4>"*/
define constant <cairo-read-func-t> = <anonymous-4>;

define C-function cairo-create
  input parameter target :: <cairo-surface-t>;
  result res :: <cairo-t>;
  c-name: "cairo_create";
end;

define C-function cairo-reference
  input parameter cr :: <cairo-t>;
  result res :: <cairo-t>;
  c-name: "cairo_reference";
end;

define C-function cairo-destroy
  input parameter cr :: <cairo-t>;
  c-name: "cairo_destroy";
end;

define C-function cairo-save
  input parameter cr :: <cairo-t>;
  c-name: "cairo_save";
end;

define C-function cairo-restore
  input parameter cr :: <cairo-t>;
  c-name: "cairo_restore";
end;

define C-function cairo-push-group
  input parameter cr :: <cairo-t>;
  c-name: "cairo_push_group";
end;

define C-function cairo-push-group-with-content
  input parameter cr :: <cairo-t>;
  input parameter content :: <cairo-content-t>;
  c-name: "cairo_push_group_with_content";
end;

define C-function cairo-pop-group
  input parameter cr :: <cairo-t>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pop_group";
end;

define C-function cairo-pop-group-to-source
  input parameter cr :: <cairo-t>;
  c-name: "cairo_pop_group_to_source";
end;

define constant <_cairo-operator> = limited(<integer>, min: 0, max: 13);
define constant $CAIRO-OPERATOR-CLEAR :: <_cairo-operator> = 0;
define constant $CAIRO-OPERATOR-SOURCE :: <_cairo-operator> = 1;
define constant $CAIRO-OPERATOR-OVER :: <_cairo-operator> = 2;
define constant $CAIRO-OPERATOR-IN :: <_cairo-operator> = 3;
define constant $CAIRO-OPERATOR-OUT :: <_cairo-operator> = 4;
define constant $CAIRO-OPERATOR-ATOP :: <_cairo-operator> = 5;
define constant $CAIRO-OPERATOR-DEST :: <_cairo-operator> = 6;
define constant $CAIRO-OPERATOR-DEST-OVER :: <_cairo-operator> = 7;
define constant $CAIRO-OPERATOR-DEST-IN :: <_cairo-operator> = 8;
define constant $CAIRO-OPERATOR-DEST-OUT :: <_cairo-operator> = 9;
define constant $CAIRO-OPERATOR-DEST-ATOP :: <_cairo-operator> = 10;
define constant $CAIRO-OPERATOR-XOR :: <_cairo-operator> = 11;
define constant $CAIRO-OPERATOR-ADD :: <_cairo-operator> = 12;
define constant $CAIRO-OPERATOR-SATURATE :: <_cairo-operator> = 13;

define constant <cairo-operator-t> = <_cairo-operator>;

define C-function cairo-set-operator
  input parameter cr :: <cairo-t>;
  input parameter op :: <cairo-operator-t>;
  c-name: "cairo_set_operator";
end;

define C-function cairo-set-source
  input parameter cr :: <cairo-t>;
  input parameter source :: <cairo-pattern-t>;
  c-name: "cairo_set_source";
end;

define C-function cairo-set-source-rgb
  input parameter cr :: <cairo-t>;
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  c-name: "cairo_set_source_rgb";
end;

define C-function cairo-set-source-rgba
  input parameter cr :: <cairo-t>;
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  input parameter alpha :: <double-float>;
  c-name: "cairo_set_source_rgba";
end;

define C-function cairo-set-source-surface
  input parameter cr :: <cairo-t>;
  input parameter surface :: <cairo-surface-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  c-name: "cairo_set_source_surface";
end;

define C-function cairo-set-tolerance
  input parameter cr :: <cairo-t>;
  input parameter tolerance :: <double-float>;
  c-name: "cairo_set_tolerance";
end;

define constant <_cairo-antialias> = limited(<integer>, min: 0, max: 3);
define constant $CAIRO-ANTIALIAS-DEFAULT :: <_cairo-antialias> = 0;
define constant $CAIRO-ANTIALIAS-NONE :: <_cairo-antialias> = 1;
define constant $CAIRO-ANTIALIAS-GRAY :: <_cairo-antialias> = 2;
define constant $CAIRO-ANTIALIAS-SUBPIXEL :: <_cairo-antialias> = 3;

define constant <cairo-antialias-t> = <_cairo-antialias>;

define C-function cairo-set-antialias
  input parameter cr :: <cairo-t>;
  input parameter antialias :: <cairo-antialias-t>;
  c-name: "cairo_set_antialias";
end;

define constant <_cairo-fill-rule> = limited(<integer>, min: 0, max: 1);
define constant $CAIRO-FILL-RULE-WINDING :: <_cairo-fill-rule> = 0;
define constant $CAIRO-FILL-RULE-EVEN-ODD :: <_cairo-fill-rule> = 1;

define constant <cairo-fill-rule-t> = <_cairo-fill-rule>;

define C-function cairo-set-fill-rule
  input parameter cr :: <cairo-t>;
  input parameter fill_rule :: <cairo-fill-rule-t>;
  c-name: "cairo_set_fill_rule";
end;

define C-function cairo-set-line-width
  input parameter cr :: <cairo-t>;
  input parameter width :: <double-float>;
  c-name: "cairo_set_line_width";
end;

define constant <_cairo-line-cap> = limited(<integer>, min: 0, max: 2);
define constant $CAIRO-LINE-CAP-BUTT :: <_cairo-line-cap> = 0;
define constant $CAIRO-LINE-CAP-ROUND :: <_cairo-line-cap> = 1;
define constant $CAIRO-LINE-CAP-SQUARE :: <_cairo-line-cap> = 2;

define constant <cairo-line-cap-t> = <_cairo-line-cap>;

define C-function cairo-set-line-cap
  input parameter cr :: <cairo-t>;
  input parameter line_cap :: <cairo-line-cap-t>;
  c-name: "cairo_set_line_cap";
end;

define constant <_cairo-line-join> = limited(<integer>, min: 0, max: 2);
define constant $CAIRO-LINE-JOIN-MITER :: <_cairo-line-join> = 0;
define constant $CAIRO-LINE-JOIN-ROUND :: <_cairo-line-join> = 1;
define constant $CAIRO-LINE-JOIN-BEVEL :: <_cairo-line-join> = 2;

define constant <cairo-line-join-t> = <_cairo-line-join>;

define C-function cairo-set-line-join
  input parameter cr :: <cairo-t>;
  input parameter line_join :: <cairo-line-join-t>;
  c-name: "cairo_set_line_join";
end;

define C-function cairo-set-dash
  input parameter cr :: <cairo-t>;
  input parameter dashes :: <double*>;
  input parameter num_dashes :: <integer>;
  input parameter offset :: <double-float>;
  c-name: "cairo_set_dash";
end;

define C-function cairo-set-miter-limit
  input parameter cr :: <cairo-t>;
  input parameter limit :: <double-float>;
  c-name: "cairo_set_miter_limit";
end;

define C-function cairo-translate
  input parameter cr :: <cairo-t>;
  input parameter tx :: <double-float>;
  input parameter ty :: <double-float>;
  c-name: "cairo_translate";
end;

define C-function cairo-scale
  input parameter cr :: <cairo-t>;
  input parameter sx :: <double-float>;
  input parameter sy :: <double-float>;
  c-name: "cairo_scale";
end;

define C-function cairo-rotate
  input parameter cr :: <cairo-t>;
  input parameter angle :: <double-float>;
  c-name: "cairo_rotate";
end;

define C-function cairo-transform
  input parameter cr :: <cairo-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_transform";
end;

define C-function cairo-set-matrix
  input parameter cr :: <cairo-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_set_matrix";
end;

define C-function cairo-identity-matrix
  input parameter cr :: <cairo-t>;
  c-name: "cairo_identity_matrix";
end;

define C-function cairo-user-to-device
  input parameter cr :: <cairo-t>;
  input parameter x :: <double*>;
  input parameter y :: <double*>;
  c-name: "cairo_user_to_device";
end;

define C-function cairo-user-to-device-distance
  input parameter cr :: <cairo-t>;
  input parameter dx :: <double*>;
  input parameter dy :: <double*>;
  c-name: "cairo_user_to_device_distance";
end;

define C-function cairo-device-to-user
  input parameter cr :: <cairo-t>;
  input parameter x :: <double*>;
  input parameter y :: <double*>;
  c-name: "cairo_device_to_user";
end;

define C-function cairo-device-to-user-distance
  input parameter cr :: <cairo-t>;
  input parameter dx :: <double*>;
  input parameter dy :: <double*>;
  c-name: "cairo_device_to_user_distance";
end;

define C-function cairo-new-path
  input parameter cr :: <cairo-t>;
  c-name: "cairo_new_path";
end;

define C-function cairo-move-to
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  c-name: "cairo_move_to";
end;

define C-function cairo-new-sub-path
  input parameter cr :: <cairo-t>;
  c-name: "cairo_new_sub_path";
end;

define C-function cairo-line-to
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  c-name: "cairo_line_to";
end;

define C-function cairo-curve-to
  input parameter cr :: <cairo-t>;
  input parameter x1 :: <double-float>;
  input parameter y1 :: <double-float>;
  input parameter x2 :: <double-float>;
  input parameter y2 :: <double-float>;
  input parameter x3 :: <double-float>;
  input parameter y3 :: <double-float>;
  c-name: "cairo_curve_to";
end;

define C-function cairo-arc
  input parameter cr :: <cairo-t>;
  input parameter xc :: <double-float>;
  input parameter yc :: <double-float>;
  input parameter radius :: <double-float>;
  input parameter angle1 :: <double-float>;
  input parameter angle2 :: <double-float>;
  c-name: "cairo_arc";
end;

define C-function cairo-arc-negative
  input parameter cr :: <cairo-t>;
  input parameter xc :: <double-float>;
  input parameter yc :: <double-float>;
  input parameter radius :: <double-float>;
  input parameter angle1 :: <double-float>;
  input parameter angle2 :: <double-float>;
  c-name: "cairo_arc_negative";
end;

define C-function cairo-rel-move-to
  input parameter cr :: <cairo-t>;
  input parameter dx :: <double-float>;
  input parameter dy :: <double-float>;
  c-name: "cairo_rel_move_to";
end;

define C-function cairo-rel-line-to
  input parameter cr :: <cairo-t>;
  input parameter dx :: <double-float>;
  input parameter dy :: <double-float>;
  c-name: "cairo_rel_line_to";
end;

define C-function cairo-rel-curve-to
  input parameter cr :: <cairo-t>;
  input parameter dx1 :: <double-float>;
  input parameter dy1 :: <double-float>;
  input parameter dx2 :: <double-float>;
  input parameter dy2 :: <double-float>;
  input parameter dx3 :: <double-float>;
  input parameter dy3 :: <double-float>;
  c-name: "cairo_rel_curve_to";
end;

define C-function cairo-rectangle
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  input parameter width :: <double-float>;
  input parameter height :: <double-float>;
  c-name: "cairo_rectangle";
end;

define C-function cairo-close-path
  input parameter cr :: <cairo-t>;
  c-name: "cairo_close_path";
end;

define C-function cairo-paint
  input parameter cr :: <cairo-t>;
  c-name: "cairo_paint";
end;

define C-function cairo-paint-with-alpha
  input parameter cr :: <cairo-t>;
  input parameter alpha :: <double-float>;
  c-name: "cairo_paint_with_alpha";
end;

define C-function cairo-mask
  input parameter cr :: <cairo-t>;
  input parameter pattern :: <cairo-pattern-t>;
  c-name: "cairo_mask";
end;

define C-function cairo-mask-surface
  input parameter cr :: <cairo-t>;
  input parameter surface :: <cairo-surface-t>;
  input parameter surface_x :: <double-float>;
  input parameter surface_y :: <double-float>;
  c-name: "cairo_mask_surface";
end;

define C-function cairo-stroke
  input parameter cr :: <cairo-t>;
  c-name: "cairo_stroke";
end;

define C-function cairo-stroke-preserve
  input parameter cr :: <cairo-t>;
  c-name: "cairo_stroke_preserve";
end;

define C-function cairo-fill
  input parameter cr :: <cairo-t>;
  c-name: "cairo_fill";
end;

define C-function cairo-fill-preserve
  input parameter cr :: <cairo-t>;
  c-name: "cairo_fill_preserve";
end;

define C-function cairo-copy-page
  input parameter cr :: <cairo-t>;
  c-name: "cairo_copy_page";
end;

define C-function cairo-show-page
  input parameter cr :: <cairo-t>;
  c-name: "cairo_show_page";
end;

define C-function cairo-in-stroke
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  result res :: <cairo-bool-t>;
  c-name: "cairo_in_stroke";
end;

define C-function cairo-in-fill
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  result res :: <cairo-bool-t>;
  c-name: "cairo_in_fill";
end;

define C-function cairo-stroke-extents
  input parameter cr :: <cairo-t>;
  input parameter x1 :: <double*>;
  input parameter y1 :: <double*>;
  input parameter x2 :: <double*>;
  input parameter y2 :: <double*>;
  c-name: "cairo_stroke_extents";
end;

define C-function cairo-fill-extents
  input parameter cr :: <cairo-t>;
  input parameter x1 :: <double*>;
  input parameter y1 :: <double*>;
  input parameter x2 :: <double*>;
  input parameter y2 :: <double*>;
  c-name: "cairo_fill_extents";
end;

define C-function cairo-reset-clip
  input parameter cr :: <cairo-t>;
  c-name: "cairo_reset_clip";
end;

define C-function cairo-clip
  input parameter cr :: <cairo-t>;
  c-name: "cairo_clip";
end;

define C-function cairo-clip-preserve
  input parameter cr :: <cairo-t>;
  c-name: "cairo_clip_preserve";
end;

define C-subtype <_cairo-scaled-font> (<C-void*>) end;
define constant <cairo-scaled-font-t> = <_cairo-scaled-font>;

define C-subtype <_cairo-font-face> (<C-void*>) end;
define constant <cairo-font-face-t> = <_cairo-font-face>;

define C-subtype <cairo-glyph-t> (<C-void*>) end;
define C-subtype <cairo-text-extents-t> (<C-void*>) end;
define C-subtype <cairo-font-extents-t> (<C-void*>) end;
define constant <_cairo-font-slant> = limited(<integer>, min: 0, max: 2);
define constant $CAIRO-FONT-SLANT-NORMAL :: <_cairo-font-slant> = 0;
define constant $CAIRO-FONT-SLANT-ITALIC :: <_cairo-font-slant> = 1;
define constant $CAIRO-FONT-SLANT-OBLIQUE :: <_cairo-font-slant> = 2;

define constant <cairo-font-slant-t> = <_cairo-font-slant>;

define constant <_cairo-font-weight> = limited(<integer>, min: 0, max: 1);
define constant $CAIRO-FONT-WEIGHT-NORMAL :: <_cairo-font-weight> = 0;
define constant $CAIRO-FONT-WEIGHT-BOLD :: <_cairo-font-weight> = 1;

define constant <cairo-font-weight-t> = <_cairo-font-weight>;

define constant <_cairo-subpixel-order> = limited(<integer>, min: 0, max: 4);
define constant $CAIRO-SUBPIXEL-ORDER-DEFAULT :: <_cairo-subpixel-order> = 0;
define constant $CAIRO-SUBPIXEL-ORDER-RGB :: <_cairo-subpixel-order> = 1;
define constant $CAIRO-SUBPIXEL-ORDER-BGR :: <_cairo-subpixel-order> = 2;
define constant $CAIRO-SUBPIXEL-ORDER-VRGB :: <_cairo-subpixel-order> = 3;
define constant $CAIRO-SUBPIXEL-ORDER-VBGR :: <_cairo-subpixel-order> = 4;

define constant <cairo-subpixel-order-t> = <_cairo-subpixel-order>;

define constant <_cairo-hint-style> = limited(<integer>, min: 0, max: 4);
define constant $CAIRO-HINT-STYLE-DEFAULT :: <_cairo-hint-style> = 0;
define constant $CAIRO-HINT-STYLE-NONE :: <_cairo-hint-style> = 1;
define constant $CAIRO-HINT-STYLE-SLIGHT :: <_cairo-hint-style> = 2;
define constant $CAIRO-HINT-STYLE-MEDIUM :: <_cairo-hint-style> = 3;
define constant $CAIRO-HINT-STYLE-FULL :: <_cairo-hint-style> = 4;

define constant <cairo-hint-style-t> = <_cairo-hint-style>;

define constant <_cairo-hint-metrics> = limited(<integer>, min: 0, max: 2);
define constant $CAIRO-HINT-METRICS-DEFAULT :: <_cairo-hint-metrics> = 0;
define constant $CAIRO-HINT-METRICS-OFF :: <_cairo-hint-metrics> = 1;
define constant $CAIRO-HINT-METRICS-ON :: <_cairo-hint-metrics> = 2;

define constant <cairo-hint-metrics-t> = <_cairo-hint-metrics>;

define C-function cairo-font-options-create
  result res :: <cairo-font-options-t>;
  c-name: "cairo_font_options_create";
end;

define C-function cairo-font-options-copy
  input parameter original :: <cairo-font-options-t>;
  result res :: <cairo-font-options-t>;
  c-name: "cairo_font_options_copy";
end;

define C-function cairo-font-options-destroy
  input parameter options :: <cairo-font-options-t>;
  c-name: "cairo_font_options_destroy";
end;

define C-function cairo-font-options-status
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_font_options_status";
end;

define C-function cairo-font-options-merge
  input parameter options :: <cairo-font-options-t>;
  input parameter other :: <cairo-font-options-t>;
  c-name: "cairo_font_options_merge";
end;

define C-function cairo-font-options-equal
  input parameter options :: <cairo-font-options-t>;
  input parameter other :: <cairo-font-options-t>;
  result res :: <cairo-bool-t>;
  c-name: "cairo_font_options_equal";
end;

define C-function cairo-font-options-hash
  input parameter options :: <cairo-font-options-t>;
  result res :: <integer>;
  c-name: "cairo_font_options_hash";
end;

define C-function cairo-font-options-set-antialias
  input parameter options :: <cairo-font-options-t>;
  input parameter antialias :: <cairo-antialias-t>;
  c-name: "cairo_font_options_set_antialias";
end;

define C-function cairo-font-options-get-antialias
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-antialias-t>;
  c-name: "cairo_font_options_get_antialias";
end;

define C-function cairo-font-options-set-subpixel-order
  input parameter options :: <cairo-font-options-t>;
  input parameter subpixel_order :: <cairo-subpixel-order-t>;
  c-name: "cairo_font_options_set_subpixel_order";
end;

define C-function cairo-font-options-get-subpixel-order
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-subpixel-order-t>;
  c-name: "cairo_font_options_get_subpixel_order";
end;

define C-function cairo-font-options-set-hint-style
  input parameter options :: <cairo-font-options-t>;
  input parameter hint_style :: <cairo-hint-style-t>;
  c-name: "cairo_font_options_set_hint_style";
end;

define C-function cairo-font-options-get-hint-style
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-hint-style-t>;
  c-name: "cairo_font_options_get_hint_style";
end;

define C-function cairo-font-options-set-hint-metrics
  input parameter options :: <cairo-font-options-t>;
  input parameter hint_metrics :: <cairo-hint-metrics-t>;
  c-name: "cairo_font_options_set_hint_metrics";
end;

define C-function cairo-font-options-get-hint-metrics
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-hint-metrics-t>;
  c-name: "cairo_font_options_get_hint_metrics";
end;

define C-function cairo-select-font-face
  input parameter cr :: <cairo-t>;
  input parameter family :: <c-string>;
  input parameter slant :: <cairo-font-slant-t>;
  input parameter weight :: <cairo-font-weight-t>;
  c-name: "cairo_select_font_face";
end;

define C-function cairo-set-font-size
  input parameter cr :: <cairo-t>;
  input parameter size :: <double-float>;
  c-name: "cairo_set_font_size";
end;

define C-function cairo-set-font-matrix
  input parameter cr :: <cairo-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_set_font_matrix";
end;

define C-function cairo-get-font-matrix
  input parameter cr :: <cairo-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_get_font_matrix";
end;

define C-function cairo-set-font-options
  input parameter cr :: <cairo-t>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "cairo_set_font_options";
end;

define C-function cairo-get-font-options
  input parameter cr :: <cairo-t>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "cairo_get_font_options";
end;

define C-function cairo-set-scaled-font
  input parameter cr :: <cairo-t>;
  input parameter scaled_font :: <cairo-scaled-font-t>;
  c-name: "cairo_set_scaled_font";
end;

define C-function cairo-show-text
  input parameter cr :: <cairo-t>;
  input parameter utf8 :: <c-string>;
  c-name: "cairo_show_text";
end;

define C-function cairo-show-glyphs
  input parameter cr :: <cairo-t>;
  input parameter glyphs :: <cairo-glyph-t>;
  input parameter num_glyphs :: <integer>;
  c-name: "cairo_show_glyphs";
end;

define C-function cairo-get-font-face
  input parameter cr :: <cairo-t>;
  result res :: <cairo-font-face-t>;
  c-name: "cairo_get_font_face";
end;

define C-function cairo-font-extents
  input parameter cr :: <cairo-t>;
  input parameter extents :: <cairo-font-extents-t>;
  c-name: "cairo_font_extents";
end;

define C-function cairo-set-font-face
  input parameter cr :: <cairo-t>;
  input parameter font_face :: <cairo-font-face-t>;
  c-name: "cairo_set_font_face";
end;

define C-function cairo-text-extents
  input parameter cr :: <cairo-t>;
  input parameter utf8 :: <c-string>;
  input parameter extents :: <cairo-text-extents-t>;
  c-name: "cairo_text_extents";
end;

define C-function cairo-glyph-extents
  input parameter cr :: <cairo-t>;
  input parameter glyphs :: <cairo-glyph-t>;
  input parameter num_glyphs :: <integer>;
  input parameter extents :: <cairo-text-extents-t>;
  c-name: "cairo_glyph_extents";
end;

define C-function cairo-text-path
  input parameter cr :: <cairo-t>;
  input parameter utf8 :: <c-string>;
  c-name: "cairo_text_path";
end;

define C-function cairo-glyph-path
  input parameter cr :: <cairo-t>;
  input parameter glyphs :: <cairo-glyph-t>;
  input parameter num_glyphs :: <integer>;
  c-name: "cairo_glyph_path";
end;

define C-function cairo-font-face-reference
  input parameter font_face :: <cairo-font-face-t>;
  result res :: <cairo-font-face-t>;
  c-name: "cairo_font_face_reference";
end;

define C-function cairo-font-face-destroy
  input parameter font_face :: <cairo-font-face-t>;
  c-name: "cairo_font_face_destroy";
end;

define C-function cairo-font-face-status
  input parameter font_face :: <cairo-font-face-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_font_face_status";
end;

define constant <_cairo-font-type> = limited(<integer>, min: 0, max: 3);
define constant $CAIRO-FONT-TYPE-TOY :: <_cairo-font-type> = 0;
define constant $CAIRO-FONT-TYPE-FT :: <_cairo-font-type> = 1;
define constant $CAIRO-FONT-TYPE-WIN32 :: <_cairo-font-type> = 2;
define constant $CAIRO-FONT-TYPE-ATSUI :: <_cairo-font-type> = 3;

define constant <cairo-font-type-t> = <_cairo-font-type>;

define C-function cairo-font-face-get-type
  input parameter font_face :: <cairo-font-face-t>;
  result res :: <cairo-font-type-t>;
  c-name: "cairo_font_face_get_type";
end;

define C-function cairo-font-face-get-user-data
  input parameter font_face :: <cairo-font-face-t>;
  input parameter key :: <cairo-user-data-key-t>;
  result res :: <machine-pointer>;
  c-name: "cairo_font_face_get_user_data";
end;

define C-function cairo-font-face-set-user-data
  input parameter font_face :: <cairo-font-face-t>;
  input parameter key :: <cairo-user-data-key-t>;
  input parameter user_data :: <machine-pointer>;
  input parameter destroy :: <cairo-destroy-func-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_font_face_set_user_data";
end;

define C-function cairo-scaled-font-create
  input parameter font_face :: <cairo-font-face-t>;
  input parameter font_matrix :: <cairo-matrix-t>;
  input parameter ctm :: <cairo-matrix-t>;
  input parameter options :: <cairo-font-options-t>;
  result res :: <cairo-scaled-font-t>;
  c-name: "cairo_scaled_font_create";
end;

define C-function cairo-scaled-font-reference
  input parameter scaled_font :: <cairo-scaled-font-t>;
  result res :: <cairo-scaled-font-t>;
  c-name: "cairo_scaled_font_reference";
end;

define C-function cairo-scaled-font-destroy
  input parameter scaled_font :: <cairo-scaled-font-t>;
  c-name: "cairo_scaled_font_destroy";
end;

define C-function cairo-scaled-font-status
  input parameter scaled_font :: <cairo-scaled-font-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_scaled_font_status";
end;

define C-function cairo-scaled-font-get-type
  input parameter scaled_font :: <cairo-scaled-font-t>;
  result res :: <cairo-font-type-t>;
  c-name: "cairo_scaled_font_get_type";
end;

define C-function cairo-scaled-font-extents
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter extents :: <cairo-font-extents-t>;
  c-name: "cairo_scaled_font_extents";
end;

define C-function cairo-scaled-font-text-extents
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter utf8 :: <c-string>;
  input parameter extents :: <cairo-text-extents-t>;
  c-name: "cairo_scaled_font_text_extents";
end;

define C-function cairo-scaled-font-glyph-extents
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter glyphs :: <cairo-glyph-t>;
  input parameter num_glyphs :: <integer>;
  input parameter extents :: <cairo-text-extents-t>;
  c-name: "cairo_scaled_font_glyph_extents";
end;

define C-function cairo-scaled-font-get-font-face
  input parameter scaled_font :: <cairo-scaled-font-t>;
  result res :: <cairo-font-face-t>;
  c-name: "cairo_scaled_font_get_font_face";
end;

define C-function cairo-scaled-font-get-font-matrix
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter font_matrix :: <cairo-matrix-t>;
  c-name: "cairo_scaled_font_get_font_matrix";
end;

define C-function cairo-scaled-font-get-ctm
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter ctm :: <cairo-matrix-t>;
  c-name: "cairo_scaled_font_get_ctm";
end;

define C-function cairo-scaled-font-get-font-options
  input parameter scaled_font :: <cairo-scaled-font-t>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "cairo_scaled_font_get_font_options";
end;

define C-function cairo-get-operator
  input parameter cr :: <cairo-t>;
  result res :: <cairo-operator-t>;
  c-name: "cairo_get_operator";
end;

define C-function cairo-get-source
  input parameter cr :: <cairo-t>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_get_source";
end;

define C-function cairo-get-tolerance
  input parameter cr :: <cairo-t>;
  result res :: <double-float>;
  c-name: "cairo_get_tolerance";
end;

define C-function cairo-get-antialias
  input parameter cr :: <cairo-t>;
  result res :: <cairo-antialias-t>;
  c-name: "cairo_get_antialias";
end;

define C-function cairo-get-current-point
  input parameter cr :: <cairo-t>;
  input parameter x :: <double*>;
  input parameter y :: <double*>;
  c-name: "cairo_get_current_point";
end;

define C-function cairo-get-fill-rule
  input parameter cr :: <cairo-t>;
  result res :: <cairo-fill-rule-t>;
  c-name: "cairo_get_fill_rule";
end;

define C-function cairo-get-line-width
  input parameter cr :: <cairo-t>;
  result res :: <double-float>;
  c-name: "cairo_get_line_width";
end;

define C-function cairo-get-line-cap
  input parameter cr :: <cairo-t>;
  result res :: <cairo-line-cap-t>;
  c-name: "cairo_get_line_cap";
end;

define C-function cairo-get-line-join
  input parameter cr :: <cairo-t>;
  result res :: <cairo-line-join-t>;
  c-name: "cairo_get_line_join";
end;

define C-function cairo-get-miter-limit
  input parameter cr :: <cairo-t>;
  result res :: <double-float>;
  c-name: "cairo_get_miter_limit";
end;

define C-function cairo-get-matrix
  input parameter cr :: <cairo-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_get_matrix";
end;

define C-function cairo-get-target
  input parameter cr :: <cairo-t>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_get_target";
end;

define C-function cairo-get-group-target
  input parameter cr :: <cairo-t>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_get_group_target";
end;

define constant <_cairo-path-data-type> = limited(<integer>, min: 0, max: 3);
define constant $CAIRO-PATH-MOVE-TO :: <_cairo-path-data-type> = 0;
define constant $CAIRO-PATH-LINE-TO :: <_cairo-path-data-type> = 1;
define constant $CAIRO-PATH-CURVE-TO :: <_cairo-path-data-type> = 2;
define constant $CAIRO-PATH-CLOSE-PATH :: <_cairo-path-data-type> = 3;

define constant <cairo-path-data-type-t> = <_cairo-path-data-type>;

define C-subtype <anonymous-131> (<C-void*>) end;
define C-subtype <anonymous-132> (<C-void*>) end;
 /* Ignoring declaration for {instance of <union-declaration>} "<_cairo-path-data-t>"*/
define constant <cairo-path-data-t> = <_cairo-path-data-t>;

define C-subtype <cairo-path> (<C-void*>) end;
define constant <cairo-path-t> = <cairo-path>;

define C-function cairo-copy-path
  input parameter cr :: <cairo-t>;
  result res :: <cairo-path-t>;
  c-name: "cairo_copy_path";
end;

define C-function cairo-copy-path-flat
  input parameter cr :: <cairo-t>;
  result res :: <cairo-path-t>;
  c-name: "cairo_copy_path_flat";
end;

define C-function cairo-append-path
  input parameter cr :: <cairo-t>;
  input parameter path :: <cairo-path-t>;
  c-name: "cairo_append_path";
end;

define C-function cairo-path-destroy
  input parameter path :: <cairo-path-t>;
  c-name: "cairo_path_destroy";
end;

define C-function cairo-status
  input parameter cr :: <cairo-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_status";
end;

define C-function cairo-status-to-string
  input parameter status :: <cairo-status-t>;
  result res :: <c-string>;
  c-name: "cairo_status_to_string";
end;

define C-function cairo-surface-create-similar
  input parameter other :: <cairo-surface-t>;
  input parameter content :: <cairo-content-t>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_surface_create_similar";
end;

define C-function cairo-surface-reference
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_surface_reference";
end;

define C-function cairo-surface-finish
  input parameter surface :: <cairo-surface-t>;
  c-name: "cairo_surface_finish";
end;

define C-function cairo-surface-destroy
  input parameter surface :: <cairo-surface-t>;
  c-name: "cairo_surface_destroy";
end;

define C-function cairo-surface-status
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_surface_status";
end;

define constant <_cairo-surface-type> = limited(<integer>, min: 0, max: 10);
define constant $CAIRO-SURFACE-TYPE-IMAGE :: <_cairo-surface-type> = 0;
define constant $CAIRO-SURFACE-TYPE-PDF :: <_cairo-surface-type> = 1;
define constant $CAIRO-SURFACE-TYPE-PS :: <_cairo-surface-type> = 2;
define constant $CAIRO-SURFACE-TYPE-XLIB :: <_cairo-surface-type> = 3;
define constant $CAIRO-SURFACE-TYPE-XCB :: <_cairo-surface-type> = 4;
define constant $CAIRO-SURFACE-TYPE-GLITZ :: <_cairo-surface-type> = 5;
define constant $CAIRO-SURFACE-TYPE-QUARTZ :: <_cairo-surface-type> = 6;
define constant $CAIRO-SURFACE-TYPE-WIN32 :: <_cairo-surface-type> = 7;
define constant $CAIRO-SURFACE-TYPE-BEOS :: <_cairo-surface-type> = 8;
define constant $CAIRO-SURFACE-TYPE-DIRECTFB :: <_cairo-surface-type> = 9;
define constant $CAIRO-SURFACE-TYPE-SVG :: <_cairo-surface-type> = 10;

define constant <cairo-surface-type-t> = <_cairo-surface-type>;

define C-function cairo-surface-get-type
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-surface-type-t>;
  c-name: "cairo_surface_get_type";
end;

define C-function cairo-surface-get-content
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-content-t>;
  c-name: "cairo_surface_get_content";
end;

define C-function cairo-surface-write-to-png
  input parameter surface :: <cairo-surface-t>;
  input parameter filename :: <c-string>;
  result res :: <cairo-status-t>;
  c-name: "cairo_surface_write_to_png";
end;

define C-function cairo-surface-write-to-png-stream
  input parameter surface :: <cairo-surface-t>;
  input parameter write_func :: <cairo-write-func-t>;
  input parameter closure :: <machine-pointer>;
  result res :: <cairo-status-t>;
  c-name: "cairo_surface_write_to_png_stream";
end;

define C-function cairo-surface-get-user-data
  input parameter surface :: <cairo-surface-t>;
  input parameter key :: <cairo-user-data-key-t>;
  result res :: <machine-pointer>;
  c-name: "cairo_surface_get_user_data";
end;

define C-function cairo-surface-set-user-data
  input parameter surface :: <cairo-surface-t>;
  input parameter key :: <cairo-user-data-key-t>;
  input parameter user_data :: <machine-pointer>;
  input parameter destroy :: <cairo-destroy-func-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_surface_set_user_data";
end;

define C-function cairo-surface-get-font-options
  input parameter surface :: <cairo-surface-t>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "cairo_surface_get_font_options";
end;

define C-function cairo-surface-flush
  input parameter surface :: <cairo-surface-t>;
  c-name: "cairo_surface_flush";
end;

define C-function cairo-surface-mark-dirty
  input parameter surface :: <cairo-surface-t>;
  c-name: "cairo_surface_mark_dirty";
end;

define C-function cairo-surface-mark-dirty-rectangle
  input parameter surface :: <cairo-surface-t>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  c-name: "cairo_surface_mark_dirty_rectangle";
end;

define C-function cairo-surface-set-device-offset
  input parameter surface :: <cairo-surface-t>;
  input parameter x_offset :: <double-float>;
  input parameter y_offset :: <double-float>;
  c-name: "cairo_surface_set_device_offset";
end;

define C-function cairo-surface-get-device-offset
  input parameter surface :: <cairo-surface-t>;
  input parameter x_offset :: <double*>;
  input parameter y_offset :: <double*>;
  c-name: "cairo_surface_get_device_offset";
end;

define C-function cairo-surface-set-fallback-resolution
  input parameter surface :: <cairo-surface-t>;
  input parameter x_pixels_per_inch :: <double-float>;
  input parameter y_pixels_per_inch :: <double-float>;
  c-name: "cairo_surface_set_fallback_resolution";
end;

define constant <_cairo-format> = limited(<integer>, min: 0, max: 4);
define constant $CAIRO-FORMAT-ARGB32 :: <_cairo-format> = 0;
define constant $CAIRO-FORMAT-RGB24 :: <_cairo-format> = 1;
define constant $CAIRO-FORMAT-A8 :: <_cairo-format> = 2;
define constant $CAIRO-FORMAT-A1 :: <_cairo-format> = 3;
define constant $CAIRO-FORMAT-RGB16-565 :: <_cairo-format> = 4;

define constant <cairo-format-t> = <_cairo-format>;

define C-function cairo-image-surface-create
  input parameter format :: <cairo-format-t>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_image_surface_create";
end;

define C-function cairo-image-surface-create-for-data
  input parameter data :: <unsigned-char*>;
  input parameter format :: <cairo-format-t>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter stride :: <integer>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_image_surface_create_for_data";
end;

define C-function cairo-image-surface-get-data
  input parameter surface :: <cairo-surface-t>;
  result res :: <unsigned-char*>;
  c-name: "cairo_image_surface_get_data";
end;

define C-function cairo-image-surface-get-format
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-format-t>;
  c-name: "cairo_image_surface_get_format";
end;

define C-function cairo-image-surface-get-width
  input parameter surface :: <cairo-surface-t>;
  result res :: <integer>;
  c-name: "cairo_image_surface_get_width";
end;

define C-function cairo-image-surface-get-height
  input parameter surface :: <cairo-surface-t>;
  result res :: <integer>;
  c-name: "cairo_image_surface_get_height";
end;

define C-function cairo-image-surface-get-stride
  input parameter surface :: <cairo-surface-t>;
  result res :: <integer>;
  c-name: "cairo_image_surface_get_stride";
end;

define C-function cairo-image-surface-create-from-png
  input parameter filename :: <c-string>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_image_surface_create_from_png";
end;

define C-function cairo-image-surface-create-from-png-stream
  input parameter read_func :: <cairo-read-func-t>;
  input parameter closure :: <machine-pointer>;
  result res :: <cairo-surface-t>;
  c-name: "cairo_image_surface_create_from_png_stream";
end;

define C-function cairo-pattern-create-rgb
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_create_rgb";
end;

define C-function cairo-pattern-create-rgba
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  input parameter alpha :: <double-float>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_create_rgba";
end;

define C-function cairo-pattern-create-for-surface
  input parameter surface :: <cairo-surface-t>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_create_for_surface";
end;

define C-function cairo-pattern-create-linear
  input parameter x0 :: <double-float>;
  input parameter y0 :: <double-float>;
  input parameter x1 :: <double-float>;
  input parameter y1 :: <double-float>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_create_linear";
end;

define C-function cairo-pattern-create-radial
  input parameter cx0 :: <double-float>;
  input parameter cy0 :: <double-float>;
  input parameter radius0 :: <double-float>;
  input parameter cx1 :: <double-float>;
  input parameter cy1 :: <double-float>;
  input parameter radius1 :: <double-float>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_create_radial";
end;

define C-function cairo-pattern-reference
  input parameter pattern :: <cairo-pattern-t>;
  result res :: <cairo-pattern-t>;
  c-name: "cairo_pattern_reference";
end;

define C-function cairo-pattern-destroy
  input parameter pattern :: <cairo-pattern-t>;
  c-name: "cairo_pattern_destroy";
end;

define C-function cairo-pattern-status
  input parameter pattern :: <cairo-pattern-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_pattern_status";
end;

define constant <_cairo-pattern-type> = limited(<integer>, min: 0, max: 3);
define constant $CAIRO-PATTERN-TYPE-SOLID :: <_cairo-pattern-type> = 0;
define constant $CAIRO-PATTERN-TYPE-SURFACE :: <_cairo-pattern-type> = 1;
define constant $CAIRO-PATTERN-TYPE-LINEAR :: <_cairo-pattern-type> = 2;
define constant $CAIRO-PATTERN-TYPE-RADIAL :: <_cairo-pattern-type> = 3;

define constant <cairo-pattern-type-t> = <_cairo-pattern-type>;

define C-function cairo-pattern-get-type
  input parameter pattern :: <cairo-pattern-t>;
  result res :: <cairo-pattern-type-t>;
  c-name: "cairo_pattern_get_type";
end;

define C-function cairo-pattern-add-color-stop-rgb
  input parameter pattern :: <cairo-pattern-t>;
  input parameter offset :: <double-float>;
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  c-name: "cairo_pattern_add_color_stop_rgb";
end;

define C-function cairo-pattern-add-color-stop-rgba
  input parameter pattern :: <cairo-pattern-t>;
  input parameter offset :: <double-float>;
  input parameter red :: <double-float>;
  input parameter green :: <double-float>;
  input parameter blue :: <double-float>;
  input parameter alpha :: <double-float>;
  c-name: "cairo_pattern_add_color_stop_rgba";
end;

define C-function cairo-pattern-set-matrix
  input parameter pattern :: <cairo-pattern-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_pattern_set_matrix";
end;

define C-function cairo-pattern-get-matrix
  input parameter pattern :: <cairo-pattern-t>;
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_pattern_get_matrix";
end;

define constant <_cairo-extend> = limited(<integer>, min: 0, max: 3);
define constant $CAIRO-EXTEND-NONE :: <_cairo-extend> = 0;
define constant $CAIRO-EXTEND-REPEAT :: <_cairo-extend> = 1;
define constant $CAIRO-EXTEND-REFLECT :: <_cairo-extend> = 2;
define constant $CAIRO-EXTEND-PAD :: <_cairo-extend> = 3;

define constant <cairo-extend-t> = <_cairo-extend>;

define C-function cairo-pattern-set-extend
  input parameter pattern :: <cairo-pattern-t>;
  input parameter extend :: <cairo-extend-t>;
  c-name: "cairo_pattern_set_extend";
end;

define C-function cairo-pattern-get-extend
  input parameter pattern :: <cairo-pattern-t>;
  result res :: <cairo-extend-t>;
  c-name: "cairo_pattern_get_extend";
end;

define constant <_cairo-filter> = limited(<integer>, min: 0, max: 5);
define constant $CAIRO-FILTER-FAST :: <_cairo-filter> = 0;
define constant $CAIRO-FILTER-GOOD :: <_cairo-filter> = 1;
define constant $CAIRO-FILTER-BEST :: <_cairo-filter> = 2;
define constant $CAIRO-FILTER-NEAREST :: <_cairo-filter> = 3;
define constant $CAIRO-FILTER-BILINEAR :: <_cairo-filter> = 4;
define constant $CAIRO-FILTER-GAUSSIAN :: <_cairo-filter> = 5;

define constant <cairo-filter-t> = <_cairo-filter>;

define C-function cairo-pattern-set-filter
  input parameter pattern :: <cairo-pattern-t>;
  input parameter filter :: <cairo-filter-t>;
  c-name: "cairo_pattern_set_filter";
end;

define C-function cairo-pattern-get-filter
  input parameter pattern :: <cairo-pattern-t>;
  result res :: <cairo-filter-t>;
  c-name: "cairo_pattern_get_filter";
end;

define C-function cairo-matrix-init
  input parameter matrix :: <cairo-matrix-t>;
  input parameter xx :: <double-float>;
  input parameter yx :: <double-float>;
  input parameter xy :: <double-float>;
  input parameter yy :: <double-float>;
  input parameter x0 :: <double-float>;
  input parameter y0 :: <double-float>;
  c-name: "cairo_matrix_init";
end;

define C-function cairo-matrix-init-identity
  input parameter matrix :: <cairo-matrix-t>;
  c-name: "cairo_matrix_init_identity";
end;

define C-function cairo-matrix-init-translate
  input parameter matrix :: <cairo-matrix-t>;
  input parameter tx :: <double-float>;
  input parameter ty :: <double-float>;
  c-name: "cairo_matrix_init_translate";
end;

define C-function cairo-matrix-init-scale
  input parameter matrix :: <cairo-matrix-t>;
  input parameter sx :: <double-float>;
  input parameter sy :: <double-float>;
  c-name: "cairo_matrix_init_scale";
end;

define C-function cairo-matrix-init-rotate
  input parameter matrix :: <cairo-matrix-t>;
  input parameter radians :: <double-float>;
  c-name: "cairo_matrix_init_rotate";
end;

define C-function cairo-matrix-translate
  input parameter matrix :: <cairo-matrix-t>;
  input parameter tx :: <double-float>;
  input parameter ty :: <double-float>;
  c-name: "cairo_matrix_translate";
end;

define C-function cairo-matrix-scale
  input parameter matrix :: <cairo-matrix-t>;
  input parameter sx :: <double-float>;
  input parameter sy :: <double-float>;
  c-name: "cairo_matrix_scale";
end;

define C-function cairo-matrix-rotate
  input parameter matrix :: <cairo-matrix-t>;
  input parameter radians :: <double-float>;
  c-name: "cairo_matrix_rotate";
end;

define C-function cairo-matrix-invert
  input parameter matrix :: <cairo-matrix-t>;
  result res :: <cairo-status-t>;
  c-name: "cairo_matrix_invert";
end;

define C-function cairo-matrix-multiply
  input parameter result :: <cairo-matrix-t>;
  input parameter a :: <cairo-matrix-t>;
  input parameter b :: <cairo-matrix-t>;
  c-name: "cairo_matrix_multiply";
end;

define C-function cairo-matrix-transform-distance
  input parameter matrix :: <cairo-matrix-t>;
  input parameter dx :: <double*>;
  input parameter dy :: <double*>;
  c-name: "cairo_matrix_transform_distance";
end;

define C-function cairo-matrix-transform-point
  input parameter matrix :: <cairo-matrix-t>;
  input parameter x :: <double*>;
  input parameter y :: <double*>;
  c-name: "cairo_matrix_transform_point";
end;

define C-function cairo-debug-reset-static-data
  c-name: "cairo_debug_reset_static_data";
end;

define constant $CAIRO-VERSION = 10206;

define constant $CAIRO-VERSION-MAJOR = 1;

define constant $CAIRO-VERSION-MINOR = 2;

define constant $CAIRO-VERSION-MICRO = 6;

define constant $CAIRO-VERSION-STRING = "1.2.6";

define constant $CAIRO-HAS-SVG-SURFACE = 1;

define constant $CAIRO-HAS-PDF-SURFACE = 1;

define constant $CAIRO-HAS-PS-SURFACE = 1;

define constant $CAIRO-HAS-FT-FONT = 1;

define constant $CAIRO-HAS-PNG-FUNCTIONS = 1;

define constant $CAIRO-HAS-WIN32-FONT = 1;

define constant $CAIRO-HAS-WIN32-SURFACE = 1;

define C-function gdk-drawable-get-type
  result res :: <GType>;
  c-name: "gdk_drawable_get_type";
end;

define C-function gdk-drawable-set-data
  input parameter drawable :: <GdkDrawable>;
  input parameter key :: <c-string>;
  input parameter data :: <gpointer>;
  input parameter destroy_func :: <GDestroyNotify>;
  c-name: "gdk_drawable_set_data";
end;

define C-function gdk-drawable-get-data
  input parameter drawable :: <GdkDrawable>;
  input parameter key :: <c-string>;
  result res :: <gpointer>;
  c-name: "gdk_drawable_get_data";
end;

define C-function gdk-drawable-get-depth
  input parameter drawable :: <GdkDrawable>;
  result res :: <gint>;
  c-name: "gdk_drawable_get_depth";
end;

define C-function gdk-drawable-get-screen
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkScreen>;
  c-name: "gdk_drawable_get_screen";
end;

define C-function gdk-drawable-get-display
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkDisplay>;
  c-name: "gdk_drawable_get_display";
end;

define C-function gdk-draw-point
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_draw_point";
end;

define C-function gdk-draw-line
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x1_ :: <gint>;
  input parameter y1_ :: <gint>;
  input parameter x2_ :: <gint>;
  input parameter y2_ :: <gint>;
  c-name: "gdk_draw_line";
end;

define C-function gdk-draw-rectangle
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter filled :: <gboolean>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_draw_rectangle";
end;

define C-function gdk-draw-arc
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter filled :: <gboolean>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter angle1 :: <gint>;
  input parameter angle2 :: <gint>;
  c-name: "gdk_draw_arc";
end;

define C-function gdk-draw-polygon
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter filled :: <gboolean>;
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  c-name: "gdk_draw_polygon";
end;

define C-function gdk-draw-string
  input parameter drawable :: <GdkDrawable>;
  input parameter font :: <GdkFont>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter string :: <c-string>;
  c-name: "gdk_draw_string";
end;

define C-function gdk-draw-text
  input parameter drawable :: <GdkDrawable>;
  input parameter font :: <GdkFont>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter text :: <c-string>;
  input parameter text_length :: <gint>;
  c-name: "gdk_draw_text";
end;

define C-function gdk-draw-text-wc
  input parameter drawable :: <GdkDrawable>;
  input parameter font :: <GdkFont>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter text :: <GdkWChar*>;
  input parameter text_length :: <gint>;
  c-name: "gdk_draw_text_wc";
end;

define C-function gdk-draw-drawable
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter src :: <GdkDrawable>;
  input parameter xsrc :: <gint>;
  input parameter ysrc :: <gint>;
  input parameter xdest :: <gint>;
  input parameter ydest :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_draw_drawable";
end;

define C-function gdk-draw-image
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter image :: <GdkImage>;
  input parameter xsrc :: <gint>;
  input parameter ysrc :: <gint>;
  input parameter xdest :: <gint>;
  input parameter ydest :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gdk_draw_image";
end;

define C-function gdk-draw-points
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  c-name: "gdk_draw_points";
end;

define C-function gdk-draw-segments
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter segs :: <GdkSegment>;
  input parameter nsegs :: <gint>;
  c-name: "gdk_draw_segments";
end;

define C-function gdk-draw-lines
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  c-name: "gdk_draw_lines";
end;

define C-function gdk-draw-pixbuf
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter src_x :: <gint>;
  input parameter src_y :: <gint>;
  input parameter dest_x :: <gint>;
  input parameter dest_y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dither :: <GdkRgbDither>;
  input parameter x_dither :: <gint>;
  input parameter y_dither :: <gint>;
  c-name: "gdk_draw_pixbuf";
end;

define C-function gdk-draw-glyphs
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter font :: <PangoFont>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter glyphs :: <PangoGlyphString>;
  c-name: "gdk_draw_glyphs";
end;

define C-function gdk-draw-layout-line
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter line :: <PangoLayoutLine>;
  c-name: "gdk_draw_layout_line";
end;

define C-function gdk-draw-layout
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter layout :: <PangoLayout>;
  c-name: "gdk_draw_layout";
end;

define C-function gdk-draw-layout-line-with-colors
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter line :: <PangoLayoutLine>;
  input parameter foreground :: <GdkColor>;
  input parameter background :: <GdkColor>;
  c-name: "gdk_draw_layout_line_with_colors";
end;

define C-function gdk-draw-layout-with-colors
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter layout :: <PangoLayout>;
  input parameter foreground :: <GdkColor>;
  input parameter background :: <GdkColor>;
  c-name: "gdk_draw_layout_with_colors";
end;

define C-function gdk-draw-glyphs-transformed
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter matrix :: <PangoMatrix>;
  input parameter font :: <PangoFont>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter glyphs :: <PangoGlyphString>;
  c-name: "gdk_draw_glyphs_transformed";
end;

define C-function gdk-draw-trapezoids
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter trapezoids :: <GdkTrapezoid>;
  input parameter n_trapezoids :: <gint>;
  c-name: "gdk_draw_trapezoids";
end;

define C-function gdk-drawable-get-image
  input parameter drawable :: <GdkDrawable>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GdkImage>;
  c-name: "gdk_drawable_get_image";
end;

define C-function gdk-drawable-copy-to-image
  input parameter drawable :: <GdkDrawable>;
  input parameter image :: <GdkImage>;
  input parameter src_x :: <gint>;
  input parameter src_y :: <gint>;
  input parameter dest_x :: <gint>;
  input parameter dest_y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GdkImage>;
  c-name: "gdk_drawable_copy_to_image";
end;

define C-function gdk-drawable-get-clip-region
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkRegion>;
  c-name: "gdk_drawable_get_clip_region";
end;

define C-function gdk-drawable-get-visible-region
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkRegion>;
  c-name: "gdk_drawable_get_visible_region";
end;

define constant gdk-draw-pixmap = gdk-draw-drawable;

define constant gdk-draw-bitmap = gdk-draw-drawable;

define C-function gdk-pixbuf-alpha-mode-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_alpha_mode_get_type";
end;

define C-function gdk-colorspace-get-type
  result res :: <GType>;
  c-name: "gdk_colorspace_get_type";
end;

define C-function gdk-pixbuf-error-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_error_get_type";
end;

define C-function gdk-interp-type-get-type
  result res :: <GType>;
  c-name: "gdk_interp_type_get_type";
end;

define C-function gdk-pixbuf-rotation-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_rotation_get_type";
end;

define C-subtype <_GdkPixbufLoader> (<C-void*>) end;
define constant <GdkPixbufLoader> = <_GdkPixbufLoader>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2432>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2433>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2434>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2435>"*/
define C-subtype <_GdkPixbufLoaderClass> (<C-void*>) end;
define constant <GdkPixbufLoaderClass> = <_GdkPixbufLoaderClass>;

define C-function gdk-pixbuf-loader-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_loader_get_type";
end;

define C-function gdk-pixbuf-loader-new
  result res :: <GdkPixbufLoader>;
  c-name: "gdk_pixbuf_loader_new";
end;

define C-function gdk-pixbuf-loader-new-with-type
  input parameter image_type :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbufLoader>;
  c-name: "gdk_pixbuf_loader_new_with_type";
end;

define C-function gdk-pixbuf-loader-new-with-mime-type
  input parameter mime_type :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbufLoader>;
  c-name: "gdk_pixbuf_loader_new_with_mime_type";
end;

define C-function gdk-pixbuf-loader-set-size
  input parameter loader :: <GdkPixbufLoader>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  c-name: "gdk_pixbuf_loader_set_size";
end;

define C-function gdk-pixbuf-loader-write
  input parameter loader :: <GdkPixbufLoader>;
  input parameter buf :: <guchar*>;
  input parameter count :: <gsize>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_loader_write";
end;

define C-function gdk-pixbuf-loader-get-pixbuf
  input parameter loader :: <GdkPixbufLoader>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_loader_get_pixbuf";
end;

define C-subtype <_GdkPixbufAnimation> (<C-void*>) end;
define constant <GdkPixbufAnimation> = <_GdkPixbufAnimation>;

define C-function gdk-pixbuf-loader-get-animation
  input parameter loader :: <GdkPixbufLoader>;
  result res :: <GdkPixbufAnimation>;
  c-name: "gdk_pixbuf_loader_get_animation";
end;

define C-function gdk-pixbuf-loader-close
  input parameter loader :: <GdkPixbufLoader>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_loader_close";
end;

define C-subtype <_GdkPixbufFormat> (<C-void*>) end;
define constant <GdkPixbufFormat> = <_GdkPixbufFormat>;

define C-function gdk-pixbuf-loader-get-format
  input parameter loader :: <GdkPixbufLoader>;
  result res :: <GdkPixbufFormat>;
  c-name: "gdk_pixbuf_loader_get_format";
end;

define C-function gdk-pixbuf-get-formats
  result res :: <GSList>;
  c-name: "gdk_pixbuf_get_formats";
end;

define C-function gdk-pixbuf-format-get-name
  input parameter format :: <GdkPixbufFormat>;
  result res :: <c-string>;
  c-name: "gdk_pixbuf_format_get_name";
end;

define C-function gdk-pixbuf-format-get-description
  input parameter format :: <GdkPixbufFormat>;
  result res :: <c-string>;
  c-name: "gdk_pixbuf_format_get_description";
end;

define C-function gdk-pixbuf-format-get-mime-types
  input parameter format :: <GdkPixbufFormat>;
  result res :: <gchar**>;
  c-name: "gdk_pixbuf_format_get_mime_types";
end;

define C-function gdk-pixbuf-format-get-extensions
  input parameter format :: <GdkPixbufFormat>;
  result res :: <gchar**>;
  c-name: "gdk_pixbuf_format_get_extensions";
end;

define C-function gdk-pixbuf-format-is-writable
  input parameter format :: <GdkPixbufFormat>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_format_is_writable";
end;

define C-function gdk-pixbuf-format-is-scalable
  input parameter format :: <GdkPixbufFormat>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_format_is_scalable";
end;

define C-function gdk-pixbuf-format-is-disabled
  input parameter format :: <GdkPixbufFormat>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_format_is_disabled";
end;

define C-function gdk-pixbuf-format-set-disabled
  input parameter format :: <GdkPixbufFormat>;
  input parameter disabled :: <gboolean>;
  c-name: "gdk_pixbuf_format_set_disabled";
end;

define C-function gdk-pixbuf-format-get-license
  input parameter format :: <GdkPixbufFormat>;
  result res :: <c-string>;
  c-name: "gdk_pixbuf_format_get_license";
end;

define C-function gdk-pixbuf-get-file-info
  input parameter filename :: <c-string>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  result res :: <GdkPixbufFormat>;
  c-name: "gdk_pixbuf_get_file_info";
end;

define C-subtype <_GdkPixbufAnimationIter> (<C-void*>) end;
define constant <GdkPixbufAnimationIter> = <_GdkPixbufAnimationIter>;

define C-function gdk-pixbuf-animation-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_animation_get_type";
end;

define C-function gdk-pixbuf-animation-new-from-file-utf8
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbufAnimation>;
  c-name: "gdk_pixbuf_animation_new_from_file_utf8";
end;

define C-function gdk-pixbuf-animation-ref
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <GdkPixbufAnimation>;
  c-name: "gdk_pixbuf_animation_ref";
end;

define C-function gdk-pixbuf-animation-unref
  input parameter animation :: <GdkPixbufAnimation>;
  c-name: "gdk_pixbuf_animation_unref";
end;

define C-function gdk-pixbuf-animation-get-width
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_animation_get_width";
end;

define C-function gdk-pixbuf-animation-get-height
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_animation_get_height";
end;

define C-function gdk-pixbuf-animation-is-static-image
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_animation_is_static_image";
end;

define C-function gdk-pixbuf-animation-get-static-image
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_animation_get_static_image";
end;

define C-function gdk-pixbuf-animation-get-iter
  input parameter animation :: <GdkPixbufAnimation>;
  input parameter start_time :: <GTimeVal>;
  result res :: <GdkPixbufAnimationIter>;
  c-name: "gdk_pixbuf_animation_get_iter";
end;

define C-function gdk-pixbuf-animation-iter-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_animation_iter_get_type";
end;

define C-function gdk-pixbuf-animation-iter-get-delay-time
  input parameter iter :: <GdkPixbufAnimationIter>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_animation_iter_get_delay_time";
end;

define C-function gdk-pixbuf-animation-iter-get-pixbuf
  input parameter iter :: <GdkPixbufAnimationIter>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_animation_iter_get_pixbuf";
end;

define C-function gdk-pixbuf-animation-iter-on-currently-loading-frame
  input parameter iter :: <GdkPixbufAnimationIter>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_animation_iter_on_currently_loading_frame";
end;

define C-function gdk-pixbuf-animation-iter-advance
  input parameter iter :: <GdkPixbufAnimationIter>;
  input parameter current_time :: <GTimeVal>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_animation_iter_advance";
end;

define constant gdk-pixbuf-animation-new-from-file = gdk-pixbuf-animation-new-from-file-utf8;

define constant <GdkPixbufAlphaMode> = limited(<integer>, min: 0, max: 1);
define constant $GDK-PIXBUF-ALPHA-BILEVEL :: <GdkPixbufAlphaMode> = 0;
define constant $GDK-PIXBUF-ALPHA-FULL :: <GdkPixbufAlphaMode> = 1;

define constant <GdkColorspace> = limited(<integer>, min: 0, max: 0);
define constant $GDK-COLORSPACE-RGB :: <GdkColorspace> = 0;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2348>"*/
define constant <GdkPixbufDestroyNotify> = <anonymous-2348>;

define constant <GdkPixbufError> = limited(<integer>, min: 0, max: 5);
define constant $GDK-PIXBUF-ERROR-CORRUPT-IMAGE :: <GdkPixbufError> = 0;
define constant $GDK-PIXBUF-ERROR-INSUFFICIENT-MEMORY :: <GdkPixbufError> = 1;
define constant $GDK-PIXBUF-ERROR-BAD-OPTION :: <GdkPixbufError> = 2;
define constant $GDK-PIXBUF-ERROR-UNKNOWN-TYPE :: <GdkPixbufError> = 3;
define constant $GDK-PIXBUF-ERROR-UNSUPPORTED-OPERATION :: <GdkPixbufError> = 4;
define constant $GDK-PIXBUF-ERROR-FAILED :: <GdkPixbufError> = 5;

define C-function gdk-pixbuf-error-quark
  result res :: <GQuark>;
  c-name: "gdk_pixbuf_error_quark";
end;

define C-function gdk-pixbuf-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_get_type";
end;

define C-function gdk-pixbuf-ref
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_ref";
end;

define C-function gdk-pixbuf-unref
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_unref";
end;

define C-function gdk-pixbuf-get-colorspace
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GdkColorspace>;
  c-name: "gdk_pixbuf_get_colorspace";
end;

define C-function gdk-pixbuf-get-n-channels
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_get_n_channels";
end;

define C-function gdk-pixbuf-get-has-alpha
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_get_has_alpha";
end;

define C-function gdk-pixbuf-get-bits-per-sample
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_get_bits_per_sample";
end;

define C-function gdk-pixbuf-get-pixels
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <guchar*>;
  c-name: "gdk_pixbuf_get_pixels";
end;

define C-function gdk-pixbuf-get-width
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_get_width";
end;

define C-function gdk-pixbuf-get-height
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_get_height";
end;

define C-function gdk-pixbuf-get-rowstride
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <integer>;
  c-name: "gdk_pixbuf_get_rowstride";
end;

define C-function gdk-pixbuf-new
  input parameter colorspace :: <GdkColorspace>;
  input parameter has_alpha :: <gboolean>;
  input parameter bits_per_sample :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new";
end;

define C-function gdk-pixbuf-copy
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_copy";
end;

define C-function gdk-pixbuf-new-subpixbuf
  input parameter src_pixbuf :: <GdkPixbuf>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_subpixbuf";
end;

define C-function gdk-pixbuf-new-from-file-utf8
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_file_utf8";
end;

define C-function gdk-pixbuf-new-from-file-at-size-utf8
  input parameter filename :: <c-string>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_file_at_size_utf8";
end;

define C-function gdk-pixbuf-new-from-file-at-scale-utf8
  input parameter filename :: <c-string>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter preserve_aspect_ratio :: <gboolean>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_file_at_scale_utf8";
end;

define C-function gdk-pixbuf-new-from-data
  input parameter data :: <guchar*>;
  input parameter colorspace :: <GdkColorspace>;
  input parameter has_alpha :: <gboolean>;
  input parameter bits_per_sample :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter rowstride :: <integer>;
  input parameter destroy_fn :: <GdkPixbufDestroyNotify>;
  input parameter destroy_fn_data :: <gpointer>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_data";
end;

define C-function gdk-pixbuf-new-from-xpm-data
  input parameter data :: <c-string-vector>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_xpm_data";
end;

define C-function gdk-pixbuf-new-from-inline
  input parameter data_length :: <gint>;
  input parameter data :: <guint8*>;
  input parameter copy_pixels :: <gboolean>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_new_from_inline";
end;

define C-function gdk-pixbuf-fill
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter pixel :: <guint32>;
  c-name: "gdk_pixbuf_fill";
end;

define C-function gdk-pixbuf-save-utf8
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter filename :: <c-string>;
  input parameter type :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_save_utf8";
end;

define C-function gdk-pixbuf-savev-utf8
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter filename :: <c-string>;
  input parameter type :: <c-string>;
  input parameter option_keys :: <c-string-vector>;
  input parameter option_values :: <c-string-vector>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_savev_utf8";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2374>"*/
define constant <GdkPixbufSaveFunc> = <anonymous-2374>;

define C-function gdk-pixbuf-save-to-callback
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter save_func :: <GdkPixbufSaveFunc>;
  input parameter user_data :: <gpointer>;
  input parameter type :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_save_to_callback";
end;

define C-function gdk-pixbuf-save-to-callbackv
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter save_func :: <GdkPixbufSaveFunc>;
  input parameter user_data :: <gpointer>;
  input parameter type :: <c-string>;
  input parameter option_keys :: <c-string-vector>;
  input parameter option_values :: <c-string-vector>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_save_to_callbackv";
end;

define C-function gdk-pixbuf-save-to-buffer
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter buffer :: <gchar**>;
  input parameter buffer_size :: <gsize*>;
  input parameter type :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_save_to_buffer";
end;

define C-function gdk-pixbuf-save-to-bufferv
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter buffer :: <gchar**>;
  input parameter buffer_size :: <gsize*>;
  input parameter type :: <c-string>;
  input parameter option_keys :: <c-string-vector>;
  input parameter option_values :: <c-string-vector>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_pixbuf_save_to_bufferv";
end;

define C-function gdk-pixbuf-add-alpha
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter substitute_color :: <gboolean>;
  input parameter r :: <guchar>;
  input parameter g :: <guchar>;
  input parameter b :: <guchar>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_add_alpha";
end;

define C-function gdk-pixbuf-copy-area
  input parameter src_pixbuf :: <GdkPixbuf>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter dest_pixbuf :: <GdkPixbuf>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  c-name: "gdk_pixbuf_copy_area";
end;

define C-function gdk-pixbuf-saturate-and-pixelate
  input parameter src :: <GdkPixbuf>;
  input parameter dest :: <GdkPixbuf>;
  input parameter saturation :: <gfloat>;
  input parameter pixelate :: <gboolean>;
  c-name: "gdk_pixbuf_saturate_and_pixelate";
end;

define C-function gdk-pixbuf-get-option
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter key :: <c-string>;
  result res :: <c-string>;
  c-name: "gdk_pixbuf_get_option";
end;

define constant gdk-pixbuf-new-from-file = gdk-pixbuf-new-from-file-utf8;

define constant gdk-pixbuf-new-from-file-at-size = gdk-pixbuf-new-from-file-at-size-utf8;

define constant gdk-pixbuf-new-from-file-at-scale = gdk-pixbuf-new-from-file-at-scale-utf8;

define constant gdk-pixbuf-save = gdk-pixbuf-save-utf8;

define constant gdk-pixbuf-savev = gdk-pixbuf-savev-utf8;

define constant <GModuleFlags> = limited(<integer>, min: 1, max: 3);
define constant $G-MODULE-BIND-LAZY :: <GModuleFlags> = 1;
define constant $G-MODULE-BIND-LOCAL :: <GModuleFlags> = 2;
define constant $G-MODULE-BIND-MASK :: <GModuleFlags> = 3;

define C-subtype <_GModule> (<C-void*>) end;
define constant <GModule> = <_GModule>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2411>"*/
define constant <GModuleCheckInit> = <anonymous-2411>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2412>"*/
define constant <GModuleUnload> = <anonymous-2412>;

define C-function g-module-supported
  result res :: <gboolean>;
  c-name: "g_module_supported";
end;

define C-function g-module-open-utf8
  input parameter file_name :: <c-string>;
  input parameter flags :: <GModuleFlags>;
  result res :: <GModule>;
  c-name: "g_module_open_utf8";
end;

define C-function g-module-close
  input parameter module :: <GModule>;
  result res :: <gboolean>;
  c-name: "g_module_close";
end;

define C-function g-module-make-resident
  input parameter module :: <GModule>;
  c-name: "g_module_make_resident";
end;

define C-function g-module-error
  result res :: <c-string>;
  c-name: "g_module_error";
end;

define C-function g-module-symbol
  input parameter module :: <GModule>;
  input parameter symbol_name :: <c-string>;
  input parameter symbol :: <gpointer*>;
  result res :: <gboolean>;
  c-name: "g_module_symbol";
end;

define C-function g-module-name-utf8
  input parameter module :: <GModule>;
  result res :: <c-string>;
  c-name: "g_module_name_utf8";
end;

define C-function g-module-build-path
  input parameter directory :: <c-string>;
  input parameter module_name :: <c-string>;
  result res :: <c-string>;
  c-name: "g_module_build_path";
end;

define constant g-module-open = g-module-open-utf8;

define constant g-module-name = g-module-name-utf8;

define C-subtype <_GdkPixbufSimpleAnim> (<C-void*>) end;
define constant <GdkPixbufSimpleAnim> = <_GdkPixbufSimpleAnim>;

define C-subtype <_GdkPixbufSimpleAnimClass> (<C-void*>) end;
define constant <GdkPixbufSimpleAnimClass> = <_GdkPixbufSimpleAnimClass>;

define C-function gdk-pixbuf-simple-anim-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_simple_anim_get_type";
end;

define C-function gdk-pixbuf-simple-anim-iter-get-type
  result res :: <GType>;
  c-name: "gdk_pixbuf_simple_anim_iter_get_type";
end;

define C-function gdk-pixbuf-simple-anim-new
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter rate :: <gfloat>;
  result res :: <GdkPixbufSimpleAnim>;
  c-name: "gdk_pixbuf_simple_anim_new";
end;

define C-function gdk-pixbuf-simple-anim-add-frame
  input parameter animation :: <GdkPixbufSimpleAnim>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_simple_anim_add_frame";
end;

define constant <GdkInterpType> = limited(<integer>, min: 0, max: 3);
define constant $GDK-INTERP-NEAREST :: <GdkInterpType> = 0;
define constant $GDK-INTERP-TILES :: <GdkInterpType> = 1;
define constant $GDK-INTERP-BILINEAR :: <GdkInterpType> = 2;
define constant $GDK-INTERP-HYPER :: <GdkInterpType> = 3;

define constant <GdkPixbufRotation> = limited(<integer>, min: 0, max: 270);
define constant $GDK-PIXBUF-ROTATE-NONE :: <GdkPixbufRotation> = 0;
define constant $GDK-PIXBUF-ROTATE-COUNTERCLOCKWISE :: <GdkPixbufRotation> = 90;
define constant $GDK-PIXBUF-ROTATE-UPSIDEDOWN :: <GdkPixbufRotation> = 180;
define constant $GDK-PIXBUF-ROTATE-CLOCKWISE :: <GdkPixbufRotation> = 270;

define C-function gdk-pixbuf-scale
  input parameter src :: <GdkPixbuf>;
  input parameter dest :: <GdkPixbuf>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter dest_width :: <integer>;
  input parameter dest_height :: <integer>;
  input parameter offset_x :: <double-float>;
  input parameter offset_y :: <double-float>;
  input parameter scale_x :: <double-float>;
  input parameter scale_y :: <double-float>;
  input parameter interp_type :: <GdkInterpType>;
  c-name: "gdk_pixbuf_scale";
end;

define C-function gdk-pixbuf-composite
  input parameter src :: <GdkPixbuf>;
  input parameter dest :: <GdkPixbuf>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter dest_width :: <integer>;
  input parameter dest_height :: <integer>;
  input parameter offset_x :: <double-float>;
  input parameter offset_y :: <double-float>;
  input parameter scale_x :: <double-float>;
  input parameter scale_y :: <double-float>;
  input parameter interp_type :: <GdkInterpType>;
  input parameter overall_alpha :: <integer>;
  c-name: "gdk_pixbuf_composite";
end;

define C-function gdk-pixbuf-composite-color
  input parameter src :: <GdkPixbuf>;
  input parameter dest :: <GdkPixbuf>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter dest_width :: <integer>;
  input parameter dest_height :: <integer>;
  input parameter offset_x :: <double-float>;
  input parameter offset_y :: <double-float>;
  input parameter scale_x :: <double-float>;
  input parameter scale_y :: <double-float>;
  input parameter interp_type :: <GdkInterpType>;
  input parameter overall_alpha :: <integer>;
  input parameter check_x :: <integer>;
  input parameter check_y :: <integer>;
  input parameter check_size :: <integer>;
  input parameter color1 :: <guint32>;
  input parameter color2 :: <guint32>;
  c-name: "gdk_pixbuf_composite_color";
end;

define C-function gdk-pixbuf-scale-simple
  input parameter src :: <GdkPixbuf>;
  input parameter dest_width :: <integer>;
  input parameter dest_height :: <integer>;
  input parameter interp_type :: <GdkInterpType>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_scale_simple";
end;

define C-function gdk-pixbuf-composite-color-simple
  input parameter src :: <GdkPixbuf>;
  input parameter dest_width :: <integer>;
  input parameter dest_height :: <integer>;
  input parameter interp_type :: <GdkInterpType>;
  input parameter overall_alpha :: <integer>;
  input parameter check_size :: <integer>;
  input parameter color1 :: <guint32>;
  input parameter color2 :: <guint32>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_composite_color_simple";
end;

define C-function gdk-pixbuf-rotate-simple
  input parameter src :: <GdkPixbuf>;
  input parameter angle :: <GdkPixbufRotation>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_rotate_simple";
end;

define C-function gdk-pixbuf-flip
  input parameter src :: <GdkPixbuf>;
  input parameter horizontal :: <gboolean>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_flip";
end;

 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-pixbuf-major-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-pixbuf-minor-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-pixbuf-micro-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gdk-pixbuf-version"*/
define constant $GDK-PIXBUF-FEATURES-H = 1;

define constant $GDK-PIXBUF-MAJOR = 2;

define constant $GDK-PIXBUF-MINOR = 10;

define constant $GDK-PIXBUF-MICRO = 11;

define constant $GDK-PIXBUF-VERSION = "2.10.11";

 /* Ignoring declaration for {instance of <vector-declaration>} "<guint32<@256>>"*/
define C-subtype <_GdkRgbCmap> (<C-void*>) end;
define constant <GdkRgbCmap> = <_GdkRgbCmap>;

define C-function gdk-rgb-init
  c-name: "gdk_rgb_init";
end;

define C-function gdk-rgb-xpixel-from-rgb
  input parameter rgb :: <guint32>;
  result res :: <gulong>;
  c-name: "gdk_rgb_xpixel_from_rgb";
end;

define C-function gdk-rgb-gc-set-foreground
  input parameter gc :: <GdkGC>;
  input parameter rgb :: <guint32>;
  c-name: "gdk_rgb_gc_set_foreground";
end;

define C-function gdk-rgb-gc-set-background
  input parameter gc :: <GdkGC>;
  input parameter rgb :: <guint32>;
  c-name: "gdk_rgb_gc_set_background";
end;

define C-function gdk-rgb-find-color
  input parameter colormap :: <GdkColormap>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_rgb_find_color";
end;

define C-function gdk-draw-rgb-image
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter rgb_buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  c-name: "gdk_draw_rgb_image";
end;

define C-function gdk-draw-rgb-image-dithalign
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter rgb_buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  input parameter xdith :: <gint>;
  input parameter ydith :: <gint>;
  c-name: "gdk_draw_rgb_image_dithalign";
end;

define C-function gdk-draw-rgb-32-image
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  c-name: "gdk_draw_rgb_32_image";
end;

define C-function gdk-draw-rgb-32-image-dithalign
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  input parameter xdith :: <gint>;
  input parameter ydith :: <gint>;
  c-name: "gdk_draw_rgb_32_image_dithalign";
end;

define C-function gdk-draw-gray-image
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  c-name: "gdk_draw_gray_image";
end;

define C-function gdk-draw-indexed-image
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter dith :: <GdkRgbDither>;
  input parameter buf :: <guchar*>;
  input parameter rowstride :: <gint>;
  input parameter cmap :: <GdkRgbCmap>;
  c-name: "gdk_draw_indexed_image";
end;

define C-function gdk-rgb-cmap-new
  input parameter colors :: <guint32*>;
  input parameter n_colors :: <gint>;
  result res :: <GdkRgbCmap>;
  c-name: "gdk_rgb_cmap_new";
end;

define C-function gdk-rgb-cmap-free
  input parameter cmap :: <GdkRgbCmap>;
  c-name: "gdk_rgb_cmap_free";
end;

define C-function gdk-rgb-set-verbose
  input parameter verbose :: <gboolean>;
  c-name: "gdk_rgb_set_verbose";
end;

define C-function gdk-rgb-set-install
  input parameter install :: <gboolean>;
  c-name: "gdk_rgb_set_install";
end;

define C-function gdk-rgb-set-min-colors
  input parameter min_colors :: <gint>;
  c-name: "gdk_rgb_set_min_colors";
end;

define C-function gdk-rgb-get-colormap
  result res :: <GdkColormap>;
  c-name: "gdk_rgb_get_colormap";
end;

define C-function gdk-rgb-get-visual
  result res :: <GdkVisual>;
  c-name: "gdk_rgb_get_visual";
end;

define C-function gdk-rgb-ditherable
  result res :: <gboolean>;
  c-name: "gdk_rgb_ditherable";
end;

define C-function gdk-rgb-colormap-ditherable
  input parameter cmap :: <GdkColormap>;
  result res :: <gboolean>;
  c-name: "gdk_rgb_colormap_ditherable";
end;

define constant gdk-rgb-get-cmap = gdk-rgb-get-colormap;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2621>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2622>"*/
define C-pointer-type <gint8*> => <gint8>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<gint8<@>>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2623>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2624>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2625>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2626>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2627>"*/
define C-subtype <_GdkGCClass> (<C-void*>) end;
define constant <GdkGCClass> = <_GdkGCClass>;

define C-function gdk-gc-get-type
  result res :: <GType>;
  c-name: "gdk_gc_get_type";
end;

define C-function gdk-gc-new
  input parameter drawable :: <GdkDrawable>;
  result res :: <GdkGC>;
  c-name: "gdk_gc_new";
end;

define C-function gdk-gc-new-with-values
  input parameter drawable :: <GdkDrawable>;
  input parameter values :: <GdkGCValues>;
  input parameter values_mask :: <GdkGCValuesMask>;
  result res :: <GdkGC>;
  c-name: "gdk_gc_new_with_values";
end;

define C-function gdk-gc-ref
  input parameter gc :: <GdkGC>;
  result res :: <GdkGC>;
  c-name: "gdk_gc_ref";
end;

define C-function gdk-gc-unref
  input parameter gc :: <GdkGC>;
  c-name: "gdk_gc_unref";
end;

define C-function gdk-gc-get-values
  input parameter gc :: <GdkGC>;
  input parameter values :: <GdkGCValues>;
  c-name: "gdk_gc_get_values";
end;

define C-function gdk-gc-set-values
  input parameter gc :: <GdkGC>;
  input parameter values :: <GdkGCValues>;
  input parameter values_mask :: <GdkGCValuesMask>;
  c-name: "gdk_gc_set_values";
end;

define C-function gdk-gc-set-foreground
  input parameter gc :: <GdkGC>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_gc_set_foreground";
end;

define C-function gdk-gc-set-background
  input parameter gc :: <GdkGC>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_gc_set_background";
end;

define C-function gdk-gc-set-font
  input parameter gc :: <GdkGC>;
  input parameter font :: <GdkFont>;
  c-name: "gdk_gc_set_font";
end;

define C-function gdk-gc-set-function
  input parameter gc :: <GdkGC>;
  input parameter function :: <GdkFunction>;
  c-name: "gdk_gc_set_function";
end;

define C-function gdk-gc-set-fill
  input parameter gc :: <GdkGC>;
  input parameter fill :: <GdkFill>;
  c-name: "gdk_gc_set_fill";
end;

define C-function gdk-gc-set-tile
  input parameter gc :: <GdkGC>;
  input parameter tile :: <GdkPixmap>;
  c-name: "gdk_gc_set_tile";
end;

define C-function gdk-gc-set-stipple
  input parameter gc :: <GdkGC>;
  input parameter stipple :: <GdkPixmap>;
  c-name: "gdk_gc_set_stipple";
end;

define C-function gdk-gc-set-ts-origin
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_gc_set_ts_origin";
end;

define C-function gdk-gc-set-clip-origin
  input parameter gc :: <GdkGC>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_gc_set_clip_origin";
end;

define C-function gdk-gc-set-clip-mask
  input parameter gc :: <GdkGC>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gdk_gc_set_clip_mask";
end;

define C-function gdk-gc-set-clip-rectangle
  input parameter gc :: <GdkGC>;
  input parameter rectangle :: <GdkRectangle>;
  c-name: "gdk_gc_set_clip_rectangle";
end;

define C-function gdk-gc-set-clip-region
  input parameter gc :: <GdkGC>;
  input parameter region :: <GdkRegion>;
  c-name: "gdk_gc_set_clip_region";
end;

define C-function gdk-gc-set-subwindow
  input parameter gc :: <GdkGC>;
  input parameter mode :: <GdkSubwindowMode>;
  c-name: "gdk_gc_set_subwindow";
end;

define C-function gdk-gc-set-exposures
  input parameter gc :: <GdkGC>;
  input parameter exposures :: <gboolean>;
  c-name: "gdk_gc_set_exposures";
end;

define C-function gdk-gc-set-line-attributes
  input parameter gc :: <GdkGC>;
  input parameter line_width :: <gint>;
  input parameter line_style :: <GdkLineStyle>;
  input parameter cap_style :: <GdkCapStyle>;
  input parameter join_style :: <GdkJoinStyle>;
  c-name: "gdk_gc_set_line_attributes";
end;

define C-function gdk-gc-set-dashes
  input parameter gc :: <GdkGC>;
  input parameter dash_offset :: <gint>;
  input parameter dash_list :: <gint8<@>>;
  input parameter n :: <gint>;
  c-name: "gdk_gc_set_dashes";
end;

define C-function gdk-gc-offset
  input parameter gc :: <GdkGC>;
  input parameter x_offset :: <gint>;
  input parameter y_offset :: <gint>;
  c-name: "gdk_gc_offset";
end;

define C-function gdk-gc-copy
  input parameter dst_gc :: <GdkGC>;
  input parameter src_gc :: <GdkGC>;
  c-name: "gdk_gc_copy";
end;

define C-function gdk-gc-set-colormap
  input parameter gc :: <GdkGC>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gdk_gc_set_colormap";
end;

define C-function gdk-gc-get-colormap
  input parameter gc :: <GdkGC>;
  result res :: <GdkColormap>;
  c-name: "gdk_gc_get_colormap";
end;

define C-function gdk-gc-set-rgb-fg-color
  input parameter gc :: <GdkGC>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_gc_set_rgb_fg_color";
end;

define C-function gdk-gc-set-rgb-bg-color
  input parameter gc :: <GdkGC>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_gc_set_rgb_bg_color";
end;

define C-function gdk-gc-get-screen
  input parameter gc :: <GdkGC>;
  result res :: <GdkScreen>;
  c-name: "gdk_gc_get_screen";
end;

define constant gdk-gc-destroy = gdk-gc-unref;

define C-subtype <_GdkVisualClass> (<C-void*>) end;
define constant <GdkVisualClass> = <_GdkVisualClass>;

define C-function gdk-visual-get-type
  result res :: <GType>;
  c-name: "gdk_visual_get_type";
end;

define C-function gdk-visual-get-best-depth
  result res :: <gint>;
  c-name: "gdk_visual_get_best_depth";
end;

define C-function gdk-visual-get-best-type
  result res :: <GdkVisualType>;
  c-name: "gdk_visual_get_best_type";
end;

define C-function gdk-visual-get-system
  result res :: <GdkVisual>;
  c-name: "gdk_visual_get_system";
end;

define C-function gdk-visual-get-best
  result res :: <GdkVisual>;
  c-name: "gdk_visual_get_best";
end;

define C-function gdk-visual-get-best-with-depth
  input parameter depth :: <gint>;
  result res :: <GdkVisual>;
  c-name: "gdk_visual_get_best_with_depth";
end;

define C-function gdk-visual-get-best-with-type
  input parameter visual_type :: <GdkVisualType>;
  result res :: <GdkVisual>;
  c-name: "gdk_visual_get_best_with_type";
end;

define C-function gdk-visual-get-best-with-both
  input parameter depth :: <gint>;
  input parameter visual_type :: <GdkVisualType>;
  result res :: <GdkVisual>;
  c-name: "gdk_visual_get_best_with_both";
end;

define C-function gdk-query-depths
  input parameter depths :: <gint**>;
  input parameter count :: <gint*>;
  c-name: "gdk_query_depths";
end;

define C-pointer-type <GdkVisualType*> => <GdkVisualType>;
define C-pointer-type <GdkVisualType**> => <GdkVisualType*>;
define C-function gdk-query-visual-types
  input parameter visual_types :: <GdkVisualType**>;
  input parameter count :: <gint*>;
  c-name: "gdk_query_visual_types";
end;

define C-function gdk-list-visuals
  result res :: <GList>;
  c-name: "gdk_list_visuals";
end;

define C-function gdk-visual-get-screen
  input parameter visual :: <GdkVisual>;
  result res :: <GdkScreen>;
  c-name: "gdk_visual_get_screen";
end;

define C-function gdk-spawn-on-screen
  input parameter screen :: <GdkScreen>;
  input parameter working_directory :: <c-string>;
  input parameter argv :: <gchar**>;
  input parameter envp :: <gchar**>;
  input parameter flags :: <GSpawnFlags>;
  input parameter child_setup :: <GSpawnChildSetupFunc>;
  input parameter user_data :: <gpointer>;
  input parameter child_pid :: <gint*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_spawn_on_screen";
end;

define C-function gdk-spawn-on-screen-with-pipes
  input parameter screen :: <GdkScreen>;
  input parameter working_directory :: <c-string>;
  input parameter argv :: <gchar**>;
  input parameter envp :: <gchar**>;
  input parameter flags :: <GSpawnFlags>;
  input parameter child_setup :: <GSpawnChildSetupFunc>;
  input parameter user_data :: <gpointer>;
  input parameter child_pid :: <gint*>;
  input parameter standard_input :: <gint*>;
  input parameter standard_output :: <gint*>;
  input parameter standard_error :: <gint*>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_spawn_on_screen_with_pipes";
end;

define C-function gdk-spawn-command-line-on-screen
  input parameter screen :: <GdkScreen>;
  input parameter command_line :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gdk_spawn_command_line_on_screen";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2910>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2911>"*/
define C-subtype <_GdkScreenClass> (<C-void*>) end;
define constant <GdkScreenClass> = <_GdkScreenClass>;

define C-function gdk-screen-get-type
  result res :: <GType>;
  c-name: "gdk_screen_get_type";
end;

define C-function gdk-screen-get-default-colormap
  input parameter screen :: <GdkScreen>;
  result res :: <GdkColormap>;
  c-name: "gdk_screen_get_default_colormap";
end;

define C-function gdk-screen-set-default-colormap
  input parameter screen :: <GdkScreen>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gdk_screen_set_default_colormap";
end;

define C-function gdk-screen-get-system-colormap
  input parameter screen :: <GdkScreen>;
  result res :: <GdkColormap>;
  c-name: "gdk_screen_get_system_colormap";
end;

define C-function gdk-screen-get-system-visual
  input parameter screen :: <GdkScreen>;
  result res :: <GdkVisual>;
  c-name: "gdk_screen_get_system_visual";
end;

define C-function gdk-screen-get-rgb-colormap
  input parameter screen :: <GdkScreen>;
  result res :: <GdkColormap>;
  c-name: "gdk_screen_get_rgb_colormap";
end;

define C-function gdk-screen-get-rgb-visual
  input parameter screen :: <GdkScreen>;
  result res :: <GdkVisual>;
  c-name: "gdk_screen_get_rgb_visual";
end;

define C-function gdk-screen-get-rgba-colormap
  input parameter screen :: <GdkScreen>;
  result res :: <GdkColormap>;
  c-name: "gdk_screen_get_rgba_colormap";
end;

define C-function gdk-screen-get-rgba-visual
  input parameter screen :: <GdkScreen>;
  result res :: <GdkVisual>;
  c-name: "gdk_screen_get_rgba_visual";
end;

define C-function gdk-screen-is-composited
  input parameter screen :: <GdkScreen>;
  result res :: <gboolean>;
  c-name: "gdk_screen_is_composited";
end;

define C-function gdk-screen-get-root-window
  input parameter screen :: <GdkScreen>;
  result res :: <GdkWindow>;
  c-name: "gdk_screen_get_root_window";
end;

define C-function gdk-screen-get-display
  input parameter screen :: <GdkScreen>;
  result res :: <GdkDisplay>;
  c-name: "gdk_screen_get_display";
end;

define C-function gdk-screen-get-number
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_number";
end;

define C-function gdk-screen-get-width
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_width";
end;

define C-function gdk-screen-get-height
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_height";
end;

define C-function gdk-screen-get-width-mm
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_width_mm";
end;

define C-function gdk-screen-get-height-mm
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_height_mm";
end;

define C-function gdk-screen-list-visuals
  input parameter screen :: <GdkScreen>;
  result res :: <GList>;
  c-name: "gdk_screen_list_visuals";
end;

define C-function gdk-screen-get-toplevel-windows
  input parameter screen :: <GdkScreen>;
  result res :: <GList>;
  c-name: "gdk_screen_get_toplevel_windows";
end;

define C-function gdk-screen-make-display-name
  input parameter screen :: <GdkScreen>;
  result res :: <c-string>;
  c-name: "gdk_screen_make_display_name";
end;

define C-function gdk-screen-get-n-monitors
  input parameter screen :: <GdkScreen>;
  result res :: <gint>;
  c-name: "gdk_screen_get_n_monitors";
end;

define C-function gdk-screen-get-monitor-geometry
  input parameter screen :: <GdkScreen>;
  input parameter monitor_num :: <gint>;
  input parameter dest :: <GdkRectangle>;
  c-name: "gdk_screen_get_monitor_geometry";
end;

define C-function gdk-screen-get-monitor-at-point
  input parameter screen :: <GdkScreen>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <gint>;
  c-name: "gdk_screen_get_monitor_at_point";
end;

define C-function gdk-screen-get-monitor-at-window
  input parameter screen :: <GdkScreen>;
  input parameter window :: <GdkWindow>;
  result res :: <gint>;
  c-name: "gdk_screen_get_monitor_at_window";
end;

define C-function gdk-screen-broadcast-client-message
  input parameter screen :: <GdkScreen>;
  input parameter event :: <GdkEvent>;
  c-name: "gdk_screen_broadcast_client_message";
end;

define C-function gdk-screen-get-default
  result res :: <GdkScreen>;
  c-name: "gdk_screen_get_default";
end;

define C-function gdk-screen-get-setting
  input parameter screen :: <GdkScreen>;
  input parameter name :: <c-string>;
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "gdk_screen_get_setting";
end;

define C-function gdk-screen-set-font-options
  input parameter screen :: <GdkScreen>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "gdk_screen_set_font_options";
end;

define C-function gdk-screen-get-font-options
  input parameter screen :: <GdkScreen>;
  result res :: <cairo-font-options-t>;
  c-name: "gdk_screen_get_font_options";
end;

define C-function gdk-screen-set-resolution
  input parameter screen :: <GdkScreen>;
  input parameter dpi :: <gdouble>;
  c-name: "gdk_screen_set_resolution";
end;

define C-function gdk-screen-get-resolution
  input parameter screen :: <GdkScreen>;
  result res :: <gdouble>;
  c-name: "gdk_screen_get_resolution";
end;

define C-function gdk-screen-get-active-window
  input parameter screen :: <GdkScreen>;
  result res :: <GdkWindow>;
  c-name: "gdk_screen_get_active_window";
end;

define C-function gdk-screen-get-window-stack
  input parameter screen :: <GdkScreen>;
  result res :: <GList>;
  c-name: "gdk_screen_get_window_stack";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2568>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2569>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2570>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2571>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2572>"*/
define C-subtype <_GdkDisplayClass> (<C-void*>) end;
define constant <GdkDisplayClass> = <_GdkDisplayClass>;

define C-function gdk-display-get-type
  result res :: <GType>;
  c-name: "gdk_display_get_type";
end;

define C-function gdk-display-open
  input parameter display_name :: <c-string>;
  result res :: <GdkDisplay>;
  c-name: "gdk_display_open";
end;

define C-function gdk-display-get-name
  input parameter display :: <GdkDisplay>;
  result res :: <c-string>;
  c-name: "gdk_display_get_name";
end;

define C-function gdk-display-get-n-screens
  input parameter display :: <GdkDisplay>;
  result res :: <gint>;
  c-name: "gdk_display_get_n_screens";
end;

define C-function gdk-display-get-screen
  input parameter display :: <GdkDisplay>;
  input parameter screen_num :: <gint>;
  result res :: <GdkScreen>;
  c-name: "gdk_display_get_screen";
end;

define C-function gdk-display-get-default-screen
  input parameter display :: <GdkDisplay>;
  result res :: <GdkScreen>;
  c-name: "gdk_display_get_default_screen";
end;

define C-function gdk-display-pointer-ungrab
  input parameter display :: <GdkDisplay>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_display_pointer_ungrab";
end;

define C-function gdk-display-keyboard-ungrab
  input parameter display :: <GdkDisplay>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_display_keyboard_ungrab";
end;

define C-function gdk-display-pointer-is-grabbed
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_pointer_is_grabbed";
end;

define C-function gdk-display-beep
  input parameter display :: <GdkDisplay>;
  c-name: "gdk_display_beep";
end;

define C-function gdk-display-sync
  input parameter display :: <GdkDisplay>;
  c-name: "gdk_display_sync";
end;

define C-function gdk-display-flush
  input parameter display :: <GdkDisplay>;
  c-name: "gdk_display_flush";
end;

define C-function gdk-display-close
  input parameter display :: <GdkDisplay>;
  c-name: "gdk_display_close";
end;

define C-function gdk-display-list-devices
  input parameter display :: <GdkDisplay>;
  result res :: <GList>;
  c-name: "gdk_display_list_devices";
end;

define C-function gdk-display-get-event
  input parameter display :: <GdkDisplay>;
  result res :: <GdkEvent>;
  c-name: "gdk_display_get_event";
end;

define C-function gdk-display-peek-event
  input parameter display :: <GdkDisplay>;
  result res :: <GdkEvent>;
  c-name: "gdk_display_peek_event";
end;

define C-function gdk-display-put-event
  input parameter display :: <GdkDisplay>;
  input parameter event :: <GdkEvent>;
  c-name: "gdk_display_put_event";
end;

define C-function gdk-display-add-client-message-filter
  input parameter display :: <GdkDisplay>;
  input parameter message_type :: <GdkAtom>;
  input parameter func :: <GdkFilterFunc>;
  input parameter data :: <gpointer>;
  c-name: "gdk_display_add_client_message_filter";
end;

define C-function gdk-display-set-double-click-time
  input parameter display :: <GdkDisplay>;
  input parameter msec :: <guint>;
  c-name: "gdk_display_set_double_click_time";
end;

define C-function gdk-display-set-double-click-distance
  input parameter display :: <GdkDisplay>;
  input parameter distance :: <guint>;
  c-name: "gdk_display_set_double_click_distance";
end;

define C-function gdk-display-get-default
  result res :: <GdkDisplay>;
  c-name: "gdk_display_get_default";
end;

define C-function gdk-display-get-core-pointer
  input parameter display :: <GdkDisplay>;
  result res :: <GdkDevice>;
  c-name: "gdk_display_get_core_pointer";
end;

define C-function gdk-display-get-pointer
  input parameter display :: <GdkDisplay>;
  input parameter screen :: <GdkScreen*>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter mask :: <GdkModifierType*>;
  c-name: "gdk_display_get_pointer";
end;

define C-function gdk-display-get-window-at-pointer
  input parameter display :: <GdkDisplay>;
  input parameter win_x :: <gint*>;
  input parameter win_y :: <gint*>;
  result res :: <GdkWindow>;
  c-name: "gdk_display_get_window_at_pointer";
end;

define C-function gdk-display-warp-pointer
  input parameter display :: <GdkDisplay>;
  input parameter screen :: <GdkScreen>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gdk_display_warp_pointer";
end;

define C-function gdk-display-set-pointer-hooks
  input parameter display :: <GdkDisplay>;
  input parameter new_hooks :: <GdkDisplayPointerHooks>;
  result res :: <GdkDisplayPointerHooks>;
  c-name: "gdk_display_set_pointer_hooks";
end;

define C-function gdk-display-open-default-libgtk-only
  result res :: <GdkDisplay>;
  c-name: "gdk_display_open_default_libgtk_only";
end;

define C-function gdk-display-supports-cursor-alpha
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_cursor_alpha";
end;

define C-function gdk-display-supports-cursor-color
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_cursor_color";
end;

define C-function gdk-display-get-default-cursor-size
  input parameter display :: <GdkDisplay>;
  result res :: <guint>;
  c-name: "gdk_display_get_default_cursor_size";
end;

define C-function gdk-display-get-maximal-cursor-size
  input parameter display :: <GdkDisplay>;
  input parameter width :: <guint*>;
  input parameter height :: <guint*>;
  c-name: "gdk_display_get_maximal_cursor_size";
end;

define C-function gdk-display-get-default-group
  input parameter display :: <GdkDisplay>;
  result res :: <GdkWindow>;
  c-name: "gdk_display_get_default_group";
end;

define C-function gdk-display-supports-selection-notification
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_selection_notification";
end;

define C-function gdk-display-request-selection-notification
  input parameter display :: <GdkDisplay>;
  input parameter selection :: <GdkAtom>;
  result res :: <gboolean>;
  c-name: "gdk_display_request_selection_notification";
end;

define C-function gdk-display-supports-clipboard-persistence
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_clipboard_persistence";
end;

define C-pointer-type <GdkAtom*> => <GdkAtom>;
define C-function gdk-display-store-clipboard
  input parameter display :: <GdkDisplay>;
  input parameter clipboard_window :: <GdkWindow>;
  input parameter time_ :: <guint32>;
  input parameter targets :: <GdkAtom*>;
  input parameter n_targets :: <gint>;
  c-name: "gdk_display_store_clipboard";
end;

define C-function gdk-display-supports-shapes
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_shapes";
end;

define C-function gdk-display-supports-input-shapes
  input parameter display :: <GdkDisplay>;
  result res :: <gboolean>;
  c-name: "gdk_display_supports_input_shapes";
end;

define constant <GdkSelection> = <GdkAtom>;

define constant <GdkTarget> = <GdkAtom>;

define constant <GdkSelectionType> = <GdkAtom>;

define C-function gdk-selection-owner-set
  input parameter owner :: <GdkWindow>;
  input parameter selection :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  input parameter send_event :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gdk_selection_owner_set";
end;

define C-function gdk-selection-owner-get
  input parameter selection :: <GdkAtom>;
  result res :: <GdkWindow>;
  c-name: "gdk_selection_owner_get";
end;

define C-function gdk-selection-owner-set-for-display
  input parameter display :: <GdkDisplay>;
  input parameter owner :: <GdkWindow>;
  input parameter selection :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  input parameter send_event :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gdk_selection_owner_set_for_display";
end;

define C-function gdk-selection-owner-get-for-display
  input parameter display :: <GdkDisplay>;
  input parameter selection :: <GdkAtom>;
  result res :: <GdkWindow>;
  c-name: "gdk_selection_owner_get_for_display";
end;

define C-function gdk-selection-convert
  input parameter requestor :: <GdkWindow>;
  input parameter selection :: <GdkAtom>;
  input parameter target :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_selection_convert";
end;

define C-function gdk-selection-property-get
  input parameter requestor :: <GdkWindow>;
  input parameter data :: <guchar**>;
  input parameter prop_type :: <GdkAtom*>;
  input parameter prop_format :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_selection_property_get";
end;

define C-function gdk-selection-send-notify
  input parameter requestor :: <guint32>;
  input parameter selection :: <GdkAtom>;
  input parameter target :: <GdkAtom>;
  input parameter property :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_selection_send_notify";
end;

define C-function gdk-selection-send-notify-for-display
  input parameter display :: <GdkDisplay>;
  input parameter requestor :: <guint32>;
  input parameter selection :: <GdkAtom>;
  input parameter target :: <GdkAtom>;
  input parameter property :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  c-name: "gdk_selection_send_notify_for_display";
end;

define constant <GdkFillRule> = limited(<integer>, min: 0, max: 1);
define constant $GDK-EVEN-ODD-RULE :: <GdkFillRule> = 0;
define constant $GDK-WINDING-RULE :: <GdkFillRule> = 1;

define constant <GdkOverlapType> = limited(<integer>, min: 0, max: 2);
define constant $GDK-OVERLAP-RECTANGLE-IN :: <GdkOverlapType> = 0;
define constant $GDK-OVERLAP-RECTANGLE-OUT :: <GdkOverlapType> = 1;
define constant $GDK-OVERLAP-RECTANGLE-PART :: <GdkOverlapType> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2889>"*/
define constant <GdkSpanFunc> = <anonymous-2889>;

define C-function gdk-region-new
  result res :: <GdkRegion>;
  c-name: "gdk_region_new";
end;

define C-function gdk-region-polygon
  input parameter points :: <GdkPoint>;
  input parameter npoints :: <gint>;
  input parameter fill_rule :: <GdkFillRule>;
  result res :: <GdkRegion>;
  c-name: "gdk_region_polygon";
end;

define C-function gdk-region-copy
  input parameter region :: <GdkRegion>;
  result res :: <GdkRegion>;
  c-name: "gdk_region_copy";
end;

define C-function gdk-region-rectangle
  input parameter rectangle :: <GdkRectangle>;
  result res :: <GdkRegion>;
  c-name: "gdk_region_rectangle";
end;

define C-function gdk-region-destroy
  input parameter region :: <GdkRegion>;
  c-name: "gdk_region_destroy";
end;

define C-function gdk-region-get-clipbox
  input parameter region :: <GdkRegion>;
  input parameter rectangle :: <GdkRectangle>;
  c-name: "gdk_region_get_clipbox";
end;

define C-pointer-type <GdkRectangle*> => <GdkRectangle>;
define C-function gdk-region-get-rectangles
  input parameter region :: <GdkRegion>;
  input parameter rectangles :: <GdkRectangle*>;
  input parameter n_rectangles :: <gint*>;
  c-name: "gdk_region_get_rectangles";
end;

define C-function gdk-region-empty
  input parameter region :: <GdkRegion>;
  result res :: <gboolean>;
  c-name: "gdk_region_empty";
end;

define C-function gdk-region-equal
  input parameter region1 :: <GdkRegion>;
  input parameter region2 :: <GdkRegion>;
  result res :: <gboolean>;
  c-name: "gdk_region_equal";
end;

define C-function gdk-region-point-in
  input parameter region :: <GdkRegion>;
  input parameter x :: <integer>;
  input parameter y :: <integer>;
  result res :: <gboolean>;
  c-name: "gdk_region_point_in";
end;

define C-function gdk-region-rect-in
  input parameter region :: <GdkRegion>;
  input parameter rectangle :: <GdkRectangle>;
  result res :: <GdkOverlapType>;
  c-name: "gdk_region_rect_in";
end;

define C-function gdk-region-offset
  input parameter region :: <GdkRegion>;
  input parameter dx :: <gint>;
  input parameter dy :: <gint>;
  c-name: "gdk_region_offset";
end;

define C-function gdk-region-shrink
  input parameter region :: <GdkRegion>;
  input parameter dx :: <gint>;
  input parameter dy :: <gint>;
  c-name: "gdk_region_shrink";
end;

define C-function gdk-region-union-with-rect
  input parameter region :: <GdkRegion>;
  input parameter rect :: <GdkRectangle>;
  c-name: "gdk_region_union_with_rect";
end;

define C-function gdk-region-intersect
  input parameter source1 :: <GdkRegion>;
  input parameter source2 :: <GdkRegion>;
  c-name: "gdk_region_intersect";
end;

define C-function gdk-region-union
  input parameter source1 :: <GdkRegion>;
  input parameter source2 :: <GdkRegion>;
  c-name: "gdk_region_union";
end;

define C-function gdk-region-subtract
  input parameter source1 :: <GdkRegion>;
  input parameter source2 :: <GdkRegion>;
  c-name: "gdk_region_subtract";
end;

define C-function gdk-region-xor
  input parameter source1 :: <GdkRegion>;
  input parameter source2 :: <GdkRegion>;
  c-name: "gdk_region_xor";
end;

define C-function gdk-region-spans-intersect-foreach
  input parameter region :: <GdkRegion>;
  input parameter spans :: <GdkSpan>;
  input parameter n_spans :: <integer>;
  input parameter sorted :: <gboolean>;
  input parameter function :: <GdkSpanFunc>;
  input parameter data :: <gpointer>;
  c-name: "gdk_region_spans_intersect_foreach";
end;

define constant <GdkPropMode> = limited(<integer>, min: 0, max: 2);
define constant $GDK-PROP-MODE-REPLACE :: <GdkPropMode> = 0;
define constant $GDK-PROP-MODE-PREPEND :: <GdkPropMode> = 1;
define constant $GDK-PROP-MODE-APPEND :: <GdkPropMode> = 2;

define C-function gdk-atom-intern
  input parameter atom_name :: <c-string>;
  input parameter only_if_exists :: <gboolean>;
  result res :: <GdkAtom>;
  c-name: "gdk_atom_intern";
end;

define C-function gdk-atom-intern-static-string
  input parameter atom_name :: <c-string>;
  result res :: <GdkAtom>;
  c-name: "gdk_atom_intern_static_string";
end;

define C-function gdk-atom-name
  input parameter atom :: <GdkAtom>;
  result res :: <c-string>;
  c-name: "gdk_atom_name";
end;

define C-function gdk-property-get
  input parameter window :: <GdkWindow>;
  input parameter property :: <GdkAtom>;
  input parameter type :: <GdkAtom>;
  input parameter offset :: <gulong>;
  input parameter length :: <gulong>;
  input parameter pdelete :: <gint>;
  input parameter actual_property_type :: <GdkAtom*>;
  input parameter actual_format :: <gint*>;
  input parameter actual_length :: <gint*>;
  input parameter data :: <guchar**>;
  result res :: <gboolean>;
  c-name: "gdk_property_get";
end;

define C-function gdk-property-change
  input parameter window :: <GdkWindow>;
  input parameter property :: <GdkAtom>;
  input parameter type :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter mode :: <GdkPropMode>;
  input parameter data :: <guchar*>;
  input parameter nelements :: <gint>;
  c-name: "gdk_property_change";
end;

define C-function gdk-property-delete
  input parameter window :: <GdkWindow>;
  input parameter property :: <GdkAtom>;
  c-name: "gdk_property_delete";
end;

define C-function gdk-text-property-to-text-list
  input parameter encoding :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter text :: <guchar*>;
  input parameter length :: <gint>;
  input parameter list :: <gchar***>;
  result res :: <gint>;
  c-name: "gdk_text_property_to_text_list";
end;

define C-function gdk-text-property-to-utf8-list
  input parameter encoding :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter text :: <guchar*>;
  input parameter length :: <gint>;
  input parameter list :: <gchar***>;
  result res :: <gint>;
  c-name: "gdk_text_property_to_utf8_list";
end;

define C-function gdk-utf8-to-compound-text
  input parameter str :: <c-string>;
  input parameter encoding :: <GdkAtom*>;
  input parameter format :: <gint*>;
  input parameter ctext :: <guchar**>;
  input parameter length :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_utf8_to_compound_text";
end;

define C-function gdk-string-to-compound-text
  input parameter str :: <c-string>;
  input parameter encoding :: <GdkAtom*>;
  input parameter format :: <gint*>;
  input parameter ctext :: <guchar**>;
  input parameter length :: <gint*>;
  result res :: <gint>;
  c-name: "gdk_string_to_compound_text";
end;

define C-function gdk-text-property-to-text-list-for-display
  input parameter display :: <GdkDisplay>;
  input parameter encoding :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter text :: <guchar*>;
  input parameter length :: <gint>;
  input parameter list :: <gchar***>;
  result res :: <gint>;
  c-name: "gdk_text_property_to_text_list_for_display";
end;

define C-function gdk-text-property-to-utf8-list-for-display
  input parameter display :: <GdkDisplay>;
  input parameter encoding :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter text :: <guchar*>;
  input parameter length :: <gint>;
  input parameter list :: <gchar***>;
  result res :: <gint>;
  c-name: "gdk_text_property_to_utf8_list_for_display";
end;

define C-function gdk-utf8-to-string-target
  input parameter str :: <c-string>;
  result res :: <c-string>;
  c-name: "gdk_utf8_to_string_target";
end;

define C-function gdk-string-to-compound-text-for-display
  input parameter display :: <GdkDisplay>;
  input parameter str :: <c-string>;
  input parameter encoding :: <GdkAtom*>;
  input parameter format :: <gint*>;
  input parameter ctext :: <guchar**>;
  input parameter length :: <gint*>;
  result res :: <gint>;
  c-name: "gdk_string_to_compound_text_for_display";
end;

define C-function gdk-utf8-to-compound-text-for-display
  input parameter display :: <GdkDisplay>;
  input parameter str :: <c-string>;
  input parameter encoding :: <GdkAtom*>;
  input parameter format :: <gint*>;
  input parameter ctext :: <guchar**>;
  input parameter length :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_utf8_to_compound_text_for_display";
end;

define C-function gdk-free-text-list
  input parameter list :: <gchar**>;
  c-name: "gdk_free_text_list";
end;

define C-function gdk-free-compound-text
  input parameter ctext :: <guchar*>;
  c-name: "gdk_free_compound_text";
end;

define C-subtype <_GdkPixmapObject> (<C-void*>) end;
define constant <GdkPixmapObject> = <_GdkPixmapObject>;

define C-subtype <_GdkPixmapObjectClass> (<C-void*>) end;
define constant <GdkPixmapObjectClass> = <_GdkPixmapObjectClass>;

define C-function gdk-pixmap-get-type
  result res :: <GType>;
  c-name: "gdk_pixmap_get_type";
end;

define C-function gdk-pixmap-new
  input parameter drawable :: <GdkDrawable>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter depth :: <gint>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_new";
end;

define C-function gdk-bitmap-create-from-data
  input parameter drawable :: <GdkDrawable>;
  input parameter data :: <c-string>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GdkBitmap>;
  c-name: "gdk_bitmap_create_from_data";
end;

define C-function gdk-pixmap-create-from-data
  input parameter drawable :: <GdkDrawable>;
  input parameter data :: <c-string>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter depth :: <gint>;
  input parameter fg :: <GdkColor>;
  input parameter bg :: <GdkColor>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_create_from_data";
end;

define C-pointer-type <GdkBitmap*> => <GdkBitmap>;
define C-function gdk-pixmap-create-from-xpm
  input parameter drawable :: <GdkDrawable>;
  input parameter mask :: <GdkBitmap*>;
  input parameter transparent_color :: <GdkColor>;
  input parameter filename :: <c-string>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_create_from_xpm";
end;

define C-function gdk-pixmap-colormap-create-from-xpm
  input parameter drawable :: <GdkDrawable>;
  input parameter colormap :: <GdkColormap>;
  input parameter mask :: <GdkBitmap*>;
  input parameter transparent_color :: <GdkColor>;
  input parameter filename :: <c-string>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_colormap_create_from_xpm";
end;

define C-function gdk-pixmap-create-from-xpm-d
  input parameter drawable :: <GdkDrawable>;
  input parameter mask :: <GdkBitmap*>;
  input parameter transparent_color :: <GdkColor>;
  input parameter data :: <gchar**>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_create_from_xpm_d";
end;

define C-function gdk-pixmap-colormap-create-from-xpm-d
  input parameter drawable :: <GdkDrawable>;
  input parameter colormap :: <GdkColormap>;
  input parameter mask :: <GdkBitmap*>;
  input parameter transparent_color :: <GdkColor>;
  input parameter data :: <gchar**>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_colormap_create_from_xpm_d";
end;

define C-function gdk-pixmap-foreign-new
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_foreign_new";
end;

define C-function gdk-pixmap-lookup
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_lookup";
end;

define C-function gdk-pixmap-foreign-new-for-display
  input parameter display :: <GdkDisplay>;
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_foreign_new_for_display";
end;

define C-function gdk-pixmap-lookup-for-display
  input parameter display :: <GdkDisplay>;
  input parameter anid :: <GdkNativeWindow>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_lookup_for_display";
end;

define C-function gdk-pixmap-foreign-new-for-screen
  input parameter screen :: <GdkScreen>;
  input parameter anid :: <GdkNativeWindow>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter depth :: <gint>;
  result res :: <GdkPixmap>;
  c-name: "gdk_pixmap_foreign_new_for_screen";
end;

define constant gdk-bitmap-ref = gdk-drawable-ref;

define constant gdk-bitmap-unref = gdk-drawable-unref;

define constant gdk-pixmap-ref = gdk-drawable-ref;

define constant gdk-pixmap-unref = gdk-drawable-unref;

define C-function gdk-pixbuf-render-threshold-alpha
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter bitmap :: <GdkBitmap>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter alpha_threshold :: <integer>;
  c-name: "gdk_pixbuf_render_threshold_alpha";
end;

define C-function gdk-pixbuf-render-to-drawable
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter drawable :: <GdkDrawable>;
  input parameter gc :: <GdkGC>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter dither :: <GdkRgbDither>;
  input parameter x_dither :: <integer>;
  input parameter y_dither :: <integer>;
  c-name: "gdk_pixbuf_render_to_drawable";
end;

define C-function gdk-pixbuf-render-to-drawable-alpha
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter drawable :: <GdkDrawable>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  input parameter alpha_mode :: <GdkPixbufAlphaMode>;
  input parameter alpha_threshold :: <integer>;
  input parameter dither :: <GdkRgbDither>;
  input parameter x_dither :: <integer>;
  input parameter y_dither :: <integer>;
  c-name: "gdk_pixbuf_render_to_drawable_alpha";
end;

define C-function gdk-pixbuf-render-pixmap-and-mask-for-colormap
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter colormap :: <GdkColormap>;
  input parameter pixmap_return :: <GdkPixmap*>;
  input parameter mask_return :: <GdkBitmap*>;
  input parameter alpha_threshold :: <integer>;
  c-name: "gdk_pixbuf_render_pixmap_and_mask_for_colormap";
end;

define C-function gdk-pixbuf-render-pixmap-and-mask
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter pixmap_return :: <GdkPixmap*>;
  input parameter mask_return :: <GdkBitmap*>;
  input parameter alpha_threshold :: <integer>;
  c-name: "gdk_pixbuf_render_pixmap_and_mask";
end;

define C-function gdk-pixbuf-get-from-drawable
  input parameter dest :: <GdkPixbuf>;
  input parameter src :: <GdkDrawable>;
  input parameter cmap :: <GdkColormap>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_get_from_drawable";
end;

define C-function gdk-pixbuf-get-from-image
  input parameter dest :: <GdkPixbuf>;
  input parameter src :: <GdkImage>;
  input parameter cmap :: <GdkColormap>;
  input parameter src_x :: <integer>;
  input parameter src_y :: <integer>;
  input parameter dest_x :: <integer>;
  input parameter dest_y :: <integer>;
  input parameter width :: <integer>;
  input parameter height :: <integer>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_pixbuf_get_from_image";
end;

define C-subtype <_GdkPangoRendererPrivate> (<C-void*>) end;
define constant <GdkPangoRendererPrivate> = <_GdkPangoRendererPrivate>;

define C-subtype <_GdkPangoRenderer> (<C-void*>) end;
define constant <GdkPangoRenderer> = <_GdkPangoRenderer>;

define C-subtype <_GdkPangoRendererClass> (<C-void*>) end;
define constant <GdkPangoRendererClass> = <_GdkPangoRendererClass>;

define C-function gdk-pango-renderer-get-type
  result res :: <GType>;
  c-name: "gdk_pango_renderer_get_type";
end;

define C-function gdk-pango-renderer-new
  input parameter screen :: <GdkScreen>;
  result res :: <PangoRenderer>;
  c-name: "gdk_pango_renderer_new";
end;

define C-function gdk-pango-renderer-get-default
  input parameter screen :: <GdkScreen>;
  result res :: <PangoRenderer>;
  c-name: "gdk_pango_renderer_get_default";
end;

define C-function gdk-pango-renderer-set-drawable
  input parameter gdk_renderer :: <GdkPangoRenderer>;
  input parameter drawable :: <GdkDrawable>;
  c-name: "gdk_pango_renderer_set_drawable";
end;

define C-function gdk-pango-renderer-set-gc
  input parameter gdk_renderer :: <GdkPangoRenderer>;
  input parameter gc :: <GdkGC>;
  c-name: "gdk_pango_renderer_set_gc";
end;

define C-function gdk-pango-renderer-set-stipple
  input parameter gdk_renderer :: <GdkPangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  input parameter stipple :: <GdkBitmap>;
  c-name: "gdk_pango_renderer_set_stipple";
end;

define C-function gdk-pango-renderer-set-override-color
  input parameter gdk_renderer :: <GdkPangoRenderer>;
  input parameter part :: <PangoRenderPart>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_pango_renderer_set_override_color";
end;

define C-function gdk-pango-context-get-for-screen
  input parameter screen :: <GdkScreen>;
  result res :: <PangoContext>;
  c-name: "gdk_pango_context_get_for_screen";
end;

define C-function gdk-pango-context-get
  result res :: <PangoContext>;
  c-name: "gdk_pango_context_get";
end;

define C-function gdk-pango-context-set-colormap
  input parameter context :: <PangoContext>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gdk_pango_context_set_colormap";
end;

define C-function gdk-pango-layout-line-get-clip-region
  input parameter line :: <PangoLayoutLine>;
  input parameter x_origin :: <gint>;
  input parameter y_origin :: <gint>;
  input parameter index_ranges :: <gint*>;
  input parameter n_ranges :: <gint>;
  result res :: <GdkRegion>;
  c-name: "gdk_pango_layout_line_get_clip_region";
end;

define C-function gdk-pango-layout-get-clip-region
  input parameter layout :: <PangoLayout>;
  input parameter x_origin :: <gint>;
  input parameter y_origin :: <gint>;
  input parameter index_ranges :: <gint*>;
  input parameter n_ranges :: <gint>;
  result res :: <GdkRegion>;
  c-name: "gdk_pango_layout_get_clip_region";
end;

define C-subtype <_GdkPangoAttrStipple> (<C-void*>) end;
define constant <GdkPangoAttrStipple> = <_GdkPangoAttrStipple>;

define C-subtype <_GdkPangoAttrEmbossed> (<C-void*>) end;
define constant <GdkPangoAttrEmbossed> = <_GdkPangoAttrEmbossed>;

define C-function gdk-pango-attr-stipple-new
  input parameter stipple :: <GdkBitmap>;
  result res :: <PangoAttribute>;
  c-name: "gdk_pango_attr_stipple_new";
end;

define C-function gdk-pango-attr-embossed-new
  input parameter embossed :: <gboolean>;
  result res :: <PangoAttribute>;
  c-name: "gdk_pango_attr_embossed_new";
end;

define C-subtype <_GdkDisplayManager> (<C-void*>) end;
define constant <GdkDisplayManager> = <_GdkDisplayManager>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2836>"*/
define C-subtype <_GdkDisplayManagerClass> (<C-void*>) end;
define constant <GdkDisplayManagerClass> = <_GdkDisplayManagerClass>;

define C-function gdk-display-manager-get-type
  result res :: <GType>;
  c-name: "gdk_display_manager_get_type";
end;

define C-function gdk-display-manager-get
  result res :: <GdkDisplayManager>;
  c-name: "gdk_display_manager_get";
end;

define C-function gdk-display-manager-get-default-display
  input parameter display_manager :: <GdkDisplayManager>;
  result res :: <GdkDisplay>;
  c-name: "gdk_display_manager_get_default_display";
end;

define C-function gdk-display-manager-set-default-display
  input parameter display_manager :: <GdkDisplayManager>;
  input parameter display :: <GdkDisplay>;
  c-name: "gdk_display_manager_set_default_display";
end;

define C-function gdk-display-manager-list-displays
  input parameter display_manager :: <GdkDisplayManager>;
  result res :: <GSList>;
  c-name: "gdk_display_manager_list_displays";
end;

define C-subtype <_GdkKeymapKey> (<C-void*>) end;
define constant <GdkKeymapKey> = <_GdkKeymapKey>;

define C-subtype <_GdkKeymap> (<C-void*>) end;
define constant <GdkKeymap> = <_GdkKeymap>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2817>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-2818>"*/
define C-subtype <_GdkKeymapClass> (<C-void*>) end;
define constant <GdkKeymapClass> = <_GdkKeymapClass>;

define C-function gdk-keymap-get-type
  result res :: <GType>;
  c-name: "gdk_keymap_get_type";
end;

define C-function gdk-keymap-get-default
  result res :: <GdkKeymap>;
  c-name: "gdk_keymap_get_default";
end;

define C-function gdk-keymap-get-for-display
  input parameter display :: <GdkDisplay>;
  result res :: <GdkKeymap>;
  c-name: "gdk_keymap_get_for_display";
end;

define C-function gdk-keymap-lookup-key
  input parameter keymap :: <GdkKeymap>;
  input parameter key :: <GdkKeymapKey>;
  result res :: <guint>;
  c-name: "gdk_keymap_lookup_key";
end;

define C-function gdk-keymap-translate-keyboard-state
  input parameter keymap :: <GdkKeymap>;
  input parameter hardware_keycode :: <guint>;
  input parameter state :: <GdkModifierType>;
  input parameter group :: <gint>;
  input parameter keyval :: <guint*>;
  input parameter effective_group :: <gint*>;
  input parameter level :: <gint*>;
  input parameter consumed_modifiers :: <GdkModifierType*>;
  result res :: <gboolean>;
  c-name: "gdk_keymap_translate_keyboard_state";
end;

define C-pointer-type <GdkKeymapKey*> => <GdkKeymapKey>;
define C-function gdk-keymap-get-entries-for-keyval
  input parameter keymap :: <GdkKeymap>;
  input parameter keyval :: <guint>;
  input parameter keys :: <GdkKeymapKey*>;
  input parameter n_keys :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_keymap_get_entries_for_keyval";
end;

define C-pointer-type <guint**> => <guint*>;
define C-function gdk-keymap-get-entries-for-keycode
  input parameter keymap :: <GdkKeymap>;
  input parameter hardware_keycode :: <guint>;
  input parameter keys :: <GdkKeymapKey*>;
  input parameter keyvals :: <guint**>;
  input parameter n_entries :: <gint*>;
  result res :: <gboolean>;
  c-name: "gdk_keymap_get_entries_for_keycode";
end;

define C-function gdk-keymap-get-direction
  input parameter keymap :: <GdkKeymap>;
  result res :: <PangoDirection>;
  c-name: "gdk_keymap_get_direction";
end;

define C-function gdk-keyval-name
  input parameter keyval :: <guint>;
  result res :: <c-string>;
  c-name: "gdk_keyval_name";
end;

define C-function gdk-keyval-from-name
  input parameter keyval_name :: <c-string>;
  result res :: <guint>;
  c-name: "gdk_keyval_from_name";
end;

define C-function gdk-keyval-convert-case
  input parameter symbol :: <guint>;
  input parameter lower :: <guint*>;
  input parameter upper :: <guint*>;
  c-name: "gdk_keyval_convert_case";
end;

define C-function gdk-keyval-to-upper
  input parameter keyval :: <guint>;
  result res :: <guint>;
  c-name: "gdk_keyval_to_upper";
end;

define C-function gdk-keyval-to-lower
  input parameter keyval :: <guint>;
  result res :: <guint>;
  c-name: "gdk_keyval_to_lower";
end;

define C-function gdk-keyval-is-upper
  input parameter keyval :: <guint>;
  result res :: <gboolean>;
  c-name: "gdk_keyval_is_upper";
end;

define C-function gdk-keyval-is-lower
  input parameter keyval :: <guint>;
  result res :: <gboolean>;
  c-name: "gdk_keyval_is_lower";
end;

define C-function gdk-keyval-to-unicode
  input parameter keyval :: <guint>;
  result res :: <guint32>;
  c-name: "gdk_keyval_to_unicode";
end;

define C-function gdk-unicode-to-keyval
  input parameter wc :: <guint32>;
  result res :: <guint>;
  c-name: "gdk_unicode_to_keyval";
end;

define C-subtype <_GdkImageClass> (<C-void*>) end;
define constant <GdkImageClass> = <_GdkImageClass>;

define C-function gdk-image-get-type
  result res :: <GType>;
  c-name: "gdk_image_get_type";
end;

define C-function gdk-image-new
  input parameter type :: <GdkImageType>;
  input parameter visual :: <GdkVisual>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GdkImage>;
  c-name: "gdk_image_new";
end;

define C-function gdk-image-get
  input parameter drawable :: <GdkDrawable>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GdkImage>;
  c-name: "gdk_image_get";
end;

define C-function gdk-image-ref
  input parameter image :: <GdkImage>;
  result res :: <GdkImage>;
  c-name: "gdk_image_ref";
end;

define C-function gdk-image-unref
  input parameter image :: <GdkImage>;
  c-name: "gdk_image_unref";
end;

define C-function gdk-image-put-pixel
  input parameter image :: <GdkImage>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter pixel :: <guint32>;
  c-name: "gdk_image_put_pixel";
end;

define C-function gdk-image-get-pixel
  input parameter image :: <GdkImage>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <guint32>;
  c-name: "gdk_image_get_pixel";
end;

define C-function gdk-image-set-colormap
  input parameter image :: <GdkImage>;
  input parameter colormap :: <GdkColormap>;
  c-name: "gdk_image_set_colormap";
end;

define C-function gdk-image-get-colormap
  input parameter image :: <GdkImage>;
  result res :: <GdkColormap>;
  c-name: "gdk_image_get_colormap";
end;

define constant gdk-image-destroy = gdk-image-unref;

define C-function gdk-font-get-type
  result res :: <GType>;
  c-name: "gdk_font_get_type";
end;

define C-function gdk-font-ref
  input parameter font :: <GdkFont>;
  result res :: <GdkFont>;
  c-name: "gdk_font_ref";
end;

define C-function gdk-font-unref
  input parameter font :: <GdkFont>;
  c-name: "gdk_font_unref";
end;

define C-function gdk-font-id
  input parameter font :: <GdkFont>;
  result res :: <gint>;
  c-name: "gdk_font_id";
end;

define C-function gdk-font-equal
  input parameter fonta :: <GdkFont>;
  input parameter fontb :: <GdkFont>;
  result res :: <gboolean>;
  c-name: "gdk_font_equal";
end;

define C-function gdk-font-load-for-display
  input parameter display :: <GdkDisplay>;
  input parameter font_name :: <c-string>;
  result res :: <GdkFont>;
  c-name: "gdk_font_load_for_display";
end;

define C-function gdk-fontset-load-for-display
  input parameter display :: <GdkDisplay>;
  input parameter fontset_name :: <c-string>;
  result res :: <GdkFont>;
  c-name: "gdk_fontset_load_for_display";
end;

define C-function gdk-font-from-description-for-display
  input parameter display :: <GdkDisplay>;
  input parameter font_desc :: <PangoFontDescription>;
  result res :: <GdkFont>;
  c-name: "gdk_font_from_description_for_display";
end;

define C-function gdk-font-load
  input parameter font_name :: <c-string>;
  result res :: <GdkFont>;
  c-name: "gdk_font_load";
end;

define C-function gdk-fontset-load
  input parameter fontset_name :: <c-string>;
  result res :: <GdkFont>;
  c-name: "gdk_fontset_load";
end;

define C-function gdk-font-from-description
  input parameter font_desc :: <PangoFontDescription>;
  result res :: <GdkFont>;
  c-name: "gdk_font_from_description";
end;

define C-function gdk-string-width
  input parameter font :: <GdkFont>;
  input parameter string :: <c-string>;
  result res :: <gint>;
  c-name: "gdk_string_width";
end;

define C-function gdk-text-width
  input parameter font :: <GdkFont>;
  input parameter text :: <c-string>;
  input parameter text_length :: <gint>;
  result res :: <gint>;
  c-name: "gdk_text_width";
end;

define C-function gdk-text-width-wc
  input parameter font :: <GdkFont>;
  input parameter text :: <GdkWChar*>;
  input parameter text_length :: <gint>;
  result res :: <gint>;
  c-name: "gdk_text_width_wc";
end;

define C-function gdk-char-width
  input parameter font :: <GdkFont>;
  input parameter character :: <gchar>;
  result res :: <gint>;
  c-name: "gdk_char_width";
end;

define C-function gdk-char-width-wc
  input parameter font :: <GdkFont>;
  input parameter character :: <GdkWChar>;
  result res :: <gint>;
  c-name: "gdk_char_width_wc";
end;

define C-function gdk-string-measure
  input parameter font :: <GdkFont>;
  input parameter string :: <c-string>;
  result res :: <gint>;
  c-name: "gdk_string_measure";
end;

define C-function gdk-text-measure
  input parameter font :: <GdkFont>;
  input parameter text :: <c-string>;
  input parameter text_length :: <gint>;
  result res :: <gint>;
  c-name: "gdk_text_measure";
end;

define C-function gdk-char-measure
  input parameter font :: <GdkFont>;
  input parameter character :: <gchar>;
  result res :: <gint>;
  c-name: "gdk_char_measure";
end;

define C-function gdk-string-height
  input parameter font :: <GdkFont>;
  input parameter string :: <c-string>;
  result res :: <gint>;
  c-name: "gdk_string_height";
end;

define C-function gdk-text-height
  input parameter font :: <GdkFont>;
  input parameter text :: <c-string>;
  input parameter text_length :: <gint>;
  result res :: <gint>;
  c-name: "gdk_text_height";
end;

define C-function gdk-char-height
  input parameter font :: <GdkFont>;
  input parameter character :: <gchar>;
  result res :: <gint>;
  c-name: "gdk_char_height";
end;

define C-function gdk-text-extents
  input parameter font :: <GdkFont>;
  input parameter text :: <c-string>;
  input parameter text_length :: <gint>;
  input parameter lbearing :: <gint*>;
  input parameter rbearing :: <gint*>;
  input parameter width :: <gint*>;
  input parameter ascent :: <gint*>;
  input parameter descent :: <gint*>;
  c-name: "gdk_text_extents";
end;

define C-function gdk-text-extents-wc
  input parameter font :: <GdkFont>;
  input parameter text :: <GdkWChar*>;
  input parameter text_length :: <gint>;
  input parameter lbearing :: <gint*>;
  input parameter rbearing :: <gint*>;
  input parameter width :: <gint*>;
  input parameter ascent :: <gint*>;
  input parameter descent :: <gint*>;
  c-name: "gdk_text_extents_wc";
end;

define C-function gdk-string-extents
  input parameter font :: <GdkFont>;
  input parameter string :: <c-string>;
  input parameter lbearing :: <gint*>;
  input parameter rbearing :: <gint*>;
  input parameter width :: <gint*>;
  input parameter ascent :: <gint*>;
  input parameter descent :: <gint*>;
  c-name: "gdk_string_extents";
end;

define C-function gdk-font-get-display
  input parameter font :: <GdkFont>;
  result res :: <GdkDisplay>;
  c-name: "gdk_font_get_display";
end;

define C-function gdk-cursor-type-get-type
  result res :: <GType>;
  c-name: "gdk_cursor_type_get_type";
end;

define C-function gdk-drag-action-get-type
  result res :: <GType>;
  c-name: "gdk_drag_action_get_type";
end;

define C-function gdk-drag-protocol-get-type
  result res :: <GType>;
  c-name: "gdk_drag_protocol_get_type";
end;

define C-function gdk-filter-return-get-type
  result res :: <GType>;
  c-name: "gdk_filter_return_get_type";
end;

define C-function gdk-event-type-get-type
  result res :: <GType>;
  c-name: "gdk_event_type_get_type";
end;

define C-function gdk-event-mask-get-type
  result res :: <GType>;
  c-name: "gdk_event_mask_get_type";
end;

define C-function gdk-visibility-state-get-type
  result res :: <GType>;
  c-name: "gdk_visibility_state_get_type";
end;

define C-function gdk-scroll-direction-get-type
  result res :: <GType>;
  c-name: "gdk_scroll_direction_get_type";
end;

define C-function gdk-notify-type-get-type
  result res :: <GType>;
  c-name: "gdk_notify_type_get_type";
end;

define C-function gdk-crossing-mode-get-type
  result res :: <GType>;
  c-name: "gdk_crossing_mode_get_type";
end;

define C-function gdk-property-state-get-type
  result res :: <GType>;
  c-name: "gdk_property_state_get_type";
end;

define C-function gdk-window-state-get-type
  result res :: <GType>;
  c-name: "gdk_window_state_get_type";
end;

define C-function gdk-setting-action-get-type
  result res :: <GType>;
  c-name: "gdk_setting_action_get_type";
end;

define C-function gdk-owner-change-get-type
  result res :: <GType>;
  c-name: "gdk_owner_change_get_type";
end;

define C-function gdk-font-type-get-type
  result res :: <GType>;
  c-name: "gdk_font_type_get_type";
end;

define C-function gdk-cap-style-get-type
  result res :: <GType>;
  c-name: "gdk_cap_style_get_type";
end;

define C-function gdk-fill-get-type
  result res :: <GType>;
  c-name: "gdk_fill_get_type";
end;

define C-function gdk-function-get-type
  result res :: <GType>;
  c-name: "gdk_function_get_type";
end;

define C-function gdk-join-style-get-type
  result res :: <GType>;
  c-name: "gdk_join_style_get_type";
end;

define C-function gdk-line-style-get-type
  result res :: <GType>;
  c-name: "gdk_line_style_get_type";
end;

define C-function gdk-subwindow-mode-get-type
  result res :: <GType>;
  c-name: "gdk_subwindow_mode_get_type";
end;

define C-function gdk-gc-values-mask-get-type
  result res :: <GType>;
  c-name: "gdk_gc_values_mask_get_type";
end;

define C-function gdk-image-type-get-type
  result res :: <GType>;
  c-name: "gdk_image_type_get_type";
end;

define C-function gdk-extension-mode-get-type
  result res :: <GType>;
  c-name: "gdk_extension_mode_get_type";
end;

define C-function gdk-input-source-get-type
  result res :: <GType>;
  c-name: "gdk_input_source_get_type";
end;

define C-function gdk-input-mode-get-type
  result res :: <GType>;
  c-name: "gdk_input_mode_get_type";
end;

define C-function gdk-axis-use-get-type
  result res :: <GType>;
  c-name: "gdk_axis_use_get_type";
end;

define C-function gdk-prop-mode-get-type
  result res :: <GType>;
  c-name: "gdk_prop_mode_get_type";
end;

define C-function gdk-fill-rule-get-type
  result res :: <GType>;
  c-name: "gdk_fill_rule_get_type";
end;

define C-function gdk-overlap-type-get-type
  result res :: <GType>;
  c-name: "gdk_overlap_type_get_type";
end;

define C-function gdk-rgb-dither-get-type
  result res :: <GType>;
  c-name: "gdk_rgb_dither_get_type";
end;

define C-function gdk-byte-order-get-type
  result res :: <GType>;
  c-name: "gdk_byte_order_get_type";
end;

define C-function gdk-modifier-type-get-type
  result res :: <GType>;
  c-name: "gdk_modifier_type_get_type";
end;

define C-function gdk-input-condition-get-type
  result res :: <GType>;
  c-name: "gdk_input_condition_get_type";
end;

define C-function gdk-status-get-type
  result res :: <GType>;
  c-name: "gdk_status_get_type";
end;

define C-function gdk-grab-status-get-type
  result res :: <GType>;
  c-name: "gdk_grab_status_get_type";
end;

define C-function gdk-visual-type-get-type
  result res :: <GType>;
  c-name: "gdk_visual_type_get_type";
end;

define C-function gdk-window-class-get-type
  result res :: <GType>;
  c-name: "gdk_window_class_get_type";
end;

define C-function gdk-window-type-get-type
  result res :: <GType>;
  c-name: "gdk_window_type_get_type";
end;

define C-function gdk-window-attributes-type-get-type
  result res :: <GType>;
  c-name: "gdk_window_attributes_type_get_type";
end;

define C-function gdk-window-hints-get-type
  result res :: <GType>;
  c-name: "gdk_window_hints_get_type";
end;

define C-function gdk-window-type-hint-get-type
  result res :: <GType>;
  c-name: "gdk_window_type_hint_get_type";
end;

define C-function gdk-wm-decoration-get-type
  result res :: <GType>;
  c-name: "gdk_wm_decoration_get_type";
end;

define C-function gdk-wm-function-get-type
  result res :: <GType>;
  c-name: "gdk_wm_function_get_type";
end;

define C-function gdk-gravity-get-type
  result res :: <GType>;
  c-name: "gdk_gravity_get_type";
end;

define C-function gdk-window-edge-get-type
  result res :: <GType>;
  c-name: "gdk_window_edge_get_type";
end;

define C-function gdk-cursor-get-type
  result res :: <GType>;
  c-name: "gdk_cursor_get_type";
end;

define C-function gdk-cursor-new-for-display
  input parameter display :: <GdkDisplay>;
  input parameter cursor_type :: <GdkCursorType>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_new_for_display";
end;

define C-function gdk-cursor-new
  input parameter cursor_type :: <GdkCursorType>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_new";
end;

define C-function gdk-cursor-new-from-pixmap
  input parameter source :: <GdkPixmap>;
  input parameter mask :: <GdkPixmap>;
  input parameter fg :: <GdkColor>;
  input parameter bg :: <GdkColor>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_new_from_pixmap";
end;

define C-function gdk-cursor-new-from-pixbuf
  input parameter display :: <GdkDisplay>;
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_new_from_pixbuf";
end;

define C-function gdk-cursor-get-display
  input parameter cursor :: <GdkCursor>;
  result res :: <GdkDisplay>;
  c-name: "gdk_cursor_get_display";
end;

define C-function gdk-cursor-ref
  input parameter cursor :: <GdkCursor>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_ref";
end;

define C-function gdk-cursor-unref
  input parameter cursor :: <GdkCursor>;
  c-name: "gdk_cursor_unref";
end;

define C-function gdk-cursor-new-from-name
  input parameter display :: <GdkDisplay>;
  input parameter name :: <c-string>;
  result res :: <GdkCursor>;
  c-name: "gdk_cursor_new_from_name";
end;

define C-function gdk-cursor-get-image
  input parameter cursor :: <GdkCursor>;
  result res :: <GdkPixbuf>;
  c-name: "gdk_cursor_get_image";
end;

define constant gdk-cursor-destroy = gdk-cursor-unref;

define C-function gdk-cairo-create
  input parameter drawable :: <GdkDrawable>;
  result res :: <cairo-t>;
  c-name: "gdk_cairo_create";
end;

define C-function gdk-cairo-set-source-color
  input parameter cr :: <cairo-t>;
  input parameter color :: <GdkColor>;
  c-name: "gdk_cairo_set_source_color";
end;

define C-function gdk-cairo-set-source-pixbuf
  input parameter cr :: <cairo-t>;
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter pixbuf_x :: <double-float>;
  input parameter pixbuf_y :: <double-float>;
  c-name: "gdk_cairo_set_source_pixbuf";
end;

define C-function gdk-cairo-set-source-pixmap
  input parameter cr :: <cairo-t>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter pixmap_x :: <double-float>;
  input parameter pixmap_y :: <double-float>;
  c-name: "gdk_cairo_set_source_pixmap";
end;

define C-function gdk-cairo-rectangle
  input parameter cr :: <cairo-t>;
  input parameter rectangle :: <GdkRectangle>;
  c-name: "gdk_cairo_rectangle";
end;

define C-function gdk-cairo-region
  input parameter cr :: <cairo-t>;
  input parameter region :: <GdkRegion>;
  c-name: "gdk_cairo_region";
end;

define C-subtype <_PangoCairoFontMap> (<C-void*>) end;
define constant <PangoCairoFontMap> = <_PangoCairoFontMap>;

define C-function pango-cairo-font-map-get-type
  result res :: <GType>;
  c-name: "pango_cairo_font_map_get_type";
end;

define C-function pango-cairo-font-map-new
  result res :: <PangoFontMap>;
  c-name: "pango_cairo_font_map_new";
end;

define C-function pango-cairo-font-map-get-default
  result res :: <PangoFontMap>;
  c-name: "pango_cairo_font_map_get_default";
end;

define C-function pango-cairo-font-map-set-resolution
  input parameter fontmap :: <PangoCairoFontMap>;
  input parameter dpi :: <double-float>;
  c-name: "pango_cairo_font_map_set_resolution";
end;

define C-function pango-cairo-font-map-get-resolution
  input parameter fontmap :: <PangoCairoFontMap>;
  result res :: <double-float>;
  c-name: "pango_cairo_font_map_get_resolution";
end;

define C-function pango-cairo-font-map-create-context
  input parameter fontmap :: <PangoCairoFontMap>;
  result res :: <PangoContext>;
  c-name: "pango_cairo_font_map_create_context";
end;

define C-function pango-cairo-update-context
  input parameter cr :: <cairo-t>;
  input parameter context :: <PangoContext>;
  c-name: "pango_cairo_update_context";
end;

define C-function pango-cairo-context-set-font-options
  input parameter context :: <PangoContext>;
  input parameter options :: <cairo-font-options-t>;
  c-name: "pango_cairo_context_set_font_options";
end;

define C-function pango-cairo-context-get-font-options
  input parameter context :: <PangoContext>;
  result res :: <cairo-font-options-t>;
  c-name: "pango_cairo_context_get_font_options";
end;

define C-function pango-cairo-context-set-resolution
  input parameter context :: <PangoContext>;
  input parameter dpi :: <double-float>;
  c-name: "pango_cairo_context_set_resolution";
end;

define C-function pango-cairo-context-get-resolution
  input parameter context :: <PangoContext>;
  result res :: <double-float>;
  c-name: "pango_cairo_context_get_resolution";
end;

define C-function pango-cairo-create-layout
  input parameter cr :: <cairo-t>;
  result res :: <PangoLayout>;
  c-name: "pango_cairo_create_layout";
end;

define C-function pango-cairo-update-layout
  input parameter cr :: <cairo-t>;
  input parameter layout :: <PangoLayout>;
  c-name: "pango_cairo_update_layout";
end;

define C-function pango-cairo-show-glyph-string
  input parameter cr :: <cairo-t>;
  input parameter font :: <PangoFont>;
  input parameter glyphs :: <PangoGlyphString>;
  c-name: "pango_cairo_show_glyph_string";
end;

define C-function pango-cairo-show-layout-line
  input parameter cr :: <cairo-t>;
  input parameter line :: <PangoLayoutLine>;
  c-name: "pango_cairo_show_layout_line";
end;

define C-function pango-cairo-show-layout
  input parameter cr :: <cairo-t>;
  input parameter layout :: <PangoLayout>;
  c-name: "pango_cairo_show_layout";
end;

define C-function pango-cairo-show-error-underline
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  input parameter width :: <double-float>;
  input parameter height :: <double-float>;
  c-name: "pango_cairo_show_error_underline";
end;

define C-function pango-cairo-glyph-string-path
  input parameter cr :: <cairo-t>;
  input parameter font :: <PangoFont>;
  input parameter glyphs :: <PangoGlyphString>;
  c-name: "pango_cairo_glyph_string_path";
end;

define C-function pango-cairo-layout-line-path
  input parameter cr :: <cairo-t>;
  input parameter line :: <PangoLayoutLine>;
  c-name: "pango_cairo_layout_line_path";
end;

define C-function pango-cairo-layout-path
  input parameter cr :: <cairo-t>;
  input parameter layout :: <PangoLayout>;
  c-name: "pango_cairo_layout_path";
end;

define C-function pango-cairo-error-underline-path
  input parameter cr :: <cairo-t>;
  input parameter x :: <double-float>;
  input parameter y :: <double-float>;
  input parameter width :: <double-float>;
  input parameter height :: <double-float>;
  c-name: "pango_cairo_error_underline_path";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3384>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3385>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3386>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3387>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3388>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3389>"*/
define C-subtype <_GtkAdjustmentClass> (<C-void*>) end;
define constant <GtkAdjustmentClass> = <_GtkAdjustmentClass>;

define C-function gtk-adjustment-get-type
  result res :: <GType>;
  c-name: "gtk_adjustment_get_type";
end;

define C-function gtk-adjustment-new
  input parameter value :: <gdouble>;
  input parameter lower :: <gdouble>;
  input parameter upper :: <gdouble>;
  input parameter step_increment :: <gdouble>;
  input parameter page_increment :: <gdouble>;
  input parameter page_size :: <gdouble>;
  result res :: <GtkObject>;
  c-name: "gtk_adjustment_new";
end;

define C-function gtk-adjustment-changed
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_adjustment_changed";
end;

define C-function gtk-adjustment-value-changed
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_adjustment_value_changed";
end;

define C-function gtk-adjustment-clamp-page
  input parameter adjustment :: <GtkAdjustment>;
  input parameter lower :: <gdouble>;
  input parameter upper :: <gdouble>;
  c-name: "gtk_adjustment_clamp_page";
end;

define C-function gtk-adjustment-get-value
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <gdouble>;
  c-name: "gtk_adjustment_get_value";
end;

define C-function gtk-adjustment-set-value
  input parameter adjustment :: <GtkAdjustment>;
  input parameter value :: <gdouble>;
  c-name: "gtk_adjustment_set_value";
end;

define constant <GtkObjectFlags> = limited(<integer>, min: 1, max: 8);
define constant $GTK-IN-DESTRUCTION :: <GtkObjectFlags> = 1;
define constant $GTK-FLOATING :: <GtkObjectFlags> = 2;
define constant $GTK-RESERVED-1 :: <GtkObjectFlags> = 4;
define constant $GTK-RESERVED-2 :: <GtkObjectFlags> = 8;

define C-function gtk-object-get-type
  result res :: <GtkType>;
  c-name: "gtk_object_get_type";
end;

define C-function gtk-object-sink
  input parameter object :: <GtkObject>;
  c-name: "gtk_object_sink";
end;

define C-function gtk-object-destroy
  input parameter object :: <GtkObject>;
  c-name: "gtk_object_destroy";
end;

define C-function gtk-object-new
  input parameter type :: <GtkType>;
  input parameter first_property_name :: <c-string>;
  result res :: <GtkObject>;
  c-name: "gtk_object_new";
end;

define C-function gtk-object-ref
  input parameter object :: <GtkObject>;
  result res :: <GtkObject>;
  c-name: "gtk_object_ref";
end;

define C-function gtk-object-unref
  input parameter object :: <GtkObject>;
  c-name: "gtk_object_unref";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3342>"*/
define constant <GtkDestroyNotify> = <anonymous-3342>;

define C-function gtk-object-weakref
  input parameter object :: <GtkObject>;
  input parameter notify :: <GtkDestroyNotify>;
  input parameter data :: <gpointer>;
  c-name: "gtk_object_weakref";
end;

define C-function gtk-object-weakunref
  input parameter object :: <GtkObject>;
  input parameter notify :: <GtkDestroyNotify>;
  input parameter data :: <gpointer>;
  c-name: "gtk_object_weakunref";
end;

define C-function gtk-object-set-data
  input parameter object :: <GtkObject>;
  input parameter key :: <c-string>;
  input parameter data :: <gpointer>;
  c-name: "gtk_object_set_data";
end;

define C-function gtk-object-set-data-full
  input parameter object :: <GtkObject>;
  input parameter key :: <c-string>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_object_set_data_full";
end;

define C-function gtk-object-remove-data
  input parameter object :: <GtkObject>;
  input parameter key :: <c-string>;
  c-name: "gtk_object_remove_data";
end;

define C-function gtk-object-get-data
  input parameter object :: <GtkObject>;
  input parameter key :: <c-string>;
  result res :: <gpointer>;
  c-name: "gtk_object_get_data";
end;

define C-function gtk-object-remove-no-notify
  input parameter object :: <GtkObject>;
  input parameter key :: <c-string>;
  c-name: "gtk_object_remove_no_notify";
end;

define C-function gtk-object-set-user-data
  input parameter object :: <GtkObject>;
  input parameter data :: <gpointer>;
  c-name: "gtk_object_set_user_data";
end;

define C-function gtk-object-get-user-data
  input parameter object :: <GtkObject>;
  result res :: <gpointer>;
  c-name: "gtk_object_get_user_data";
end;

define C-function gtk-object-set-data-by-id
  input parameter object :: <GtkObject>;
  input parameter data_id :: <GQuark>;
  input parameter data :: <gpointer>;
  c-name: "gtk_object_set_data_by_id";
end;

define C-function gtk-object-set-data-by-id-full
  input parameter object :: <GtkObject>;
  input parameter data_id :: <GQuark>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_object_set_data_by_id_full";
end;

define C-function gtk-object-get-data-by-id
  input parameter object :: <GtkObject>;
  input parameter data_id :: <GQuark>;
  result res :: <gpointer>;
  c-name: "gtk_object_get_data_by_id";
end;

define C-function gtk-object-remove-data-by-id
  input parameter object :: <GtkObject>;
  input parameter data_id :: <GQuark>;
  c-name: "gtk_object_remove_data_by_id";
end;

define C-function gtk-object-remove-no-notify-by-id
  input parameter object :: <GtkObject>;
  input parameter key_id :: <GQuark>;
  c-name: "gtk_object_remove_no_notify_by_id";
end;

define constant <GtkArgFlags> = limited(<integer>, min: 1, max: 16);
define constant $GTK-ARG-READABLE :: <GtkArgFlags> = 1;
define constant $GTK-ARG-WRITABLE :: <GtkArgFlags> = 2;
define constant $GTK-ARG-CONSTRUCT :: <GtkArgFlags> = 4;
define constant $GTK-ARG-CONSTRUCT-ONLY :: <GtkArgFlags> = 8;
define constant $GTK-ARG-CHILD-ARG :: <GtkArgFlags> = 16;

define C-function gtk-object-get
  input parameter object :: <GtkObject>;
  input parameter first_property_name :: <c-string>;
  c-name: "gtk_object_get";
end;

define C-function gtk-object-set
  input parameter object :: <GtkObject>;
  input parameter first_property_name :: <c-string>;
  c-name: "gtk_object_set";
end;

define C-function gtk-object-add-arg-type
  input parameter arg_name :: <c-string>;
  input parameter arg_type :: <GtkType>;
  input parameter arg_flags :: <guint>;
  input parameter arg_id :: <guint>;
  c-name: "gtk_object_add_arg_type";
end;

define constant gtk-object-data-try-key = g-quark-try-string;

define constant gtk-object-data-force-id = g-quark-from-string;

define constant $GTK-ARG-READWRITE = 0;

define constant <GtkDebugFlag> = limited(<integer>, min: 1, max: 1024);
define constant $GTK-DEBUG-MISC :: <GtkDebugFlag> = 1;
define constant $GTK-DEBUG-PLUGSOCKET :: <GtkDebugFlag> = 2;
define constant $GTK-DEBUG-TEXT :: <GtkDebugFlag> = 4;
define constant $GTK-DEBUG-TREE :: <GtkDebugFlag> = 8;
define constant $GTK-DEBUG-UPDATES :: <GtkDebugFlag> = 16;
define constant $GTK-DEBUG-KEYBINDINGS :: <GtkDebugFlag> = 32;
define constant $GTK-DEBUG-MULTIHEAD :: <GtkDebugFlag> = 64;
define constant $GTK-DEBUG-MODULES :: <GtkDebugFlag> = 128;
define constant $GTK-DEBUG-GEOMETRY :: <GtkDebugFlag> = 256;
define constant $GTK-DEBUG-ICONTHEME :: <GtkDebugFlag> = 512;
define constant $GTK-DEBUG-PRINTING :: <GtkDebugFlag> = 1024;

 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-debug-flags"*/
define constant <GtkFundamentalType> = <GType>;

define constant <GtkTypeObject> = <GTypeInstance>;

define constant <GtkTypeClass> = <GTypeClass>;

define constant <GtkClassInitFunc> = <GBaseInitFunc>;

define constant <GtkObjectInitFunc> = <GInstanceInitFunc>;

define C-function gtk-identifier-get-type
  result res :: <GType>;
  c-name: "gtk_identifier_get_type";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3341>"*/
define constant <GtkFunction> = <anonymous-3341>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3343>"*/
define constant <GtkCallbackMarshal> = <anonymous-3343>;

define C-subtype <_GtkTypeInfo> (<C-void*>) end;
define constant <GtkTypeInfo> = <_GtkTypeInfo>;

define constant <GtkSignalMarshaller> = <GSignalCMarshaller>;

define C-function gtk-type-class
  input parameter type :: <GtkType>;
  result res :: <gpointer>;
  c-name: "gtk_type_class";
end;

define C-function gtk-type-unique
  input parameter parent_type :: <GtkType>;
  input parameter gtkinfo :: <GtkTypeInfo>;
  result res :: <GtkType>;
  c-name: "gtk_type_unique";
end;

define C-function gtk-type-new
  input parameter type :: <GtkType>;
  result res :: <gpointer>;
  c-name: "gtk_type_new";
end;

define constant <GtkEnumValue> = <GEnumValue>;

define constant <GtkFlagValue> = <GFlagsValue>;

define C-function gtk-type-enum-get-values
  input parameter enum_type :: <GtkType>;
  result res :: <GtkEnumValue>;
  c-name: "gtk_type_enum_get_values";
end;

define C-function gtk-type-flags-get-values
  input parameter flags_type :: <GtkType>;
  result res :: <GtkFlagValue>;
  c-name: "gtk_type_flags_get_values";
end;

define C-function gtk-type-enum-find-value
  input parameter enum_type :: <GtkType>;
  input parameter value_name :: <c-string>;
  result res :: <GtkEnumValue>;
  c-name: "gtk_type_enum_find_value";
end;

define C-function gtk-type-flags-find-value
  input parameter flags_type :: <GtkType>;
  input parameter value_name :: <c-string>;
  result res :: <GtkFlagValue>;
  c-name: "gtk_type_flags_find_value";
end;

define C-function gtk-type-init
  input parameter debug_flags :: <GTypeDebugFlags>;
  c-name: "gtk_type_init";
end;

define constant $GTK-TYPE-INVALID = 0;

define constant $GTK-TYPE-NONE = 4;

define constant $GTK-TYPE-ENUM = 48;

define constant $GTK-TYPE-FLAGS = 52;

define constant $GTK-TYPE-CHAR = 12;

define constant $GTK-TYPE-UCHAR = 16;

define constant $GTK-TYPE-BOOL = 20;

define constant $GTK-TYPE-INT = 24;

define constant $GTK-TYPE-UINT = 28;

define constant $GTK-TYPE-LONG = 32;

define constant $GTK-TYPE-ULONG = 36;

define constant $GTK-TYPE-FLOAT = 56;

define constant $GTK-TYPE-DOUBLE = 60;

define constant $GTK-TYPE-STRING = 64;

define constant $GTK-TYPE-BOXED = 72;

define constant $GTK-TYPE-POINTER = 68;

define constant $GTK-TYPE-FUNDAMENTAL-LAST = -1;

define constant $GTK-TYPE-FUNDAMENTAL-MAX = 1020;

define C-function gtk-accel-flags-get-type
  result res :: <GType>;
  c-name: "gtk_accel_flags_get_type";
end;

define C-function gtk-assistant-page-type-get-type
  result res :: <GType>;
  c-name: "gtk_assistant_page_type_get_type";
end;

define C-function gtk-calendar-display-options-get-type
  result res :: <GType>;
  c-name: "gtk_calendar_display_options_get_type";
end;

define C-function gtk-cell-renderer-state-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_state_get_type";
end;

define C-function gtk-cell-renderer-mode-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_mode_get_type";
end;

define C-function gtk-cell-renderer-accel-mode-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_accel_mode_get_type";
end;

define C-function gtk-cell-type-get-type
  result res :: <GType>;
  c-name: "gtk_cell_type_get_type";
end;

define C-function gtk-clist-drag-pos-get-type
  result res :: <GType>;
  c-name: "gtk_clist_drag_pos_get_type";
end;

define C-function gtk-button-action-get-type
  result res :: <GType>;
  c-name: "gtk_button_action_get_type";
end;

define C-function gtk-ctree-pos-get-type
  result res :: <GType>;
  c-name: "gtk_ctree_pos_get_type";
end;

define C-function gtk-ctree-line-style-get-type
  result res :: <GType>;
  c-name: "gtk_ctree_line_style_get_type";
end;

define C-function gtk-ctree-expander-style-get-type
  result res :: <GType>;
  c-name: "gtk_ctree_expander_style_get_type";
end;

define C-function gtk-ctree-expansion-type-get-type
  result res :: <GType>;
  c-name: "gtk_ctree_expansion_type_get_type";
end;

define C-function gtk-debug-flag-get-type
  result res :: <GType>;
  c-name: "gtk_debug_flag_get_type";
end;

define C-function gtk-dialog-flags-get-type
  result res :: <GType>;
  c-name: "gtk_dialog_flags_get_type";
end;

define C-function gtk-response-type-get-type
  result res :: <GType>;
  c-name: "gtk_response_type_get_type";
end;

define C-function gtk-dest-defaults-get-type
  result res :: <GType>;
  c-name: "gtk_dest_defaults_get_type";
end;

define C-function gtk-target-flags-get-type
  result res :: <GType>;
  c-name: "gtk_target_flags_get_type";
end;

define C-function gtk-anchor-type-get-type
  result res :: <GType>;
  c-name: "gtk_anchor_type_get_type";
end;

define C-function gtk-arrow-type-get-type
  result res :: <GType>;
  c-name: "gtk_arrow_type_get_type";
end;

define C-function gtk-attach-options-get-type
  result res :: <GType>;
  c-name: "gtk_attach_options_get_type";
end;

define C-function gtk-button-box-style-get-type
  result res :: <GType>;
  c-name: "gtk_button_box_style_get_type";
end;

define C-function gtk-curve-type-get-type
  result res :: <GType>;
  c-name: "gtk_curve_type_get_type";
end;

define C-function gtk-delete-type-get-type
  result res :: <GType>;
  c-name: "gtk_delete_type_get_type";
end;

define C-function gtk-direction-type-get-type
  result res :: <GType>;
  c-name: "gtk_direction_type_get_type";
end;

define C-function gtk-expander-style-get-type
  result res :: <GType>;
  c-name: "gtk_expander_style_get_type";
end;

define C-function gtk-icon-size-get-type
  result res :: <GType>;
  c-name: "gtk_icon_size_get_type";
end;

define C-function gtk-sensitivity-type-get-type
  result res :: <GType>;
  c-name: "gtk_sensitivity_type_get_type";
end;

define C-function gtk-side-type-get-type
  result res :: <GType>;
  c-name: "gtk_side_type_get_type";
end;

define C-function gtk-text-direction-get-type
  result res :: <GType>;
  c-name: "gtk_text_direction_get_type";
end;

define C-function gtk-justification-get-type
  result res :: <GType>;
  c-name: "gtk_justification_get_type";
end;

define C-function gtk-match-type-get-type
  result res :: <GType>;
  c-name: "gtk_match_type_get_type";
end;

define C-function gtk-menu-direction-type-get-type
  result res :: <GType>;
  c-name: "gtk_menu_direction_type_get_type";
end;

define C-function gtk-metric-type-get-type
  result res :: <GType>;
  c-name: "gtk_metric_type_get_type";
end;

define C-function gtk-movement-step-get-type
  result res :: <GType>;
  c-name: "gtk_movement_step_get_type";
end;

define C-function gtk-scroll-step-get-type
  result res :: <GType>;
  c-name: "gtk_scroll_step_get_type";
end;

define C-function gtk-orientation-get-type
  result res :: <GType>;
  c-name: "gtk_orientation_get_type";
end;

define C-function gtk-corner-type-get-type
  result res :: <GType>;
  c-name: "gtk_corner_type_get_type";
end;

define C-function gtk-pack-type-get-type
  result res :: <GType>;
  c-name: "gtk_pack_type_get_type";
end;

define C-function gtk-path-priority-type-get-type
  result res :: <GType>;
  c-name: "gtk_path_priority_type_get_type";
end;

define C-function gtk-path-type-get-type
  result res :: <GType>;
  c-name: "gtk_path_type_get_type";
end;

define C-function gtk-policy-type-get-type
  result res :: <GType>;
  c-name: "gtk_policy_type_get_type";
end;

define C-function gtk-position-type-get-type
  result res :: <GType>;
  c-name: "gtk_position_type_get_type";
end;

define C-function gtk-preview-type-get-type
  result res :: <GType>;
  c-name: "gtk_preview_type_get_type";
end;

define C-function gtk-relief-style-get-type
  result res :: <GType>;
  c-name: "gtk_relief_style_get_type";
end;

define C-function gtk-resize-mode-get-type
  result res :: <GType>;
  c-name: "gtk_resize_mode_get_type";
end;

define C-function gtk-signal-run-type-get-type
  result res :: <GType>;
  c-name: "gtk_signal_run_type_get_type";
end;

define C-function gtk-scroll-type-get-type
  result res :: <GType>;
  c-name: "gtk_scroll_type_get_type";
end;

define C-function gtk-selection-mode-get-type
  result res :: <GType>;
  c-name: "gtk_selection_mode_get_type";
end;

define C-function gtk-shadow-type-get-type
  result res :: <GType>;
  c-name: "gtk_shadow_type_get_type";
end;

define C-function gtk-state-type-get-type
  result res :: <GType>;
  c-name: "gtk_state_type_get_type";
end;

define C-function gtk-submenu-direction-get-type
  result res :: <GType>;
  c-name: "gtk_submenu_direction_get_type";
end;

define C-function gtk-submenu-placement-get-type
  result res :: <GType>;
  c-name: "gtk_submenu_placement_get_type";
end;

define C-function gtk-toolbar-style-get-type
  result res :: <GType>;
  c-name: "gtk_toolbar_style_get_type";
end;

define C-function gtk-update-type-get-type
  result res :: <GType>;
  c-name: "gtk_update_type_get_type";
end;

define C-function gtk-visibility-get-type
  result res :: <GType>;
  c-name: "gtk_visibility_get_type";
end;

define C-function gtk-window-position-get-type
  result res :: <GType>;
  c-name: "gtk_window_position_get_type";
end;

define C-function gtk-window-type-get-type
  result res :: <GType>;
  c-name: "gtk_window_type_get_type";
end;

define C-function gtk-wrap-mode-get-type
  result res :: <GType>;
  c-name: "gtk_wrap_mode_get_type";
end;

define C-function gtk-sort-type-get-type
  result res :: <GType>;
  c-name: "gtk_sort_type_get_type";
end;

define C-function gtk-im-preedit-style-get-type
  result res :: <GType>;
  c-name: "gtk_im_preedit_style_get_type";
end;

define C-function gtk-im-status-style-get-type
  result res :: <GType>;
  c-name: "gtk_im_status_style_get_type";
end;

define C-function gtk-pack-direction-get-type
  result res :: <GType>;
  c-name: "gtk_pack_direction_get_type";
end;

define C-function gtk-print-pages-get-type
  result res :: <GType>;
  c-name: "gtk_print_pages_get_type";
end;

define C-function gtk-page-set-get-type
  result res :: <GType>;
  c-name: "gtk_page_set_get_type";
end;

define C-function gtk-page-orientation-get-type
  result res :: <GType>;
  c-name: "gtk_page_orientation_get_type";
end;

define C-function gtk-print-quality-get-type
  result res :: <GType>;
  c-name: "gtk_print_quality_get_type";
end;

define C-function gtk-print-duplex-get-type
  result res :: <GType>;
  c-name: "gtk_print_duplex_get_type";
end;

define C-function gtk-unit-get-type
  result res :: <GType>;
  c-name: "gtk_unit_get_type";
end;

define C-function gtk-tree-view-grid-lines-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_grid_lines_get_type";
end;

define C-function gtk-file-chooser-action-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_action_get_type";
end;

define C-function gtk-file-chooser-confirmation-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_confirmation_get_type";
end;

define C-function gtk-file-chooser-error-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_error_get_type";
end;

define C-function gtk-file-filter-flags-get-type
  result res :: <GType>;
  c-name: "gtk_file_filter_flags_get_type";
end;

define C-function gtk-icon-lookup-flags-get-type
  result res :: <GType>;
  c-name: "gtk_icon_lookup_flags_get_type";
end;

define C-function gtk-icon-theme-error-get-type
  result res :: <GType>;
  c-name: "gtk_icon_theme_error_get_type";
end;

define C-function gtk-icon-view-drop-position-get-type
  result res :: <GType>;
  c-name: "gtk_icon_view_drop_position_get_type";
end;

define C-function gtk-image-type-get-type
  result res :: <GType>;
  c-name: "gtk_image_type_get_type";
end;

define C-function gtk-message-type-get-type
  result res :: <GType>;
  c-name: "gtk_message_type_get_type";
end;

define C-function gtk-buttons-type-get-type
  result res :: <GType>;
  c-name: "gtk_buttons_type_get_type";
end;

define C-function gtk-notebook-tab-get-type
  result res :: <GType>;
  c-name: "gtk_notebook_tab_get_type";
end;

define C-function gtk-object-flags-get-type
  result res :: <GType>;
  c-name: "gtk_object_flags_get_type";
end;

define C-function gtk-arg-flags-get-type
  result res :: <GType>;
  c-name: "gtk_arg_flags_get_type";
end;

define C-function gtk-print-status-get-type
  result res :: <GType>;
  c-name: "gtk_print_status_get_type";
end;

define C-function gtk-print-operation-result-get-type
  result res :: <GType>;
  c-name: "gtk_print_operation_result_get_type";
end;

define C-function gtk-print-operation-action-get-type
  result res :: <GType>;
  c-name: "gtk_print_operation_action_get_type";
end;

define C-function gtk-print-error-get-type
  result res :: <GType>;
  c-name: "gtk_print_error_get_type";
end;

define C-function gtk-private-flags-get-type
  result res :: <GType>;
  c-name: "gtk_private_flags_get_type";
end;

define C-function gtk-progress-bar-style-get-type
  result res :: <GType>;
  c-name: "gtk_progress_bar_style_get_type";
end;

define C-function gtk-progress-bar-orientation-get-type
  result res :: <GType>;
  c-name: "gtk_progress_bar_orientation_get_type";
end;

define C-function gtk-rc-flags-get-type
  result res :: <GType>;
  c-name: "gtk_rc_flags_get_type";
end;

define C-function gtk-rc-token-type-get-type
  result res :: <GType>;
  c-name: "gtk_rc_token_type_get_type";
end;

define C-function gtk-recent-sort-type-get-type
  result res :: <GType>;
  c-name: "gtk_recent_sort_type_get_type";
end;

define C-function gtk-recent-chooser-error-get-type
  result res :: <GType>;
  c-name: "gtk_recent_chooser_error_get_type";
end;

define C-function gtk-recent-filter-flags-get-type
  result res :: <GType>;
  c-name: "gtk_recent_filter_flags_get_type";
end;

define C-function gtk-recent-manager-error-get-type
  result res :: <GType>;
  c-name: "gtk_recent_manager_error_get_type";
end;

define C-function gtk-size-group-mode-get-type
  result res :: <GType>;
  c-name: "gtk_size_group_mode_get_type";
end;

define C-function gtk-spin-button-update-policy-get-type
  result res :: <GType>;
  c-name: "gtk_spin_button_update_policy_get_type";
end;

define C-function gtk-spin-type-get-type
  result res :: <GType>;
  c-name: "gtk_spin_type_get_type";
end;

define C-function gtk-text-buffer-target-info-get-type
  result res :: <GType>;
  c-name: "gtk_text_buffer_target_info_get_type";
end;

define C-function gtk-text-search-flags-get-type
  result res :: <GType>;
  c-name: "gtk_text_search_flags_get_type";
end;

define C-function gtk-text-window-type-get-type
  result res :: <GType>;
  c-name: "gtk_text_window_type_get_type";
end;

define C-function gtk-toolbar-child-type-get-type
  result res :: <GType>;
  c-name: "gtk_toolbar_child_type_get_type";
end;

define C-function gtk-toolbar-space-style-get-type
  result res :: <GType>;
  c-name: "gtk_toolbar_space_style_get_type";
end;

define C-function gtk-tree-view-mode-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_mode_get_type";
end;

define C-function gtk-tree-model-flags-get-type
  result res :: <GType>;
  c-name: "gtk_tree_model_flags_get_type";
end;

define C-function gtk-tree-view-drop-position-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_drop_position_get_type";
end;

define C-function gtk-tree-view-column-sizing-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_column_sizing_get_type";
end;

define C-function gtk-ui-manager-item-type-get-type
  result res :: <GType>;
  c-name: "gtk_ui_manager_item_type_get_type";
end;

define C-function gtk-widget-flags-get-type
  result res :: <GType>;
  c-name: "gtk_widget_flags_get_type";
end;

define C-function gtk-widget-help-type-get-type
  result res :: <GType>;
  c-name: "gtk_widget_help_type_get_type";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3200>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3201>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3202>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3203>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3204>"*/
define C-subtype <_GtkAccelGroupClass> (<C-void*>) end;
define constant <GtkAccelGroupClass> = <_GtkAccelGroupClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3198>"*/
define constant <GtkAccelGroupActivate> = <anonymous-3198>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-3199>"*/
define constant <GtkAccelGroupFindFunc> = <anonymous-3199>;

define C-function gtk-accel-group-get-type
  result res :: <GType>;
  c-name: "gtk_accel_group_get_type";
end;

define C-function gtk-accel-group-new
  result res :: <GtkAccelGroup>;
  c-name: "gtk_accel_group_new";
end;

define C-function gtk-accel-group-lock
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_accel_group_lock";
end;

define C-function gtk-accel-group-unlock
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_accel_group_unlock";
end;

define C-function gtk-accel-group-connect
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  input parameter accel_flags :: <GtkAccelFlags>;
  input parameter closure :: <GClosure>;
  c-name: "gtk_accel_group_connect";
end;

define C-function gtk-accel-group-connect-by-path
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_path :: <c-string>;
  input parameter closure :: <GClosure>;
  c-name: "gtk_accel_group_connect_by_path";
end;

define C-function gtk-accel-group-disconnect
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter closure :: <GClosure>;
  result res :: <gboolean>;
  c-name: "gtk_accel_group_disconnect";
end;

define C-function gtk-accel-group-disconnect-key
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_accel_group_disconnect_key";
end;

define C-function gtk-accel-group-activate
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_quark :: <GQuark>;
  input parameter acceleratable :: <GObject>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_accel_group_activate";
end;

define C-function _gtk-accel-group-attach
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter object :: <GObject>;
  c-name: "_gtk_accel_group_attach";
end;

define C-function _gtk-accel-group-detach
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter object :: <GObject>;
  c-name: "_gtk_accel_group_detach";
end;

define C-function gtk-accel-groups-activate
  input parameter object :: <GObject>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_accel_groups_activate";
end;

define C-function gtk-accel-groups-from-object
  input parameter object :: <GObject>;
  result res :: <GSList>;
  c-name: "gtk_accel_groups_from_object";
end;

define C-function gtk-accel-group-find
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter find_func :: <GtkAccelGroupFindFunc>;
  input parameter data :: <gpointer>;
  result res :: <GtkAccelKey>;
  c-name: "gtk_accel_group_find";
end;

define C-function gtk-accel-group-from-accel-closure
  input parameter closure :: <GClosure>;
  result res :: <GtkAccelGroup>;
  c-name: "gtk_accel_group_from_accel_closure";
end;

define C-function gtk-accelerator-valid
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_accelerator_valid";
end;

define C-function gtk-accelerator-parse
  input parameter accelerator :: <c-string>;
  input parameter accelerator_key :: <guint*>;
  input parameter accelerator_mods :: <GdkModifierType*>;
  c-name: "gtk_accelerator_parse";
end;

define C-function gtk-accelerator-name
  input parameter accelerator_key :: <guint>;
  input parameter accelerator_mods :: <GdkModifierType>;
  result res :: <c-string>;
  c-name: "gtk_accelerator_name";
end;

define C-function gtk-accelerator-get-label
  input parameter accelerator_key :: <guint>;
  input parameter accelerator_mods :: <GdkModifierType>;
  result res :: <c-string>;
  c-name: "gtk_accelerator_get_label";
end;

define C-function gtk-accelerator-set-default-mod-mask
  input parameter default_mod_mask :: <GdkModifierType>;
  c-name: "gtk_accelerator_set_default_mod_mask";
end;

define C-function gtk-accelerator-get-default-mod-mask
  result res :: <guint>;
  c-name: "gtk_accelerator_get_default_mod_mask";
end;

define C-function gtk-accel-group-query
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  input parameter n_entries :: <guint*>;
  result res :: <GtkAccelGroupEntry>;
  c-name: "gtk_accel_group_query";
end;

define C-function _gtk-accel-group-reconnect
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter accel_path_quark :: <GQuark>;
  c-name: "_gtk_accel_group_reconnect";
end;

define constant gtk-accel-group-ref = g-object-ref;

define constant gtk-accel-group-unref = g-object-unref;

define C-function gtk-bin-get-type
  result res :: <GType>;
  c-name: "gtk_bin_get_type";
end;

define C-function gtk-bin-get-child
  input parameter bin :: <GtkBin>;
  result res :: <GtkWidget>;
  c-name: "gtk_bin_get_child";
end;

define C-function gtk-container-get-type
  result res :: <GType>;
  c-name: "gtk_container_get_type";
end;

define C-function gtk-container-set-border-width
  input parameter container :: <GtkContainer>;
  input parameter border_width :: <guint>;
  c-name: "gtk_container_set_border_width";
end;

define C-function gtk-container-get-border-width
  input parameter container :: <GtkContainer>;
  result res :: <guint>;
  c-name: "gtk_container_get_border_width";
end;

define C-function gtk-container-add
  input parameter container :: <GtkContainer>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_container_add";
end;

define C-function gtk-container-remove
  input parameter container :: <GtkContainer>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_container_remove";
end;

define C-function gtk-container-set-resize-mode
  input parameter container :: <GtkContainer>;
  input parameter resize_mode :: <GtkResizeMode>;
  c-name: "gtk_container_set_resize_mode";
end;

define C-function gtk-container-get-resize-mode
  input parameter container :: <GtkContainer>;
  result res :: <GtkResizeMode>;
  c-name: "gtk_container_get_resize_mode";
end;

define C-function gtk-container-check-resize
  input parameter container :: <GtkContainer>;
  c-name: "gtk_container_check_resize";
end;

define C-function gtk-container-foreach
  input parameter container :: <GtkContainer>;
  input parameter callback :: <GtkCallback>;
  input parameter callback_data :: <gpointer>;
  c-name: "gtk_container_foreach";
end;

define C-function gtk-container-foreach-full
  input parameter container :: <GtkContainer>;
  input parameter callback :: <GtkCallback>;
  input parameter marshal :: <GtkCallbackMarshal>;
  input parameter callback_data :: <gpointer>;
  input parameter notify :: <GtkDestroyNotify>;
  c-name: "gtk_container_foreach_full";
end;

define C-function gtk-container-get-children
  input parameter container :: <GtkContainer>;
  result res :: <GList>;
  c-name: "gtk_container_get_children";
end;

define C-function gtk-container-propagate-expose
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter event :: <GdkEventExpose>;
  c-name: "gtk_container_propagate_expose";
end;

define C-function gtk-container-set-focus-chain
  input parameter container :: <GtkContainer>;
  input parameter focusable_widgets :: <GList>;
  c-name: "gtk_container_set_focus_chain";
end;

define C-pointer-type <GList*> => <GList>;
define C-function gtk-container-get-focus-chain
  input parameter container :: <GtkContainer>;
  input parameter focusable_widgets :: <GList*>;
  result res :: <gboolean>;
  c-name: "gtk_container_get_focus_chain";
end;

define C-function gtk-container-unset-focus-chain
  input parameter container :: <GtkContainer>;
  c-name: "gtk_container_unset_focus_chain";
end;

define C-function gtk-container-set-reallocate-redraws
  input parameter container :: <GtkContainer>;
  input parameter needs_redraws :: <gboolean>;
  c-name: "gtk_container_set_reallocate_redraws";
end;

define C-function gtk-container-set-focus-child
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_container_set_focus_child";
end;

define C-function gtk-container-set-focus-vadjustment
  input parameter container :: <GtkContainer>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_container_set_focus_vadjustment";
end;

define C-function gtk-container-get-focus-vadjustment
  input parameter container :: <GtkContainer>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_container_get_focus_vadjustment";
end;

define C-function gtk-container-set-focus-hadjustment
  input parameter container :: <GtkContainer>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_container_set_focus_hadjustment";
end;

define C-function gtk-container-get-focus-hadjustment
  input parameter container :: <GtkContainer>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_container_get_focus_hadjustment";
end;

define C-function gtk-container-resize-children
  input parameter container :: <GtkContainer>;
  c-name: "gtk_container_resize_children";
end;

define C-function gtk-container-child-type
  input parameter container :: <GtkContainer>;
  result res :: <GType>;
  c-name: "gtk_container_child_type";
end;

define C-function gtk-container-class-install-child-property
  input parameter cclass :: <GtkContainerClass>;
  input parameter property_id :: <guint>;
  input parameter pspec :: <GParamSpec>;
  c-name: "gtk_container_class_install_child_property";
end;

define C-function gtk-container-class-find-child-property
  input parameter cclass :: <GObjectClass>;
  input parameter property_name :: <c-string>;
  result res :: <GParamSpec>;
  c-name: "gtk_container_class_find_child_property";
end;

define C-function gtk-container-class-list-child-properties
  input parameter cclass :: <GObjectClass>;
  input parameter n_properties :: <guint*>;
  result res :: <GParamSpec*>;
  c-name: "gtk_container_class_list_child_properties";
end;

define C-function gtk-container-add-with-properties
  input parameter container :: <GtkContainer>;
  input parameter widget :: <GtkWidget>;
  input parameter first_prop_name :: <c-string>;
  c-name: "gtk_container_add_with_properties";
end;

define C-function gtk-container-child-set
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter first_prop_name :: <c-string>;
  c-name: "gtk_container_child_set";
end;

define C-function gtk-container-child-get
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter first_prop_name :: <c-string>;
  c-name: "gtk_container_child_get";
end;

define C-function gtk-container-child-set-valist
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_container_child_set_valist";
end;

define C-function gtk-container-child-get-valist
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter first_property_name :: <c-string>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_container_child_get_valist";
end;

define C-function gtk-container-child-set-property
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter property_name :: <c-string>;
  input parameter value :: <GValue>;
  c-name: "gtk_container_child_set_property";
end;

define C-function gtk-container-child-get-property
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  input parameter property_name :: <c-string>;
  input parameter value :: <GValue>;
  c-name: "gtk_container_child_get_property";
end;

define C-function gtk-container-forall
  input parameter container :: <GtkContainer>;
  input parameter callback :: <GtkCallback>;
  input parameter callback_data :: <gpointer>;
  c-name: "gtk_container_forall";
end;

define C-function _gtk-container-queue-resize
  input parameter container :: <GtkContainer>;
  c-name: "_gtk_container_queue_resize";
end;

define C-function _gtk-container-child-composite-name
  input parameter container :: <GtkContainer>;
  input parameter child :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "_gtk_container_child_composite_name";
end;

define C-function _gtk-container-dequeue-resize-handler
  input parameter container :: <GtkContainer>;
  c-name: "_gtk_container_dequeue_resize_handler";
end;

define C-function _gtk-container-focus-sort
  input parameter container :: <GtkContainer>;
  input parameter children :: <GList>;
  input parameter direction :: <GtkDirectionType>;
  input parameter old_focus :: <GtkWidget>;
  result res :: <GList>;
  c-name: "_gtk_container_focus_sort";
end;

define constant gtk-container-children = gtk-container-get-children;

define constant gtk-container-border-width = gtk-container-set-border-width;

define C-subtype <_GtkSeparator> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkSeparator> = <_GtkSeparator>;

define C-subtype <_GtkVSeparator> (<GtkSeparator>, <AtkImplementorIface>) end;
define constant <GtkVSeparator> = <_GtkVSeparator>;

define C-subtype <_GtkSeparatorClass> (<C-void*>) end;
define constant <GtkSeparatorClass> = <_GtkSeparatorClass>;

define C-subtype <_GtkVSeparatorClass> (<C-void*>) end;
define constant <GtkVSeparatorClass> = <_GtkVSeparatorClass>;

define C-function gtk-vseparator-get-type
  result res :: <GType>;
  c-name: "gtk_vseparator_get_type";
end;

define C-function gtk-vseparator-new
  result res :: <GtkWidget>;
  c-name: "gtk_vseparator_new";
end;

define C-function gtk-separator-get-type
  result res :: <GType>;
  c-name: "gtk_separator_get_type";
end;

define C-subtype <_GtkRangeLayout> (<C-void*>) end;
define constant <GtkRangeLayout> = <_GtkRangeLayout>;

define C-subtype <_GtkRangeStepTimer> (<C-void*>) end;
define constant <GtkRangeStepTimer> = <_GtkRangeStepTimer>;

define C-subtype <_GtkRange> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkRange> = <_GtkRange>;

define C-subtype <_GtkScrollbar> (<GtkRange>, <AtkImplementorIface>) end;
define constant <GtkScrollbar> = <_GtkScrollbar>;

define C-subtype <_GtkVScrollbar> (<GtkScrollbar>, <AtkImplementorIface>) end;
define constant <GtkVScrollbar> = <_GtkVScrollbar>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5607>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5608>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5609>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5610>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5611>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5612>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5613>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5614>"*/
define C-subtype <_GtkRangeClass> (<C-void*>) end;
define constant <GtkRangeClass> = <_GtkRangeClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5631>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5632>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5633>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5634>"*/
define C-subtype <_GtkScrollbarClass> (<C-void*>) end;
define constant <GtkScrollbarClass> = <_GtkScrollbarClass>;

define C-subtype <_GtkVScrollbarClass> (<C-void*>) end;
define constant <GtkVScrollbarClass> = <_GtkVScrollbarClass>;

define C-function gtk-vscrollbar-get-type
  result res :: <GType>;
  c-name: "gtk_vscrollbar_get_type";
end;

define C-function gtk-vscrollbar-new
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_vscrollbar_new";
end;

define C-function gtk-scrollbar-get-type
  result res :: <GType>;
  c-name: "gtk_scrollbar_get_type";
end;

define C-function gtk-range-get-type
  result res :: <GType>;
  c-name: "gtk_range_get_type";
end;

define C-function gtk-range-set-update-policy
  input parameter range :: <GtkRange>;
  input parameter policy :: <GtkUpdateType>;
  c-name: "gtk_range_set_update_policy";
end;

define C-function gtk-range-get-update-policy
  input parameter range :: <GtkRange>;
  result res :: <GtkUpdateType>;
  c-name: "gtk_range_get_update_policy";
end;

define C-function gtk-range-set-adjustment
  input parameter range :: <GtkRange>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_range_set_adjustment";
end;

define C-function gtk-range-get-adjustment
  input parameter range :: <GtkRange>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_range_get_adjustment";
end;

define C-function gtk-range-set-inverted
  input parameter range :: <GtkRange>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_range_set_inverted";
end;

define C-function gtk-range-get-inverted
  input parameter range :: <GtkRange>;
  result res :: <gboolean>;
  c-name: "gtk_range_get_inverted";
end;

define C-function gtk-range-set-lower-stepper-sensitivity
  input parameter range :: <GtkRange>;
  input parameter sensitivity :: <GtkSensitivityType>;
  c-name: "gtk_range_set_lower_stepper_sensitivity";
end;

define C-function gtk-range-get-lower-stepper-sensitivity
  input parameter range :: <GtkRange>;
  result res :: <GtkSensitivityType>;
  c-name: "gtk_range_get_lower_stepper_sensitivity";
end;

define C-function gtk-range-set-upper-stepper-sensitivity
  input parameter range :: <GtkRange>;
  input parameter sensitivity :: <GtkSensitivityType>;
  c-name: "gtk_range_set_upper_stepper_sensitivity";
end;

define C-function gtk-range-get-upper-stepper-sensitivity
  input parameter range :: <GtkRange>;
  result res :: <GtkSensitivityType>;
  c-name: "gtk_range_get_upper_stepper_sensitivity";
end;

define C-function gtk-range-set-increments
  input parameter range :: <GtkRange>;
  input parameter step :: <gdouble>;
  input parameter page :: <gdouble>;
  c-name: "gtk_range_set_increments";
end;

define C-function gtk-range-set-range
  input parameter range :: <GtkRange>;
  input parameter min :: <gdouble>;
  input parameter max :: <gdouble>;
  c-name: "gtk_range_set_range";
end;

define C-function gtk-range-set-value
  input parameter range :: <GtkRange>;
  input parameter value :: <gdouble>;
  c-name: "gtk_range_set_value";
end;

define C-function gtk-range-get-value
  input parameter range :: <GtkRange>;
  result res :: <gdouble>;
  c-name: "gtk_range_get_value";
end;

define C-function _gtk-range-get-wheel-delta
  input parameter range :: <GtkRange>;
  input parameter direction :: <GdkScrollDirection>;
  result res :: <gdouble>;
  c-name: "_gtk_range_get_wheel_delta";
end;

define C-subtype <_GtkScale> (<GtkRange>, <AtkImplementorIface>) end;
define constant <GtkScale> = <_GtkScale>;

define C-subtype <_GtkVScale> (<GtkScale>, <AtkImplementorIface>) end;
define constant <GtkVScale> = <_GtkVScale>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6580>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6581>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6582>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6583>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6584>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6585>"*/
define C-subtype <_GtkScaleClass> (<C-void*>) end;
define constant <GtkScaleClass> = <_GtkScaleClass>;

define C-subtype <_GtkVScaleClass> (<C-void*>) end;
define constant <GtkVScaleClass> = <_GtkVScaleClass>;

define C-function gtk-vscale-get-type
  result res :: <GType>;
  c-name: "gtk_vscale_get_type";
end;

define C-function gtk-vscale-new
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_vscale_new";
end;

define C-function gtk-vscale-new-with-range
  input parameter min :: <gdouble>;
  input parameter max :: <gdouble>;
  input parameter step :: <gdouble>;
  result res :: <GtkWidget>;
  c-name: "gtk_vscale_new_with_range";
end;

define C-function gtk-scale-get-type
  result res :: <GType>;
  c-name: "gtk_scale_get_type";
end;

define C-function gtk-scale-set-digits
  input parameter scale :: <GtkScale>;
  input parameter digits :: <gint>;
  c-name: "gtk_scale_set_digits";
end;

define C-function gtk-scale-get-digits
  input parameter scale :: <GtkScale>;
  result res :: <gint>;
  c-name: "gtk_scale_get_digits";
end;

define C-function gtk-scale-set-draw-value
  input parameter scale :: <GtkScale>;
  input parameter draw_value :: <gboolean>;
  c-name: "gtk_scale_set_draw_value";
end;

define C-function gtk-scale-get-draw-value
  input parameter scale :: <GtkScale>;
  result res :: <gboolean>;
  c-name: "gtk_scale_get_draw_value";
end;

define C-function gtk-scale-set-value-pos
  input parameter scale :: <GtkScale>;
  input parameter pos :: <GtkPositionType>;
  c-name: "gtk_scale_set_value_pos";
end;

define C-function gtk-scale-get-value-pos
  input parameter scale :: <GtkScale>;
  result res :: <GtkPositionType>;
  c-name: "gtk_scale_get_value_pos";
end;

define C-function gtk-scale-get-layout
  input parameter scale :: <GtkScale>;
  result res :: <PangoLayout>;
  c-name: "gtk_scale_get_layout";
end;

define C-function gtk-scale-get-layout-offsets
  input parameter scale :: <GtkScale>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gtk_scale_get_layout_offsets";
end;

define C-function _gtk-scale-clear-layout
  input parameter scale :: <GtkScale>;
  c-name: "_gtk_scale_clear_layout";
end;

define C-function _gtk-scale-get-value-size
  input parameter scale :: <GtkScale>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "_gtk_scale_get_value_size";
end;

define C-function _gtk-scale-format-value
  input parameter scale :: <GtkScale>;
  input parameter value :: <gdouble>;
  result res :: <c-string>;
  c-name: "_gtk_scale_format_value";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gdouble<@10>>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@5>>"*/
define C-subtype <_GtkRulerMetric> (<C-void*>) end;
define constant <GtkRulerMetric> = <_GtkRulerMetric>;

define C-subtype <_GtkRuler> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkRuler> = <_GtkRuler>;

define C-subtype <_GtkVRuler> (<GtkRuler>, <AtkImplementorIface>) end;
define constant <GtkVRuler> = <_GtkVRuler>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6563>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6564>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6565>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6566>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6567>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6568>"*/
define C-subtype <_GtkRulerClass> (<C-void*>) end;
define constant <GtkRulerClass> = <_GtkRulerClass>;

define C-subtype <_GtkVRulerClass> (<C-void*>) end;
define constant <GtkVRulerClass> = <_GtkVRulerClass>;

define C-function gtk-vruler-get-type
  result res :: <GType>;
  c-name: "gtk_vruler_get_type";
end;

define C-function gtk-vruler-new
  result res :: <GtkWidget>;
  c-name: "gtk_vruler_new";
end;

define C-function gtk-ruler-get-type
  result res :: <GType>;
  c-name: "gtk_ruler_get_type";
end;

define C-function gtk-ruler-set-metric
  input parameter ruler :: <GtkRuler>;
  input parameter metric :: <GtkMetricType>;
  c-name: "gtk_ruler_set_metric";
end;

define C-function gtk-ruler-set-range
  input parameter ruler :: <GtkRuler>;
  input parameter lower :: <gdouble>;
  input parameter upper :: <gdouble>;
  input parameter position :: <gdouble>;
  input parameter max_size :: <gdouble>;
  c-name: "gtk_ruler_set_range";
end;

define C-function gtk-ruler-draw-ticks
  input parameter ruler :: <GtkRuler>;
  c-name: "gtk_ruler_draw_ticks";
end;

define C-function gtk-ruler-draw-pos
  input parameter ruler :: <GtkRuler>;
  c-name: "gtk_ruler_draw_pos";
end;

define C-function gtk-ruler-get-metric
  input parameter ruler :: <GtkRuler>;
  result res :: <GtkMetricType>;
  c-name: "gtk_ruler_get_metric";
end;

define C-function gtk-ruler-get-range
  input parameter ruler :: <GtkRuler>;
  input parameter lower :: <gdouble*>;
  input parameter upper :: <gdouble*>;
  input parameter position :: <gdouble*>;
  input parameter max_size :: <gdouble*>;
  c-name: "gtk_ruler_get_range";
end;

define C-subtype <_GtkPanedPrivate> (<C-void*>) end;
define constant <GtkPanedPrivate> = <_GtkPanedPrivate>;

define C-subtype <_GtkPaned> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkPaned> = <_GtkPaned>;

define C-subtype <_GtkVPaned> (<GtkPaned>, <AtkImplementorIface>) end;
define constant <GtkVPaned> = <_GtkVPaned>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6541>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6542>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6543>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6544>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6545>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6546>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6547>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6548>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6549>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6550>"*/
define C-subtype <_GtkPanedClass> (<C-void*>) end;
define constant <GtkPanedClass> = <_GtkPanedClass>;

define C-subtype <_GtkVPanedClass> (<C-void*>) end;
define constant <GtkVPanedClass> = <_GtkVPanedClass>;

define C-function gtk-vpaned-get-type
  result res :: <GType>;
  c-name: "gtk_vpaned_get_type";
end;

define C-function gtk-vpaned-new
  result res :: <GtkWidget>;
  c-name: "gtk_vpaned_new";
end;

define C-function gtk-paned-get-type
  result res :: <GType>;
  c-name: "gtk_paned_get_type";
end;

define C-function gtk-paned-add1
  input parameter paned :: <GtkPaned>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_paned_add1";
end;

define C-function gtk-paned-add2
  input parameter paned :: <GtkPaned>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_paned_add2";
end;

define C-function gtk-paned-pack1
  input parameter paned :: <GtkPaned>;
  input parameter child :: <GtkWidget>;
  input parameter resize :: <gboolean>;
  input parameter shrink :: <gboolean>;
  c-name: "gtk_paned_pack1";
end;

define C-function gtk-paned-pack2
  input parameter paned :: <GtkPaned>;
  input parameter child :: <GtkWidget>;
  input parameter resize :: <gboolean>;
  input parameter shrink :: <gboolean>;
  c-name: "gtk_paned_pack2";
end;

define C-function gtk-paned-get-position
  input parameter paned :: <GtkPaned>;
  result res :: <gint>;
  c-name: "gtk_paned_get_position";
end;

define C-function gtk-paned-set-position
  input parameter paned :: <GtkPaned>;
  input parameter position :: <gint>;
  c-name: "gtk_paned_set_position";
end;

define C-function gtk-paned-get-child1
  input parameter paned :: <GtkPaned>;
  result res :: <GtkWidget>;
  c-name: "gtk_paned_get_child1";
end;

define C-function gtk-paned-get-child2
  input parameter paned :: <GtkPaned>;
  result res :: <GtkWidget>;
  c-name: "gtk_paned_get_child2";
end;

define C-function gtk-paned-compute-position
  input parameter paned :: <GtkPaned>;
  input parameter allocation :: <gint>;
  input parameter child1_req :: <gint>;
  input parameter child2_req :: <gint>;
  c-name: "gtk_paned_compute_position";
end;

define C-subtype <_GtkViewport> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkViewport> = <_GtkViewport>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7616>"*/
define C-subtype <_GtkViewportClass> (<C-void*>) end;
define constant <GtkViewportClass> = <_GtkViewportClass>;

define C-function gtk-viewport-get-type
  result res :: <GType>;
  c-name: "gtk_viewport_get_type";
end;

define C-function gtk-viewport-new
  input parameter hadjustment :: <GtkAdjustment>;
  input parameter vadjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_viewport_new";
end;

define C-function gtk-viewport-get-hadjustment
  input parameter viewport :: <GtkViewport>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_viewport_get_hadjustment";
end;

define C-function gtk-viewport-get-vadjustment
  input parameter viewport :: <GtkViewport>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_viewport_get_vadjustment";
end;

define C-function gtk-viewport-set-hadjustment
  input parameter viewport :: <GtkViewport>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_viewport_set_hadjustment";
end;

define C-function gtk-viewport-set-vadjustment
  input parameter viewport :: <GtkViewport>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_viewport_set_vadjustment";
end;

define C-function gtk-viewport-set-shadow-type
  input parameter viewport :: <GtkViewport>;
  input parameter type :: <GtkShadowType>;
  c-name: "gtk_viewport_set_shadow_type";
end;

define C-function gtk-viewport-get-shadow-type
  input parameter viewport :: <GtkViewport>;
  result res :: <GtkShadowType>;
  c-name: "gtk_viewport_get_shadow_type";
end;

define constant $GTK-MAJOR-VERSION = 2;

define constant $GTK-MINOR-VERSION = 10;

define constant $GTK-MICRO-VERSION = 11;

define constant $GTK-BINARY-AGE = 1011;

define constant $GTK-INTERFACE-AGE = 11;

define C-subtype <_GtkBox> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkBox> = <_GtkBox>;

define C-subtype <_GtkVBox> (<GtkBox>, <AtkImplementorIface>) end;
define constant <GtkVBox> = <_GtkVBox>;

define C-subtype <_GtkBoxClass> (<C-void*>) end;
define constant <GtkBoxClass> = <_GtkBoxClass>;

define C-subtype <_GtkVBoxClass> (<C-void*>) end;
define constant <GtkVBoxClass> = <_GtkVBoxClass>;

define C-function gtk-vbox-get-type
  result res :: <GType>;
  c-name: "gtk_vbox_get_type";
end;

define C-function gtk-vbox-new
  input parameter homogeneous :: <gboolean>;
  input parameter spacing :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_vbox_new";
end;

define C-subtype <_GtkBoxChild> (<C-void*>) end;
define constant <GtkBoxChild> = <_GtkBoxChild>;

define C-function gtk-box-get-type
  result res :: <GType>;
  c-name: "gtk_box_get_type";
end;

define C-function gtk-box-pack-start
  input parameter box :: <GtkBox>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean>;
  input parameter fill :: <gboolean>;
  input parameter padding :: <guint>;
  c-name: "gtk_box_pack_start";
end;

define C-function gtk-box-pack-end
  input parameter box :: <GtkBox>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean>;
  input parameter fill :: <gboolean>;
  input parameter padding :: <guint>;
  c-name: "gtk_box_pack_end";
end;

define C-function gtk-box-pack-start-defaults
  input parameter box :: <GtkBox>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_box_pack_start_defaults";
end;

define C-function gtk-box-pack-end-defaults
  input parameter box :: <GtkBox>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_box_pack_end_defaults";
end;

define C-function gtk-box-set-homogeneous
  input parameter box :: <GtkBox>;
  input parameter homogeneous :: <gboolean>;
  c-name: "gtk_box_set_homogeneous";
end;

define C-function gtk-box-get-homogeneous
  input parameter box :: <GtkBox>;
  result res :: <gboolean>;
  c-name: "gtk_box_get_homogeneous";
end;

define C-function gtk-box-set-spacing
  input parameter box :: <GtkBox>;
  input parameter spacing :: <gint>;
  c-name: "gtk_box_set_spacing";
end;

define C-function gtk-box-get-spacing
  input parameter box :: <GtkBox>;
  result res :: <gint>;
  c-name: "gtk_box_get_spacing";
end;

define C-function gtk-box-reorder-child
  input parameter box :: <GtkBox>;
  input parameter child :: <GtkWidget>;
  input parameter position :: <gint>;
  c-name: "gtk_box_reorder_child";
end;

define C-pointer-type <GtkPackType*> => <GtkPackType>;
define C-function gtk-box-query-child-packing
  input parameter box :: <GtkBox>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean*>;
  input parameter fill :: <gboolean*>;
  input parameter padding :: <guint*>;
  input parameter pack_type :: <GtkPackType*>;
  c-name: "gtk_box_query_child_packing";
end;

define C-function gtk-box-set-child-packing
  input parameter box :: <GtkBox>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean>;
  input parameter fill :: <gboolean>;
  input parameter padding :: <guint>;
  input parameter pack_type :: <GtkPackType>;
  c-name: "gtk_box_set_child_packing";
end;

define C-subtype <_GtkButtonBox> (<GtkBox>, <AtkImplementorIface>) end;
define constant <GtkButtonBox> = <_GtkButtonBox>;

define C-subtype <_GtkVButtonBox> (<GtkButtonBox>, <AtkImplementorIface>) end;
define constant <GtkVButtonBox> = <_GtkVButtonBox>;

define C-subtype <_GtkButtonBoxClass> (<C-void*>) end;
define constant <GtkButtonBoxClass> = <_GtkButtonBoxClass>;

define C-subtype <_GtkVButtonBoxClass> (<C-void*>) end;
define constant <GtkVButtonBoxClass> = <_GtkVButtonBoxClass>;

define C-function gtk-vbutton-box-get-type
  result res :: <GType>;
  c-name: "gtk_vbutton_box_get_type";
end;

define C-function gtk-vbutton-box-new
  result res :: <GtkWidget>;
  c-name: "gtk_vbutton_box_new";
end;

define C-function gtk-vbutton-box-get-spacing-default
  result res :: <gint>;
  c-name: "gtk_vbutton_box_get_spacing_default";
end;

define C-function gtk-vbutton-box-set-spacing-default
  input parameter spacing :: <gint>;
  c-name: "gtk_vbutton_box_set_spacing_default";
end;

define C-function gtk-vbutton-box-get-layout-default
  result res :: <GtkButtonBoxStyle>;
  c-name: "gtk_vbutton_box_get_layout_default";
end;

define C-function gtk-vbutton-box-set-layout-default
  input parameter layout :: <GtkButtonBoxStyle>;
  c-name: "gtk_vbutton_box_set_layout_default";
end;

define C-function gtk-button-box-get-type
  result res :: <GType>;
  c-name: "gtk_button_box_get_type";
end;

define C-function gtk-button-box-get-layout
  input parameter widget :: <GtkButtonBox>;
  result res :: <GtkButtonBoxStyle>;
  c-name: "gtk_button_box_get_layout";
end;

define C-function gtk-button-box-set-layout
  input parameter widget :: <GtkButtonBox>;
  input parameter layout_style :: <GtkButtonBoxStyle>;
  c-name: "gtk_button_box_set_layout";
end;

define C-function gtk-button-box-get-child-secondary
  input parameter widget :: <GtkButtonBox>;
  input parameter child :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_button_box_get_child_secondary";
end;

define C-function gtk-button-box-set-child-secondary
  input parameter widget :: <GtkButtonBox>;
  input parameter child :: <GtkWidget>;
  input parameter is_secondary :: <gboolean>;
  c-name: "gtk_button_box_set_child_secondary";
end;

define C-function gtk-button-box-set-child-size
  input parameter widget :: <GtkButtonBox>;
  input parameter min_width :: <gint>;
  input parameter min_height :: <gint>;
  c-name: "gtk_button_box_set_child_size";
end;

define C-function gtk-button-box-set-child-ipadding
  input parameter widget :: <GtkButtonBox>;
  input parameter ipad_x :: <gint>;
  input parameter ipad_y :: <gint>;
  c-name: "gtk_button_box_set_child_ipadding";
end;

define C-function gtk-button-box-get-child-size
  input parameter widget :: <GtkButtonBox>;
  input parameter min_width :: <gint*>;
  input parameter min_height :: <gint*>;
  c-name: "gtk_button_box_get_child_size";
end;

define C-function gtk-button-box-get-child-ipadding
  input parameter widget :: <GtkButtonBox>;
  input parameter ipad_x :: <gint*>;
  input parameter ipad_y :: <gint*>;
  c-name: "gtk_button_box_get_child_ipadding";
end;

define C-function _gtk-button-box-child-requisition
  input parameter widget :: <GtkWidget>;
  input parameter nvis_children :: <int*>;
  input parameter nvis_secondaries :: <int*>;
  input parameter width :: <int*>;
  input parameter height :: <int*>;
  c-name: "_gtk_button_box_child_requisition";
end;

define constant $GTK-BUTTONBOX-DEFAULT = -1;

define C-subtype <_GtkUIManagerPrivate> (<C-void*>) end;
define constant <GtkUIManagerPrivate> = <_GtkUIManagerPrivate>;

define C-subtype <_GtkUIManager> (<C-void*>) end;
define constant <GtkUIManager> = <_GtkUIManager>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8173>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8174>"*/
define C-subtype <_GtkActionPrivate> (<C-void*>) end;
define constant <GtkActionPrivate> = <_GtkActionPrivate>;

define C-subtype <_GtkAction> (<C-void*>) end;
define constant <GtkAction> = <_GtkAction>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8175>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8176>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8177>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8178>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8179>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8180>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8181>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8182>"*/
define C-subtype <_GtkUIManagerClass> (<C-void*>) end;
define constant <GtkUIManagerClass> = <_GtkUIManagerClass>;

define constant <GtkUIManagerItemType> = limited(<integer>, min: 0, max: 256);
define constant $GTK-UI-MANAGER-AUTO :: <GtkUIManagerItemType> = 0;
define constant $GTK-UI-MANAGER-MENUBAR :: <GtkUIManagerItemType> = 1;
define constant $GTK-UI-MANAGER-MENU :: <GtkUIManagerItemType> = 2;
define constant $GTK-UI-MANAGER-TOOLBAR :: <GtkUIManagerItemType> = 4;
define constant $GTK-UI-MANAGER-PLACEHOLDER :: <GtkUIManagerItemType> = 8;
define constant $GTK-UI-MANAGER-POPUP :: <GtkUIManagerItemType> = 16;
define constant $GTK-UI-MANAGER-MENUITEM :: <GtkUIManagerItemType> = 32;
define constant $GTK-UI-MANAGER-TOOLITEM :: <GtkUIManagerItemType> = 64;
define constant $GTK-UI-MANAGER-SEPARATOR :: <GtkUIManagerItemType> = 128;
define constant $GTK-UI-MANAGER-ACCELERATOR :: <GtkUIManagerItemType> = 256;

define C-function gtk-ui-manager-get-type
  result res :: <GType>;
  c-name: "gtk_ui_manager_get_type";
end;

define C-function gtk-ui-manager-new
  result res :: <GtkUIManager>;
  c-name: "gtk_ui_manager_new";
end;

define C-function gtk-ui-manager-set-add-tearoffs
  input parameter self :: <GtkUIManager>;
  input parameter add_tearoffs :: <gboolean>;
  c-name: "gtk_ui_manager_set_add_tearoffs";
end;

define C-function gtk-ui-manager-get-add-tearoffs
  input parameter self :: <GtkUIManager>;
  result res :: <gboolean>;
  c-name: "gtk_ui_manager_get_add_tearoffs";
end;

define C-subtype <_GtkActionGroupPrivate> (<C-void*>) end;
define constant <GtkActionGroupPrivate> = <_GtkActionGroupPrivate>;

define C-subtype <_GtkActionGroup> (<C-void*>) end;
define constant <GtkActionGroup> = <_GtkActionGroup>;

define C-function gtk-ui-manager-insert-action-group
  input parameter self :: <GtkUIManager>;
  input parameter action_group :: <GtkActionGroup>;
  input parameter pos :: <gint>;
  c-name: "gtk_ui_manager_insert_action_group";
end;

define C-function gtk-ui-manager-remove-action-group
  input parameter self :: <GtkUIManager>;
  input parameter action_group :: <GtkActionGroup>;
  c-name: "gtk_ui_manager_remove_action_group";
end;

define C-function gtk-ui-manager-get-action-groups
  input parameter self :: <GtkUIManager>;
  result res :: <GList>;
  c-name: "gtk_ui_manager_get_action_groups";
end;

define C-function gtk-ui-manager-get-accel-group
  input parameter self :: <GtkUIManager>;
  result res :: <GtkAccelGroup>;
  c-name: "gtk_ui_manager_get_accel_group";
end;

define C-function gtk-ui-manager-get-widget
  input parameter self :: <GtkUIManager>;
  input parameter path :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_ui_manager_get_widget";
end;

define C-function gtk-ui-manager-get-toplevels
  input parameter self :: <GtkUIManager>;
  input parameter types :: <GtkUIManagerItemType>;
  result res :: <GSList>;
  c-name: "gtk_ui_manager_get_toplevels";
end;

define C-function gtk-ui-manager-get-action
  input parameter self :: <GtkUIManager>;
  input parameter path :: <c-string>;
  result res :: <GtkAction>;
  c-name: "gtk_ui_manager_get_action";
end;

define C-function gtk-ui-manager-add-ui-from-string
  input parameter self :: <GtkUIManager>;
  input parameter buffer :: <c-string>;
  input parameter length :: <gssize>;
  input parameter error :: <GError*>;
  result res :: <guint>;
  c-name: "gtk_ui_manager_add_ui_from_string";
end;

define C-function gtk-ui-manager-add-ui-from-file-utf8
  input parameter self :: <GtkUIManager>;
  input parameter filename :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <guint>;
  c-name: "gtk_ui_manager_add_ui_from_file_utf8";
end;

define C-function gtk-ui-manager-add-ui
  input parameter self :: <GtkUIManager>;
  input parameter merge_id :: <guint>;
  input parameter path :: <c-string>;
  input parameter name :: <c-string>;
  input parameter action :: <c-string>;
  input parameter type :: <GtkUIManagerItemType>;
  input parameter top :: <gboolean>;
  c-name: "gtk_ui_manager_add_ui";
end;

define C-function gtk-ui-manager-remove-ui
  input parameter self :: <GtkUIManager>;
  input parameter merge_id :: <guint>;
  c-name: "gtk_ui_manager_remove_ui";
end;

define C-function gtk-ui-manager-get-ui
  input parameter self :: <GtkUIManager>;
  result res :: <c-string>;
  c-name: "gtk_ui_manager_get_ui";
end;

define C-function gtk-ui-manager-ensure-update
  input parameter self :: <GtkUIManager>;
  c-name: "gtk_ui_manager_ensure_update";
end;

define C-function gtk-ui-manager-new-merge-id
  input parameter self :: <GtkUIManager>;
  result res :: <guint>;
  c-name: "gtk_ui_manager_new_merge_id";
end;

define constant gtk-ui-manager-add-ui-from-file = gtk-ui-manager-add-ui-from-file-utf8;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4706>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4707>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4708>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4709>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4710>"*/
define C-subtype <_GtkActionGroupClass> (<C-void*>) end;
define constant <GtkActionGroupClass> = <_GtkActionGroupClass>;

define C-subtype <_GtkActionEntry> (<C-void*>) end;
define constant <GtkActionEntry> = <_GtkActionEntry>;

define C-subtype <_GtkToggleActionEntry> (<C-void*>) end;
define constant <GtkToggleActionEntry> = <_GtkToggleActionEntry>;

define C-subtype <_GtkRadioActionEntry> (<C-void*>) end;
define constant <GtkRadioActionEntry> = <_GtkRadioActionEntry>;

define C-function gtk-action-group-get-type
  result res :: <GType>;
  c-name: "gtk_action_group_get_type";
end;

define C-function gtk-action-group-new
  input parameter name :: <c-string>;
  result res :: <GtkActionGroup>;
  c-name: "gtk_action_group_new";
end;

define C-function gtk-action-group-get-name
  input parameter action_group :: <GtkActionGroup>;
  result res :: <c-string>;
  c-name: "gtk_action_group_get_name";
end;

define C-function gtk-action-group-get-sensitive
  input parameter action_group :: <GtkActionGroup>;
  result res :: <gboolean>;
  c-name: "gtk_action_group_get_sensitive";
end;

define C-function gtk-action-group-set-sensitive
  input parameter action_group :: <GtkActionGroup>;
  input parameter sensitive :: <gboolean>;
  c-name: "gtk_action_group_set_sensitive";
end;

define C-function gtk-action-group-get-visible
  input parameter action_group :: <GtkActionGroup>;
  result res :: <gboolean>;
  c-name: "gtk_action_group_get_visible";
end;

define C-function gtk-action-group-set-visible
  input parameter action_group :: <GtkActionGroup>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_action_group_set_visible";
end;

define C-function gtk-action-group-get-action
  input parameter action_group :: <GtkActionGroup>;
  input parameter action_name :: <c-string>;
  result res :: <GtkAction>;
  c-name: "gtk_action_group_get_action";
end;

define C-function gtk-action-group-list-actions
  input parameter action_group :: <GtkActionGroup>;
  result res :: <GList>;
  c-name: "gtk_action_group_list_actions";
end;

define C-function gtk-action-group-add-action
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  c-name: "gtk_action_group_add_action";
end;

define C-function gtk-action-group-add-action-with-accel
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  input parameter accelerator :: <c-string>;
  c-name: "gtk_action_group_add_action_with_accel";
end;

define C-function gtk-action-group-remove-action
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  c-name: "gtk_action_group_remove_action";
end;

define C-function gtk-action-group-add-actions
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_action_group_add_actions";
end;

define C-function gtk-action-group-add-toggle-actions
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkToggleActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_action_group_add_toggle_actions";
end;

define C-function gtk-action-group-add-radio-actions
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkRadioActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter value :: <gint>;
  input parameter on_change :: <GCallback>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_action_group_add_radio_actions";
end;

define C-function gtk-action-group-add-actions-full
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_action_group_add_actions_full";
end;

define C-function gtk-action-group-add-toggle-actions-full
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkToggleActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_action_group_add_toggle_actions_full";
end;

define C-function gtk-action-group-add-radio-actions-full
  input parameter action_group :: <GtkActionGroup>;
  input parameter entries :: <GtkRadioActionEntry>;
  input parameter n_entries :: <guint>;
  input parameter value :: <gint>;
  input parameter on_change :: <GCallback>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_action_group_add_radio_actions_full";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4671>"*/
define constant <GtkTranslateFunc> = <anonymous-4671>;

define C-function gtk-action-group-set-translate-func
  input parameter action_group :: <GtkActionGroup>;
  input parameter func :: <GtkTranslateFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GtkDestroyNotify>;
  c-name: "gtk_action_group_set_translate_func";
end;

define C-function gtk-action-group-set-translation-domain
  input parameter action_group :: <GtkActionGroup>;
  input parameter domain :: <c-string>;
  c-name: "gtk_action_group_set_translation_domain";
end;

define C-function gtk-action-group-translate-string
  input parameter action_group :: <GtkActionGroup>;
  input parameter string :: <c-string>;
  result res :: <c-string>;
  c-name: "gtk_action_group_translate_string";
end;

define C-function _gtk-action-group-emit-connect-proxy
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "_gtk_action_group_emit_connect_proxy";
end;

define C-function _gtk-action-group-emit-disconnect-proxy
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "_gtk_action_group_emit_disconnect_proxy";
end;

define C-function _gtk-action-group-emit-pre-activate
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  c-name: "_gtk_action_group_emit_pre_activate";
end;

define C-function _gtk-action-group-emit-post-activate
  input parameter action_group :: <GtkActionGroup>;
  input parameter action :: <GtkAction>;
  c-name: "_gtk_action_group_emit_post_activate";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4672>"*/
define constant <GtkPrintFunc> = <anonymous-4672>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4673>"*/
define constant <GtkItemFactoryCallback> = <anonymous-4673>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4674>"*/
define constant <GtkItemFactoryCallback1> = <anonymous-4674>;

define C-subtype <_GtkItemFactory> (<GtkObject>) end;
define constant <GtkItemFactory> = <_GtkItemFactory>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4675>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4676>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4677>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4678>"*/
define C-subtype <_GtkItemFactoryClass> (<C-void*>) end;
define constant <GtkItemFactoryClass> = <_GtkItemFactoryClass>;

define C-subtype <_GtkItemFactoryEntry> (<C-void*>) end;
define constant <GtkItemFactoryEntry> = <_GtkItemFactoryEntry>;

define C-subtype <_GtkItemFactoryItem> (<C-void*>) end;
define constant <GtkItemFactoryItem> = <_GtkItemFactoryItem>;

define C-function gtk-item-factory-get-type
  result res :: <GType>;
  c-name: "gtk_item_factory_get_type";
end;

define C-function gtk-item-factory-new
  input parameter container_type :: <GType>;
  input parameter path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  result res :: <GtkItemFactory>;
  c-name: "gtk_item_factory_new";
end;

define C-function gtk-item-factory-construct
  input parameter ifactory :: <GtkItemFactory>;
  input parameter container_type :: <GType>;
  input parameter path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_item_factory_construct";
end;

define C-function gtk-item-factory-add-foreign
  input parameter accel_widget :: <GtkWidget>;
  input parameter full_path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  c-name: "gtk_item_factory_add_foreign";
end;

define C-function gtk-item-factory-from-widget
  input parameter widget :: <GtkWidget>;
  result res :: <GtkItemFactory>;
  c-name: "gtk_item_factory_from_widget";
end;

define C-function gtk-item-factory-path-from-widget
  input parameter widget :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_item_factory_path_from_widget";
end;

define C-function gtk-item-factory-get-item
  input parameter ifactory :: <GtkItemFactory>;
  input parameter path :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_item_factory_get_item";
end;

define C-function gtk-item-factory-get-widget
  input parameter ifactory :: <GtkItemFactory>;
  input parameter path :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_item_factory_get_widget";
end;

define C-function gtk-item-factory-get-widget-by-action
  input parameter ifactory :: <GtkItemFactory>;
  input parameter action :: <guint>;
  result res :: <GtkWidget>;
  c-name: "gtk_item_factory_get_widget_by_action";
end;

define C-function gtk-item-factory-get-item-by-action
  input parameter ifactory :: <GtkItemFactory>;
  input parameter action :: <guint>;
  result res :: <GtkWidget>;
  c-name: "gtk_item_factory_get_item_by_action";
end;

define C-function gtk-item-factory-create-item
  input parameter ifactory :: <GtkItemFactory>;
  input parameter entry :: <GtkItemFactoryEntry>;
  input parameter callback_data :: <gpointer>;
  input parameter callback_type :: <guint>;
  c-name: "gtk_item_factory_create_item";
end;

define C-function gtk-item-factory-create-items
  input parameter ifactory :: <GtkItemFactory>;
  input parameter n_entries :: <guint>;
  input parameter entries :: <GtkItemFactoryEntry>;
  input parameter callback_data :: <gpointer>;
  c-name: "gtk_item_factory_create_items";
end;

define C-function gtk-item-factory-delete-item
  input parameter ifactory :: <GtkItemFactory>;
  input parameter path :: <c-string>;
  c-name: "gtk_item_factory_delete_item";
end;

define C-function gtk-item-factory-delete-entry
  input parameter ifactory :: <GtkItemFactory>;
  input parameter entry :: <GtkItemFactoryEntry>;
  c-name: "gtk_item_factory_delete_entry";
end;

define C-function gtk-item-factory-delete-entries
  input parameter ifactory :: <GtkItemFactory>;
  input parameter n_entries :: <guint>;
  input parameter entries :: <GtkItemFactoryEntry>;
  c-name: "gtk_item_factory_delete_entries";
end;

define C-function gtk-item-factory-popup
  input parameter ifactory :: <GtkItemFactory>;
  input parameter x :: <guint>;
  input parameter y :: <guint>;
  input parameter mouse_button :: <guint>;
  input parameter time_ :: <guint32>;
  c-name: "gtk_item_factory_popup";
end;

define C-function gtk-item-factory-popup-with-data
  input parameter ifactory :: <GtkItemFactory>;
  input parameter popup_data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  input parameter x :: <guint>;
  input parameter y :: <guint>;
  input parameter mouse_button :: <guint>;
  input parameter time_ :: <guint32>;
  c-name: "gtk_item_factory_popup_with_data";
end;

define C-function gtk-item-factory-popup-data
  input parameter ifactory :: <GtkItemFactory>;
  result res :: <gpointer>;
  c-name: "gtk_item_factory_popup_data";
end;

define C-function gtk-item-factory-popup-data-from-widget
  input parameter widget :: <GtkWidget>;
  result res :: <gpointer>;
  c-name: "gtk_item_factory_popup_data_from_widget";
end;

define C-function gtk-item-factory-set-translate-func
  input parameter ifactory :: <GtkItemFactory>;
  input parameter func :: <GtkTranslateFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GtkDestroyNotify>;
  c-name: "gtk_item_factory_set_translate_func";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4699>"*/
define constant <GtkMenuCallback> = <anonymous-4699>;

define C-subtype <GtkMenuEntry> (<C-void*>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4701>"*/
define constant <GtkItemFactoryCallback2> = <anonymous-4701>;

define C-function gtk-item-factory-create-items-ac
  input parameter ifactory :: <GtkItemFactory>;
  input parameter n_entries :: <guint>;
  input parameter entries :: <GtkItemFactoryEntry>;
  input parameter callback_data :: <gpointer>;
  input parameter callback_type :: <guint>;
  c-name: "gtk_item_factory_create_items_ac";
end;

define C-function gtk-item-factory-from-path
  input parameter path :: <c-string>;
  result res :: <GtkItemFactory>;
  c-name: "gtk_item_factory_from_path";
end;

define C-function gtk-item-factory-create-menu-entries
  input parameter n_entries :: <guint>;
  input parameter entries :: <GtkMenuEntry>;
  c-name: "gtk_item_factory_create_menu_entries";
end;

define C-function gtk-item-factories-path-delete
  input parameter ifactory_path :: <c-string>;
  input parameter path :: <c-string>;
  c-name: "gtk_item_factories_path_delete";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4633>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4634>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4635>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4636>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4637>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4638>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4639>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4640>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4641>"*/
define C-subtype <_GtkActionClass> (<C-void*>) end;
define constant <GtkActionClass> = <_GtkActionClass>;

define C-function gtk-action-get-type
  result res :: <GType>;
  c-name: "gtk_action_get_type";
end;

define C-function gtk-action-new
  input parameter name :: <c-string>;
  input parameter label :: <c-string>;
  input parameter tooltip :: <c-string>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkAction>;
  c-name: "gtk_action_new";
end;

define C-function gtk-action-get-name
  input parameter action :: <GtkAction>;
  result res :: <c-string>;
  c-name: "gtk_action_get_name";
end;

define C-function gtk-action-is-sensitive
  input parameter action :: <GtkAction>;
  result res :: <gboolean>;
  c-name: "gtk_action_is_sensitive";
end;

define C-function gtk-action-get-sensitive
  input parameter action :: <GtkAction>;
  result res :: <gboolean>;
  c-name: "gtk_action_get_sensitive";
end;

define C-function gtk-action-set-sensitive
  input parameter action :: <GtkAction>;
  input parameter sensitive :: <gboolean>;
  c-name: "gtk_action_set_sensitive";
end;

define C-function gtk-action-is-visible
  input parameter action :: <GtkAction>;
  result res :: <gboolean>;
  c-name: "gtk_action_is_visible";
end;

define C-function gtk-action-get-visible
  input parameter action :: <GtkAction>;
  result res :: <gboolean>;
  c-name: "gtk_action_get_visible";
end;

define C-function gtk-action-set-visible
  input parameter action :: <GtkAction>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_action_set_visible";
end;

define C-function gtk-action-activate
  input parameter action :: <GtkAction>;
  c-name: "gtk_action_activate";
end;

define C-function gtk-action-create-icon
  input parameter action :: <GtkAction>;
  input parameter icon_size :: <GtkIconSize>;
  result res :: <GtkWidget>;
  c-name: "gtk_action_create_icon";
end;

define C-function gtk-action-create-menu-item
  input parameter action :: <GtkAction>;
  result res :: <GtkWidget>;
  c-name: "gtk_action_create_menu_item";
end;

define C-function gtk-action-create-tool-item
  input parameter action :: <GtkAction>;
  result res :: <GtkWidget>;
  c-name: "gtk_action_create_tool_item";
end;

define C-function gtk-action-connect-proxy
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "gtk_action_connect_proxy";
end;

define C-function gtk-action-disconnect-proxy
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "gtk_action_disconnect_proxy";
end;

define C-function gtk-action-get-proxies
  input parameter action :: <GtkAction>;
  result res :: <GSList>;
  c-name: "gtk_action_get_proxies";
end;

define C-function gtk-widget-get-action
  input parameter widget :: <GtkWidget>;
  result res :: <GtkAction>;
  c-name: "gtk_widget_get_action";
end;

define C-function gtk-action-connect-accelerator
  input parameter action :: <GtkAction>;
  c-name: "gtk_action_connect_accelerator";
end;

define C-function gtk-action-disconnect-accelerator
  input parameter action :: <GtkAction>;
  c-name: "gtk_action_disconnect_accelerator";
end;

define C-function gtk-action-get-accel-path
  input parameter action :: <GtkAction>;
  result res :: <c-string>;
  c-name: "gtk_action_get_accel_path";
end;

define C-function gtk-action-get-accel-closure
  input parameter action :: <GtkAction>;
  result res :: <GClosure>;
  c-name: "gtk_action_get_accel_closure";
end;

define C-function gtk-action-block-activate-from
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "gtk_action_block_activate_from";
end;

define C-function gtk-action-unblock-activate-from
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  c-name: "gtk_action_unblock_activate_from";
end;

define C-function _gtk-action-emit-activate
  input parameter action :: <GtkAction>;
  c-name: "_gtk_action_emit_activate";
end;

define C-function gtk-action-set-accel-path
  input parameter action :: <GtkAction>;
  input parameter accel_path :: <c-string>;
  c-name: "gtk_action_set_accel_path";
end;

define C-function gtk-action-set-accel-group
  input parameter action :: <GtkAction>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_action_set_accel_group";
end;

define C-function _gtk-action-sync-sensitive
  input parameter action :: <GtkAction>;
  c-name: "_gtk_action_sync_sensitive";
end;

define C-function _gtk-action-sync-visible
  input parameter action :: <GtkAction>;
  c-name: "_gtk_action_sync_visible";
end;

define C-function _gtk-action-sync-menu-visible
  input parameter action :: <GtkAction>;
  input parameter proxy :: <GtkWidget>;
  input parameter empty :: <gboolean>;
  c-name: "_gtk_action_sync_menu_visible";
end;

define constant <GtkTreeViewColumnSizing> = limited(<integer>, min: 0, max: 2);
define constant $GTK-TREE-VIEW-COLUMN-GROW-ONLY :: <GtkTreeViewColumnSizing> = 0;
define constant $GTK-TREE-VIEW-COLUMN-AUTOSIZE :: <GtkTreeViewColumnSizing> = 1;
define constant $GTK-TREE-VIEW-COLUMN-FIXED :: <GtkTreeViewColumnSizing> = 2;

define C-subtype <_GtkCellEditable> (<C-void*>) end;
define constant <GtkCellEditable> = <_GtkCellEditable>;

define C-subtype <_GtkTreeViewColumn> (<GtkObject>) end;
define constant <GtkTreeViewColumn> = <_GtkTreeViewColumn>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5122>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5123>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5124>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5125>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5126>"*/
define C-subtype <_GtkTreeViewColumnClass> (<C-void*>) end;
define constant <GtkTreeViewColumnClass> = <_GtkTreeViewColumnClass>;

define C-subtype <_GtkCellRenderer> (<GtkObject>) end;
define constant <GtkCellRenderer> = <_GtkCellRenderer>;

define C-subtype <_GtkTreeModel> (<C-void*>) end;
define constant <GtkTreeModel> = <_GtkTreeModel>;

define C-subtype <_GtkTreeIter> (<C-void*>) end;
define constant <GtkTreeIter> = <_GtkTreeIter>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5112>"*/
define constant <GtkTreeCellDataFunc> = <anonymous-5112>;

define C-function gtk-tree-view-column-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_column_get_type";
end;

define C-function gtk-tree-view-column-new
  result res :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_column_new";
end;

define C-function gtk-tree-view-column-new-with-attributes
  input parameter title :: <c-string>;
  input parameter cell :: <GtkCellRenderer>;
  result res :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_column_new_with_attributes";
end;

define C-function gtk-tree-view-column-pack-start
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_tree_view_column_pack_start";
end;

define C-function gtk-tree-view-column-pack-end
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_tree_view_column_pack_end";
end;

define C-function gtk-tree-view-column-clear
  input parameter tree_column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_column_clear";
end;

define C-function gtk-tree-view-column-get-cell-renderers
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <GList>;
  c-name: "gtk_tree_view_column_get_cell_renderers";
end;

define C-function gtk-tree-view-column-add-attribute
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_renderer :: <GtkCellRenderer>;
  input parameter attribute :: <c-string>;
  input parameter column :: <gint>;
  c-name: "gtk_tree_view_column_add_attribute";
end;

define C-function gtk-tree-view-column-set-attributes
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_renderer :: <GtkCellRenderer>;
  c-name: "gtk_tree_view_column_set_attributes";
end;

define C-function gtk-tree-view-column-set-cell-data-func
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_renderer :: <GtkCellRenderer>;
  input parameter func :: <GtkTreeCellDataFunc>;
  input parameter func_data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_view_column_set_cell_data_func";
end;

define C-function gtk-tree-view-column-clear-attributes
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_renderer :: <GtkCellRenderer>;
  c-name: "gtk_tree_view_column_clear_attributes";
end;

define C-function gtk-tree-view-column-set-spacing
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter spacing :: <gint>;
  c-name: "gtk_tree_view_column_set_spacing";
end;

define C-function gtk-tree-view-column-get-spacing
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_spacing";
end;

define C-function gtk-tree-view-column-set-visible
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_tree_view_column_set_visible";
end;

define C-function gtk-tree-view-column-get-visible
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_visible";
end;

define C-function gtk-tree-view-column-set-resizable
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter resizable :: <gboolean>;
  c-name: "gtk_tree_view_column_set_resizable";
end;

define C-function gtk-tree-view-column-get-resizable
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_resizable";
end;

define C-function gtk-tree-view-column-set-sizing
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter type :: <GtkTreeViewColumnSizing>;
  c-name: "gtk_tree_view_column_set_sizing";
end;

define C-function gtk-tree-view-column-get-sizing
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <GtkTreeViewColumnSizing>;
  c-name: "gtk_tree_view_column_get_sizing";
end;

define C-function gtk-tree-view-column-get-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_width";
end;

define C-function gtk-tree-view-column-get-fixed-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_fixed_width";
end;

define C-function gtk-tree-view-column-set-fixed-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter fixed_width :: <gint>;
  c-name: "gtk_tree_view_column_set_fixed_width";
end;

define C-function gtk-tree-view-column-set-min-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter min_width :: <gint>;
  c-name: "gtk_tree_view_column_set_min_width";
end;

define C-function gtk-tree-view-column-get-min-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_min_width";
end;

define C-function gtk-tree-view-column-set-max-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter max_width :: <gint>;
  c-name: "gtk_tree_view_column_set_max_width";
end;

define C-function gtk-tree-view-column-get-max-width
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_max_width";
end;

define C-function gtk-tree-view-column-clicked
  input parameter tree_column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_column_clicked";
end;

define C-function gtk-tree-view-column-set-title
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter title :: <c-string>;
  c-name: "gtk_tree_view_column_set_title";
end;

define C-function gtk-tree-view-column-get-title
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <c-string>;
  c-name: "gtk_tree_view_column_get_title";
end;

define C-function gtk-tree-view-column-set-expand
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_tree_view_column_set_expand";
end;

define C-function gtk-tree-view-column-get-expand
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_expand";
end;

define C-function gtk-tree-view-column-set-clickable
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter clickable :: <gboolean>;
  c-name: "gtk_tree_view_column_set_clickable";
end;

define C-function gtk-tree-view-column-get-clickable
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_clickable";
end;

define C-function gtk-tree-view-column-set-widget
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_tree_view_column_set_widget";
end;

define C-function gtk-tree-view-column-get-widget
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <GtkWidget>;
  c-name: "gtk_tree_view_column_get_widget";
end;

define C-function gtk-tree-view-column-set-alignment
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter xalign :: <gfloat>;
  c-name: "gtk_tree_view_column_set_alignment";
end;

define C-function gtk-tree-view-column-get-alignment
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gfloat>;
  c-name: "gtk_tree_view_column_get_alignment";
end;

define C-function gtk-tree-view-column-set-reorderable
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter reorderable :: <gboolean>;
  c-name: "gtk_tree_view_column_set_reorderable";
end;

define C-function gtk-tree-view-column-get-reorderable
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_reorderable";
end;

define C-function gtk-tree-view-column-set-sort-column-id
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter sort_column_id :: <gint>;
  c-name: "gtk_tree_view_column_set_sort_column_id";
end;

define C-function gtk-tree-view-column-get-sort-column-id
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_column_get_sort_column_id";
end;

define C-function gtk-tree-view-column-set-sort-indicator
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_tree_view_column_set_sort_indicator";
end;

define C-function gtk-tree-view-column-get-sort-indicator
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_get_sort_indicator";
end;

define C-function gtk-tree-view-column-set-sort-order
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter order :: <GtkSortType>;
  c-name: "gtk_tree_view_column_set_sort_order";
end;

define C-function gtk-tree-view-column-get-sort-order
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <GtkSortType>;
  c-name: "gtk_tree_view_column_get_sort_order";
end;

define C-function gtk-tree-view-column-cell-set-cell-data
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter is_expander :: <gboolean>;
  input parameter is_expanded :: <gboolean>;
  c-name: "gtk_tree_view_column_cell_set_cell_data";
end;

define C-function gtk-tree-view-column-cell-get-size
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_area :: <GdkRectangle>;
  input parameter x_offset :: <gint*>;
  input parameter y_offset :: <gint*>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_tree_view_column_cell_get_size";
end;

define C-function gtk-tree-view-column-cell-is-visible
  input parameter tree_column :: <GtkTreeViewColumn>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_cell_is_visible";
end;

define C-function gtk-tree-view-column-focus-cell
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell :: <GtkCellRenderer>;
  c-name: "gtk_tree_view_column_focus_cell";
end;

define C-function gtk-tree-view-column-cell-get-position
  input parameter tree_column :: <GtkTreeViewColumn>;
  input parameter cell_renderer :: <GtkCellRenderer>;
  input parameter start_pos :: <gint*>;
  input parameter width :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_column_cell_get_position";
end;

define C-function gtk-tree-view-column-queue-resize
  input parameter tree_column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_column_queue_resize";
end;

define constant <anonymous-5096> = limited(<integer>, min: -2, max: -1);
define constant $GTK-TREE-SORTABLE-DEFAULT-SORT-COLUMN-ID :: <anonymous-5096> = -1;
define constant $GTK-TREE-SORTABLE-UNSORTED-SORT-COLUMN-ID :: <anonymous-5096> = -2;

define C-subtype <_GtkTreeSortable> (<C-void*>) end;
define constant <GtkTreeSortable> = <_GtkTreeSortable>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5098>"*/
define C-pointer-type <GtkSortType*> => <GtkSortType>;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5099>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5100>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5097>"*/
define constant <GtkTreeIterCompareFunc> = <anonymous-5097>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5101>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5102>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5103>"*/
define C-subtype <_GtkTreeSortableIface> (<C-void*>) end;
define constant <GtkTreeSortableIface> = <_GtkTreeSortableIface>;

define C-function gtk-tree-sortable-get-type
  result res :: <GType>;
  c-name: "gtk_tree_sortable_get_type";
end;

define C-function gtk-tree-sortable-sort-column-changed
  input parameter sortable :: <GtkTreeSortable>;
  c-name: "gtk_tree_sortable_sort_column_changed";
end;

define C-function gtk-tree-sortable-get-sort-column-id
  input parameter sortable :: <GtkTreeSortable>;
  input parameter sort_column_id :: <gint*>;
  input parameter order :: <GtkSortType*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_sortable_get_sort_column_id";
end;

define C-function gtk-tree-sortable-set-sort-column-id
  input parameter sortable :: <GtkTreeSortable>;
  input parameter sort_column_id :: <gint>;
  input parameter order :: <GtkSortType>;
  c-name: "gtk_tree_sortable_set_sort_column_id";
end;

define C-function gtk-tree-sortable-set-sort-func
  input parameter sortable :: <GtkTreeSortable>;
  input parameter sort_column_id :: <gint>;
  input parameter sort_func :: <GtkTreeIterCompareFunc>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_sortable_set_sort_func";
end;

define C-function gtk-tree-sortable-set-default-sort-func
  input parameter sortable :: <GtkTreeSortable>;
  input parameter sort_func :: <GtkTreeIterCompareFunc>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_sortable_set_default_sort_func";
end;

define C-function gtk-tree-sortable-has-default-sort-func
  input parameter sortable :: <GtkTreeSortable>;
  result res :: <gboolean>;
  c-name: "gtk_tree_sortable_has_default_sort_func";
end;

define C-subtype <_GtkTreePath> (<C-void*>) end;
define constant <GtkTreePath> = <_GtkTreePath>;

define C-subtype <_GtkTreeRowReference> (<C-void*>) end;
define constant <GtkTreeRowReference> = <_GtkTreeRowReference>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5018>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5019>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5020>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5021>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5022>"*/
define constant <GtkTreeModelFlags> = limited(<integer>, min: 1, max: 2);
define constant $GTK-TREE-MODEL-ITERS-PERSIST :: <GtkTreeModelFlags> = 1;
define constant $GTK-TREE-MODEL-LIST-ONLY :: <GtkTreeModelFlags> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5023>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5024>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5025>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5026>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5027>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5028>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5029>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5030>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5031>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5032>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5033>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5034>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5035>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5036>"*/
define C-subtype <_GtkTreeModelIface> (<C-void*>) end;
define constant <GtkTreeModelIface> = <_GtkTreeModelIface>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5016>"*/
define constant <GtkTreeModelForeachFunc> = <anonymous-5016>;

define C-function gtk-tree-path-new
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_path_new";
end;

define C-function gtk-tree-path-new-from-string
  input parameter path :: <c-string>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_path_new_from_string";
end;

define C-function gtk-tree-path-new-from-indices
  input parameter first_index :: <gint>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_path_new_from_indices";
end;

define C-function gtk-tree-path-to-string
  input parameter path :: <GtkTreePath>;
  result res :: <c-string>;
  c-name: "gtk_tree_path_to_string";
end;

define C-function gtk-tree-path-new-first
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_path_new_first";
end;

define C-function gtk-tree-path-append-index
  input parameter path :: <GtkTreePath>;
  input parameter index_ :: <gint>;
  c-name: "gtk_tree_path_append_index";
end;

define C-function gtk-tree-path-prepend-index
  input parameter path :: <GtkTreePath>;
  input parameter index_ :: <gint>;
  c-name: "gtk_tree_path_prepend_index";
end;

define C-function gtk-tree-path-get-depth
  input parameter path :: <GtkTreePath>;
  result res :: <gint>;
  c-name: "gtk_tree_path_get_depth";
end;

define C-function gtk-tree-path-get-indices
  input parameter path :: <GtkTreePath>;
  result res :: <gint*>;
  c-name: "gtk_tree_path_get_indices";
end;

define C-function gtk-tree-path-free
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_path_free";
end;

define C-function gtk-tree-path-copy
  input parameter path :: <GtkTreePath>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_path_copy";
end;

define C-function gtk-tree-path-get-type
  result res :: <GType>;
  c-name: "gtk_tree_path_get_type";
end;

define C-function gtk-tree-path-compare
  input parameter a :: <GtkTreePath>;
  input parameter b :: <GtkTreePath>;
  result res :: <gint>;
  c-name: "gtk_tree_path_compare";
end;

define C-function gtk-tree-path-next
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_path_next";
end;

define C-function gtk-tree-path-prev
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_path_prev";
end;

define C-function gtk-tree-path-up
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_path_up";
end;

define C-function gtk-tree-path-down
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_path_down";
end;

define C-function gtk-tree-path-is-ancestor
  input parameter path :: <GtkTreePath>;
  input parameter descendant :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_path_is_ancestor";
end;

define C-function gtk-tree-path-is-descendant
  input parameter path :: <GtkTreePath>;
  input parameter ancestor :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_path_is_descendant";
end;

define C-function gtk-tree-row-reference-get-type
  result res :: <GType>;
  c-name: "gtk_tree_row_reference_get_type";
end;

define C-function gtk-tree-row-reference-new
  input parameter model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  result res :: <GtkTreeRowReference>;
  c-name: "gtk_tree_row_reference_new";
end;

define C-function gtk-tree-row-reference-new-proxy
  input parameter proxy :: <GObject>;
  input parameter model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  result res :: <GtkTreeRowReference>;
  c-name: "gtk_tree_row_reference_new_proxy";
end;

define C-function gtk-tree-row-reference-get-path
  input parameter reference :: <GtkTreeRowReference>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_row_reference_get_path";
end;

define C-function gtk-tree-row-reference-get-model
  input parameter reference :: <GtkTreeRowReference>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_row_reference_get_model";
end;

define C-function gtk-tree-row-reference-valid
  input parameter reference :: <GtkTreeRowReference>;
  result res :: <gboolean>;
  c-name: "gtk_tree_row_reference_valid";
end;

define C-function gtk-tree-row-reference-copy
  input parameter reference :: <GtkTreeRowReference>;
  result res :: <GtkTreeRowReference>;
  c-name: "gtk_tree_row_reference_copy";
end;

define C-function gtk-tree-row-reference-free
  input parameter reference :: <GtkTreeRowReference>;
  c-name: "gtk_tree_row_reference_free";
end;

define C-function gtk-tree-row-reference-inserted
  input parameter proxy :: <GObject>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_row_reference_inserted";
end;

define C-function gtk-tree-row-reference-deleted
  input parameter proxy :: <GObject>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_row_reference_deleted";
end;

define C-function gtk-tree-row-reference-reordered
  input parameter proxy :: <GObject>;
  input parameter path :: <GtkTreePath>;
  input parameter iter :: <GtkTreeIter>;
  input parameter new_order :: <gint*>;
  c-name: "gtk_tree_row_reference_reordered";
end;

define C-function gtk-tree-iter-copy
  input parameter iter :: <GtkTreeIter>;
  result res :: <GtkTreeIter>;
  c-name: "gtk_tree_iter_copy";
end;

define C-function gtk-tree-iter-free
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_iter_free";
end;

define C-function gtk-tree-iter-get-type
  result res :: <GType>;
  c-name: "gtk_tree_iter_get_type";
end;

define C-function gtk-tree-model-get-type
  result res :: <GType>;
  c-name: "gtk_tree_model_get_type";
end;

define C-function gtk-tree-model-get-flags
  input parameter tree_model :: <GtkTreeModel>;
  result res :: <GtkTreeModelFlags>;
  c-name: "gtk_tree_model_get_flags";
end;

define C-function gtk-tree-model-get-n-columns
  input parameter tree_model :: <GtkTreeModel>;
  result res :: <gint>;
  c-name: "gtk_tree_model_get_n_columns";
end;

define C-function gtk-tree-model-get-column-type
  input parameter tree_model :: <GtkTreeModel>;
  input parameter index_ :: <gint>;
  result res :: <GType>;
  c-name: "gtk_tree_model_get_column_type";
end;

define C-function gtk-tree-model-get-iter
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_get_iter";
end;

define C-function gtk-tree-model-get-iter-from-string
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter path_string :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_get_iter_from_string";
end;

define C-function gtk-tree-model-get-string-from-iter
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <c-string>;
  c-name: "gtk_tree_model_get_string_from_iter";
end;

define C-function gtk-tree-model-get-iter-first
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_get_iter_first";
end;

define C-function gtk-tree-model-get-path
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_model_get_path";
end;

define C-function gtk-tree-model-get-value
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter column :: <gint>;
  input parameter value :: <GValue>;
  c-name: "gtk_tree_model_get_value";
end;

define C-function gtk-tree-model-iter-next
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_iter_next";
end;

define C-function gtk-tree-model-iter-children
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_iter_children";
end;

define C-function gtk-tree-model-iter-has-child
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_iter_has_child";
end;

define C-function gtk-tree-model-iter-n-children
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gint>;
  c-name: "gtk_tree_model_iter_n_children";
end;

define C-function gtk-tree-model-iter-nth-child
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter n :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_iter_nth_child";
end;

define C-function gtk-tree-model-iter-parent
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter child :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_iter_parent";
end;

define C-function gtk-tree-model-ref-node
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_ref_node";
end;

define C-function gtk-tree-model-unref-node
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_unref_node";
end;

define C-function gtk-tree-model-get
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_get";
end;

define C-function gtk-tree-model-get-valist
  input parameter tree_model :: <GtkTreeModel>;
  input parameter iter :: <GtkTreeIter>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_tree_model_get_valist";
end;

define C-function gtk-tree-model-foreach
  input parameter model :: <GtkTreeModel>;
  input parameter func :: <GtkTreeModelForeachFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_tree_model_foreach";
end;

define C-function gtk-tree-model-row-changed
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_row_changed";
end;

define C-function gtk-tree-model-row-inserted
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_row_inserted";
end;

define C-function gtk-tree-model-row-has-child-toggled
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_row_has_child_toggled";
end;

define C-function gtk-tree-model-row-deleted
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_model_row_deleted";
end;

define C-function gtk-tree-model-rows-reordered
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  input parameter iter :: <GtkTreeIter>;
  input parameter new_order :: <gint*>;
  c-name: "gtk_tree_model_rows_reordered";
end;

define constant <GtkCellRendererState> = limited(<integer>, min: 1, max: 16);
define constant $GTK-CELL-RENDERER-SELECTED :: <GtkCellRendererState> = 1;
define constant $GTK-CELL-RENDERER-PRELIT :: <GtkCellRendererState> = 2;
define constant $GTK-CELL-RENDERER-INSENSITIVE :: <GtkCellRendererState> = 4;
define constant $GTK-CELL-RENDERER-SORTED :: <GtkCellRendererState> = 8;
define constant $GTK-CELL-RENDERER-FOCUSED :: <GtkCellRendererState> = 16;

define constant <GtkCellRendererMode> = limited(<integer>, min: 0, max: 2);
define constant $GTK-CELL-RENDERER-MODE-INERT :: <GtkCellRendererMode> = 0;
define constant $GTK-CELL-RENDERER-MODE-ACTIVATABLE :: <GtkCellRendererMode> = 1;
define constant $GTK-CELL-RENDERER-MODE-EDITABLE :: <GtkCellRendererMode> = 2;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4999>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5000>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5001>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5002>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5003>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5004>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5005>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5006>"*/
define C-subtype <_GtkCellRendererClass> (<C-void*>) end;
define constant <GtkCellRendererClass> = <_GtkCellRendererClass>;

define C-function gtk-cell-renderer-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_get_type";
end;

define C-function gtk-cell-renderer-get-size
  input parameter cell :: <GtkCellRenderer>;
  input parameter widget :: <GtkWidget>;
  input parameter cell_area :: <GdkRectangle>;
  input parameter x_offset :: <gint*>;
  input parameter y_offset :: <gint*>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_cell_renderer_get_size";
end;

define C-function gtk-cell-renderer-render
  input parameter cell :: <GtkCellRenderer>;
  input parameter window :: <GdkWindow>;
  input parameter widget :: <GtkWidget>;
  input parameter background_area :: <GdkRectangle>;
  input parameter cell_area :: <GdkRectangle>;
  input parameter expose_area :: <GdkRectangle>;
  input parameter flags :: <GtkCellRendererState>;
  c-name: "gtk_cell_renderer_render";
end;

define C-function gtk-cell-renderer-activate
  input parameter cell :: <GtkCellRenderer>;
  input parameter event :: <GdkEvent>;
  input parameter widget :: <GtkWidget>;
  input parameter path :: <c-string>;
  input parameter background_area :: <GdkRectangle>;
  input parameter cell_area :: <GdkRectangle>;
  input parameter flags :: <GtkCellRendererState>;
  result res :: <gboolean>;
  c-name: "gtk_cell_renderer_activate";
end;

define C-function gtk-cell-renderer-start-editing
  input parameter cell :: <GtkCellRenderer>;
  input parameter event :: <GdkEvent>;
  input parameter widget :: <GtkWidget>;
  input parameter path :: <c-string>;
  input parameter background_area :: <GdkRectangle>;
  input parameter cell_area :: <GdkRectangle>;
  input parameter flags :: <GtkCellRendererState>;
  result res :: <GtkCellEditable>;
  c-name: "gtk_cell_renderer_start_editing";
end;

define C-function gtk-cell-renderer-set-fixed-size
  input parameter cell :: <GtkCellRenderer>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_cell_renderer_set_fixed_size";
end;

define C-function gtk-cell-renderer-get-fixed-size
  input parameter cell :: <GtkCellRenderer>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_cell_renderer_get_fixed_size";
end;

define C-function gtk-cell-renderer-editing-canceled
  input parameter cell :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_editing_canceled";
end;

define C-function gtk-cell-renderer-stop-editing
  input parameter cell :: <GtkCellRenderer>;
  input parameter canceled :: <gboolean>;
  c-name: "gtk_cell_renderer_stop_editing";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4983>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4984>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4985>"*/
define C-subtype <_GtkCellEditableIface> (<C-void*>) end;
define constant <GtkCellEditableIface> = <_GtkCellEditableIface>;

define C-function gtk-cell-editable-get-type
  result res :: <GType>;
  c-name: "gtk_cell_editable_get_type";
end;

define C-function gtk-cell-editable-start-editing
  input parameter cell_editable :: <GtkCellEditable>;
  input parameter event :: <GdkEvent>;
  c-name: "gtk_cell_editable_start_editing";
end;

define C-function gtk-cell-editable-editing-done
  input parameter cell_editable :: <GtkCellEditable>;
  c-name: "gtk_cell_editable_editing_done";
end;

define C-function gtk-cell-editable-remove-widget
  input parameter cell_editable :: <GtkCellEditable>;
  c-name: "gtk_cell_editable_remove_widget";
end;

define constant <GtkTreeViewDropPosition> = limited(<integer>, min: 0, max: 3);
define constant $GTK-TREE-VIEW-DROP-BEFORE :: <GtkTreeViewDropPosition> = 0;
define constant $GTK-TREE-VIEW-DROP-AFTER :: <GtkTreeViewDropPosition> = 1;
define constant $GTK-TREE-VIEW-DROP-INTO-OR-BEFORE :: <GtkTreeViewDropPosition> = 2;
define constant $GTK-TREE-VIEW-DROP-INTO-OR-AFTER :: <GtkTreeViewDropPosition> = 3;

define C-subtype <_GtkTreeViewPrivate> (<C-void*>) end;
define constant <GtkTreeViewPrivate> = <_GtkTreeViewPrivate>;

define C-subtype <_GtkTreeView> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkTreeView> = <_GtkTreeView>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6068>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6069>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6070>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6071>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6072>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6073>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6074>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6075>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6076>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6077>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6078>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6079>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6080>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6081>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6082>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6083>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6084>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6085>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6086>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6087>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6088>"*/
define C-subtype <_GtkTreeViewClass> (<C-void*>) end;
define constant <GtkTreeViewClass> = <_GtkTreeViewClass>;

define constant <GtkTreeSelection> = <_GtkTreeSelection>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8118>"*/
define constant <GtkTreeSelectionFunc> = <anonymous-8118>;

define C-subtype <_GtkTreeSelection> (<GObject>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8120>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8121>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8122>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8123>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8124>"*/
define C-subtype <_GtkTreeSelectionClass> (<C-void*>) end;
define constant <GtkTreeSelectionClass> = <_GtkTreeSelectionClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6089>"*/
define constant <GtkTreeViewColumnDropFunc> = <anonymous-6089>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6090>"*/
define constant <GtkTreeViewMappingFunc> = <anonymous-6090>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6091>"*/
define constant <GtkTreeViewSearchEqualFunc> = <anonymous-6091>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6092>"*/
define constant <GtkTreeViewRowSeparatorFunc> = <anonymous-6092>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6093>"*/
define constant <GtkTreeViewSearchPositionFunc> = <anonymous-6093>;

define C-function gtk-tree-view-get-type
  result res :: <GType>;
  c-name: "gtk_tree_view_get_type";
end;

define C-function gtk-tree-view-new
  result res :: <GtkWidget>;
  c-name: "gtk_tree_view_new";
end;

define C-function gtk-tree-view-new-with-model
  input parameter model :: <GtkTreeModel>;
  result res :: <GtkWidget>;
  c-name: "gtk_tree_view_new_with_model";
end;

define C-function gtk-tree-view-get-model
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_view_get_model";
end;

define C-function gtk-tree-view-set-model
  input parameter tree_view :: <GtkTreeView>;
  input parameter model :: <GtkTreeModel>;
  c-name: "gtk_tree_view_set_model";
end;

define C-function gtk-tree-view-get-selection
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeSelection>;
  c-name: "gtk_tree_view_get_selection";
end;

define C-function gtk-tree-view-get-hadjustment
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_tree_view_get_hadjustment";
end;

define C-function gtk-tree-view-set-hadjustment
  input parameter tree_view :: <GtkTreeView>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_tree_view_set_hadjustment";
end;

define C-function gtk-tree-view-get-vadjustment
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_tree_view_get_vadjustment";
end;

define C-function gtk-tree-view-set-vadjustment
  input parameter tree_view :: <GtkTreeView>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_tree_view_set_vadjustment";
end;

define C-function gtk-tree-view-get-headers-visible
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_headers_visible";
end;

define C-function gtk-tree-view-set-headers-visible
  input parameter tree_view :: <GtkTreeView>;
  input parameter headers_visible :: <gboolean>;
  c-name: "gtk_tree_view_set_headers_visible";
end;

define C-function gtk-tree-view-columns-autosize
  input parameter tree_view :: <GtkTreeView>;
  c-name: "gtk_tree_view_columns_autosize";
end;

define C-function gtk-tree-view-get-headers-clickable
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_headers_clickable";
end;

define C-function gtk-tree-view-set-headers-clickable
  input parameter tree_view :: <GtkTreeView>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_tree_view_set_headers_clickable";
end;

define C-function gtk-tree-view-set-rules-hint
  input parameter tree_view :: <GtkTreeView>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_tree_view_set_rules_hint";
end;

define C-function gtk-tree-view-get-rules-hint
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_rules_hint";
end;

define C-function gtk-tree-view-append-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_append_column";
end;

define C-function gtk-tree-view-remove-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <GtkTreeViewColumn>;
  result res :: <gint>;
  c-name: "gtk_tree_view_remove_column";
end;

define C-function gtk-tree-view-insert-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <GtkTreeViewColumn>;
  input parameter position :: <gint>;
  result res :: <gint>;
  c-name: "gtk_tree_view_insert_column";
end;

define C-function gtk-tree-view-insert-column-with-attributes
  input parameter tree_view :: <GtkTreeView>;
  input parameter position :: <gint>;
  input parameter title :: <c-string>;
  input parameter cell :: <GtkCellRenderer>;
  result res :: <gint>;
  c-name: "gtk_tree_view_insert_column_with_attributes";
end;

define C-function gtk-tree-view-insert-column-with-data-func
  input parameter tree_view :: <GtkTreeView>;
  input parameter position :: <gint>;
  input parameter title :: <c-string>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter func :: <GtkTreeCellDataFunc>;
  input parameter data :: <gpointer>;
  input parameter dnotify :: <GDestroyNotify>;
  result res :: <gint>;
  c-name: "gtk_tree_view_insert_column_with_data_func";
end;

define C-function gtk-tree-view-get-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter n :: <gint>;
  result res :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_get_column";
end;

define C-function gtk-tree-view-get-columns
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GList>;
  c-name: "gtk_tree_view_get_columns";
end;

define C-function gtk-tree-view-move-column-after
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <GtkTreeViewColumn>;
  input parameter base_column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_move_column_after";
end;

define C-function gtk-tree-view-set-expander-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_set_expander_column";
end;

define C-function gtk-tree-view-get-expander-column
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_get_expander_column";
end;

define C-function gtk-tree-view-set-column-drag-function
  input parameter tree_view :: <GtkTreeView>;
  input parameter func :: <GtkTreeViewColumnDropFunc>;
  input parameter user_data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_view_set_column_drag_function";
end;

define C-function gtk-tree-view-scroll-to-point
  input parameter tree_view :: <GtkTreeView>;
  input parameter tree_x :: <gint>;
  input parameter tree_y :: <gint>;
  c-name: "gtk_tree_view_scroll_to_point";
end;

define C-function gtk-tree-view-scroll-to-cell
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter column :: <GtkTreeViewColumn>;
  input parameter use_align :: <gboolean>;
  input parameter row_align :: <gfloat>;
  input parameter col_align :: <gfloat>;
  c-name: "gtk_tree_view_scroll_to_cell";
end;

define C-function gtk-tree-view-row-activated
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter column :: <GtkTreeViewColumn>;
  c-name: "gtk_tree_view_row_activated";
end;

define C-function gtk-tree-view-expand-all
  input parameter tree_view :: <GtkTreeView>;
  c-name: "gtk_tree_view_expand_all";
end;

define C-function gtk-tree-view-collapse-all
  input parameter tree_view :: <GtkTreeView>;
  c-name: "gtk_tree_view_collapse_all";
end;

define C-function gtk-tree-view-expand-to-path
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_view_expand_to_path";
end;

define C-function gtk-tree-view-expand-row
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter open_all :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_expand_row";
end;

define C-function gtk-tree-view-collapse-row
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_collapse_row";
end;

define C-function gtk-tree-view-map-expanded-rows
  input parameter tree_view :: <GtkTreeView>;
  input parameter func :: <GtkTreeViewMappingFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_tree_view_map_expanded_rows";
end;

define C-function gtk-tree-view-row-expanded
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_row_expanded";
end;

define C-function gtk-tree-view-set-reorderable
  input parameter tree_view :: <GtkTreeView>;
  input parameter reorderable :: <gboolean>;
  c-name: "gtk_tree_view_set_reorderable";
end;

define C-function gtk-tree-view-get-reorderable
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_reorderable";
end;

define C-function gtk-tree-view-set-cursor
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter focus_column :: <GtkTreeViewColumn>;
  input parameter start_editing :: <gboolean>;
  c-name: "gtk_tree_view_set_cursor";
end;

define C-function gtk-tree-view-set-cursor-on-cell
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter focus_column :: <GtkTreeViewColumn>;
  input parameter focus_cell :: <GtkCellRenderer>;
  input parameter start_editing :: <gboolean>;
  c-name: "gtk_tree_view_set_cursor_on_cell";
end;

define C-pointer-type <GtkTreePath*> => <GtkTreePath>;
define C-pointer-type <GtkTreeViewColumn*> => <GtkTreeViewColumn>;
define C-function gtk-tree-view-get-cursor
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath*>;
  input parameter focus_column :: <GtkTreeViewColumn*>;
  c-name: "gtk_tree_view_get_cursor";
end;

define C-function gtk-tree-view-get-bin-window
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GdkWindow>;
  c-name: "gtk_tree_view_get_bin_window";
end;

define C-function gtk-tree-view-get-path-at-pos
  input parameter tree_view :: <GtkTreeView>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter path :: <GtkTreePath*>;
  input parameter column :: <GtkTreeViewColumn*>;
  input parameter cell_x :: <gint*>;
  input parameter cell_y :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_path_at_pos";
end;

define C-function gtk-tree-view-get-cell-area
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter column :: <GtkTreeViewColumn>;
  input parameter rect :: <GdkRectangle>;
  c-name: "gtk_tree_view_get_cell_area";
end;

define C-function gtk-tree-view-get-background-area
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter column :: <GtkTreeViewColumn>;
  input parameter rect :: <GdkRectangle>;
  c-name: "gtk_tree_view_get_background_area";
end;

define C-function gtk-tree-view-get-visible-rect
  input parameter tree_view :: <GtkTreeView>;
  input parameter visible_rect :: <GdkRectangle>;
  c-name: "gtk_tree_view_get_visible_rect";
end;

define C-function gtk-tree-view-widget-to-tree-coords
  input parameter tree_view :: <GtkTreeView>;
  input parameter wx :: <gint>;
  input parameter wy :: <gint>;
  input parameter tx :: <gint*>;
  input parameter ty :: <gint*>;
  c-name: "gtk_tree_view_widget_to_tree_coords";
end;

define C-function gtk-tree-view-tree-to-widget-coords
  input parameter tree_view :: <GtkTreeView>;
  input parameter tx :: <gint>;
  input parameter ty :: <gint>;
  input parameter wx :: <gint*>;
  input parameter wy :: <gint*>;
  c-name: "gtk_tree_view_tree_to_widget_coords";
end;

define C-function gtk-tree-view-get-visible-range
  input parameter tree_view :: <GtkTreeView>;
  input parameter start_path :: <GtkTreePath*>;
  input parameter end_path :: <GtkTreePath*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_visible_range";
end;

define C-subtype <_GtkTargetEntry> (<C-void*>) end;
define constant <GtkTargetEntry> = <_GtkTargetEntry>;

define C-function gtk-tree-view-enable-model-drag-source
  input parameter tree_view :: <GtkTreeView>;
  input parameter start_button_mask :: <GdkModifierType>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_tree_view_enable_model_drag_source";
end;

define C-function gtk-tree-view-enable-model-drag-dest
  input parameter tree_view :: <GtkTreeView>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_tree_view_enable_model_drag_dest";
end;

define C-function gtk-tree-view-unset-rows-drag-source
  input parameter tree_view :: <GtkTreeView>;
  c-name: "gtk_tree_view_unset_rows_drag_source";
end;

define C-function gtk-tree-view-unset-rows-drag-dest
  input parameter tree_view :: <GtkTreeView>;
  c-name: "gtk_tree_view_unset_rows_drag_dest";
end;

define C-function gtk-tree-view-set-drag-dest-row
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  input parameter pos :: <GtkTreeViewDropPosition>;
  c-name: "gtk_tree_view_set_drag_dest_row";
end;

define C-pointer-type <GtkTreeViewDropPosition*> => <GtkTreeViewDropPosition>;
define C-function gtk-tree-view-get-drag-dest-row
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath*>;
  input parameter pos :: <GtkTreeViewDropPosition*>;
  c-name: "gtk_tree_view_get_drag_dest_row";
end;

define C-function gtk-tree-view-get-dest-row-at-pos
  input parameter tree_view :: <GtkTreeView>;
  input parameter drag_x :: <gint>;
  input parameter drag_y :: <gint>;
  input parameter path :: <GtkTreePath*>;
  input parameter pos :: <GtkTreeViewDropPosition*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_dest_row_at_pos";
end;

define C-function gtk-tree-view-create-row-drag-icon
  input parameter tree_view :: <GtkTreeView>;
  input parameter path :: <GtkTreePath>;
  result res :: <GdkPixmap>;
  c-name: "gtk_tree_view_create_row_drag_icon";
end;

define C-function gtk-tree-view-set-enable-search
  input parameter tree_view :: <GtkTreeView>;
  input parameter enable_search :: <gboolean>;
  c-name: "gtk_tree_view_set_enable_search";
end;

define C-function gtk-tree-view-get-enable-search
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_enable_search";
end;

define C-function gtk-tree-view-get-search-column
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gint>;
  c-name: "gtk_tree_view_get_search_column";
end;

define C-function gtk-tree-view-set-search-column
  input parameter tree_view :: <GtkTreeView>;
  input parameter column :: <gint>;
  c-name: "gtk_tree_view_set_search_column";
end;

define C-function gtk-tree-view-get-search-equal-func
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeViewSearchEqualFunc>;
  c-name: "gtk_tree_view_get_search_equal_func";
end;

define C-function gtk-tree-view-set-search-equal-func
  input parameter tree_view :: <GtkTreeView>;
  input parameter search_equal_func :: <GtkTreeViewSearchEqualFunc>;
  input parameter search_user_data :: <gpointer>;
  input parameter search_destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_view_set_search_equal_func";
end;

define C-subtype <_GtkIMContext> (<GObject>) end;
define constant <GtkIMContext> = <_GtkIMContext>;

define C-subtype <_GtkEntry> (<GtkWidget>, <AtkImplementorIface>, <GtkEditable>, <GtkCellEditable>) end;
define constant <GtkEntry> = <_GtkEntry>;

define C-function gtk-tree-view-get-search-entry
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkEntry>;
  c-name: "gtk_tree_view_get_search_entry";
end;

define C-function gtk-tree-view-set-search-entry
  input parameter tree_view :: <GtkTreeView>;
  input parameter entry :: <GtkEntry>;
  c-name: "gtk_tree_view_set_search_entry";
end;

define C-function gtk-tree-view-get-search-position-func
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeViewSearchPositionFunc>;
  c-name: "gtk_tree_view_get_search_position_func";
end;

define C-function gtk-tree-view-set-search-position-func
  input parameter tree_view :: <GtkTreeView>;
  input parameter func :: <GtkTreeViewSearchPositionFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_tree_view_set_search_position_func";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6163>"*/
define constant <GtkTreeDestroyCountFunc> = <anonymous-6163>;

define C-function gtk-tree-view-set-destroy-count-func
  input parameter tree_view :: <GtkTreeView>;
  input parameter func :: <GtkTreeDestroyCountFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_view_set_destroy_count_func";
end;

define C-function gtk-tree-view-set-fixed-height-mode
  input parameter tree_view :: <GtkTreeView>;
  input parameter enable :: <gboolean>;
  c-name: "gtk_tree_view_set_fixed_height_mode";
end;

define C-function gtk-tree-view-get-fixed-height-mode
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_fixed_height_mode";
end;

define C-function gtk-tree-view-set-hover-selection
  input parameter tree_view :: <GtkTreeView>;
  input parameter hover :: <gboolean>;
  c-name: "gtk_tree_view_set_hover_selection";
end;

define C-function gtk-tree-view-get-hover-selection
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_hover_selection";
end;

define C-function gtk-tree-view-set-hover-expand
  input parameter tree_view :: <GtkTreeView>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_tree_view_set_hover_expand";
end;

define C-function gtk-tree-view-get-hover-expand
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_hover_expand";
end;

define C-function gtk-tree-view-set-rubber-banding
  input parameter tree_view :: <GtkTreeView>;
  input parameter enable :: <gboolean>;
  c-name: "gtk_tree_view_set_rubber_banding";
end;

define C-function gtk-tree-view-get-rubber-banding
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_rubber_banding";
end;

define C-function gtk-tree-view-get-row-separator-func
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeViewRowSeparatorFunc>;
  c-name: "gtk_tree_view_get_row_separator_func";
end;

define C-function gtk-tree-view-set-row-separator-func
  input parameter tree_view :: <GtkTreeView>;
  input parameter func :: <GtkTreeViewRowSeparatorFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_view_set_row_separator_func";
end;

define C-function gtk-tree-view-get-grid-lines
  input parameter tree_view :: <GtkTreeView>;
  result res :: <GtkTreeViewGridLines>;
  c-name: "gtk_tree_view_get_grid_lines";
end;

define C-function gtk-tree-view-set-grid-lines
  input parameter tree_view :: <GtkTreeView>;
  input parameter grid_lines :: <GtkTreeViewGridLines>;
  c-name: "gtk_tree_view_set_grid_lines";
end;

define C-function gtk-tree-view-get-enable-tree-lines
  input parameter tree_view :: <GtkTreeView>;
  result res :: <gboolean>;
  c-name: "gtk_tree_view_get_enable_tree_lines";
end;

define C-function gtk-tree-view-set-enable-tree-lines
  input parameter tree_view :: <GtkTreeView>;
  input parameter enabled :: <gboolean>;
  c-name: "gtk_tree_view_set_enable_tree_lines";
end;

define C-subtype <_GtkMenuShell> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkMenuShell> = <_GtkMenuShell>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4154>"*/
define constant <GtkMenuPositionFunc> = <anonymous-4154>;

define C-subtype <_GtkMenu> (<GtkMenuShell>, <AtkImplementorIface>) end;
define constant <GtkMenu> = <_GtkMenu>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6022>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6023>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6024>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6025>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6026>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6027>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6028>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6029>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6030>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6031>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6032>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6033>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6034>"*/
define C-subtype <_GtkEntryClass> (<C-void*>) end;
define constant <GtkEntryClass> = <_GtkEntryClass>;

define C-function gtk-entry-get-type
  result res :: <GType>;
  c-name: "gtk_entry_get_type";
end;

define C-function gtk-entry-new
  result res :: <GtkWidget>;
  c-name: "gtk_entry_new";
end;

define C-function gtk-entry-set-visibility
  input parameter entry :: <GtkEntry>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_entry_set_visibility";
end;

define C-function gtk-entry-get-visibility
  input parameter entry :: <GtkEntry>;
  result res :: <gboolean>;
  c-name: "gtk_entry_get_visibility";
end;

define C-function gtk-entry-set-invisible-char
  input parameter entry :: <GtkEntry>;
  input parameter ch :: <gunichar>;
  c-name: "gtk_entry_set_invisible_char";
end;

define C-function gtk-entry-get-invisible-char
  input parameter entry :: <GtkEntry>;
  result res :: <gunichar>;
  c-name: "gtk_entry_get_invisible_char";
end;

define C-function gtk-entry-set-has-frame
  input parameter entry :: <GtkEntry>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_entry_set_has_frame";
end;

define C-function gtk-entry-get-has-frame
  input parameter entry :: <GtkEntry>;
  result res :: <gboolean>;
  c-name: "gtk_entry_get_has_frame";
end;

define C-function gtk-entry-set-inner-border
  input parameter entry :: <GtkEntry>;
  input parameter border :: <GtkBorder>;
  c-name: "gtk_entry_set_inner_border";
end;

define C-function gtk-entry-get-inner-border
  input parameter entry :: <GtkEntry>;
  result res :: <GtkBorder>;
  c-name: "gtk_entry_get_inner_border";
end;

define C-function gtk-entry-set-max-length
  input parameter entry :: <GtkEntry>;
  input parameter max :: <gint>;
  c-name: "gtk_entry_set_max_length";
end;

define C-function gtk-entry-get-max-length
  input parameter entry :: <GtkEntry>;
  result res :: <gint>;
  c-name: "gtk_entry_get_max_length";
end;

define C-function gtk-entry-set-activates-default
  input parameter entry :: <GtkEntry>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_entry_set_activates_default";
end;

define C-function gtk-entry-get-activates-default
  input parameter entry :: <GtkEntry>;
  result res :: <gboolean>;
  c-name: "gtk_entry_get_activates_default";
end;

define C-function gtk-entry-set-width-chars
  input parameter entry :: <GtkEntry>;
  input parameter n_chars :: <gint>;
  c-name: "gtk_entry_set_width_chars";
end;

define C-function gtk-entry-get-width-chars
  input parameter entry :: <GtkEntry>;
  result res :: <gint>;
  c-name: "gtk_entry_get_width_chars";
end;

define C-function gtk-entry-set-text
  input parameter entry :: <GtkEntry>;
  input parameter text :: <c-string>;
  c-name: "gtk_entry_set_text";
end;

define C-function gtk-entry-get-text
  input parameter entry :: <GtkEntry>;
  result res :: <c-string>;
  c-name: "gtk_entry_get_text";
end;

define C-function gtk-entry-get-layout
  input parameter entry :: <GtkEntry>;
  result res :: <PangoLayout>;
  c-name: "gtk_entry_get_layout";
end;

define C-function gtk-entry-get-layout-offsets
  input parameter entry :: <GtkEntry>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gtk_entry_get_layout_offsets";
end;

define C-function gtk-entry-set-alignment
  input parameter entry :: <GtkEntry>;
  input parameter xalign :: <gfloat>;
  c-name: "gtk_entry_set_alignment";
end;

define C-function gtk-entry-get-alignment
  input parameter entry :: <GtkEntry>;
  result res :: <gfloat>;
  c-name: "gtk_entry_get_alignment";
end;

define C-subtype <_GtkEntryCompletionPrivate> (<C-void*>) end;
define constant <GtkEntryCompletionPrivate> = <_GtkEntryCompletionPrivate>;

define C-subtype <_GtkEntryCompletion> (<C-void*>) end;
define constant <GtkEntryCompletion> = <_GtkEntryCompletion>;

define C-function gtk-entry-set-completion
  input parameter entry :: <GtkEntry>;
  input parameter completion :: <GtkEntryCompletion>;
  c-name: "gtk_entry_set_completion";
end;

define C-function gtk-entry-get-completion
  input parameter entry :: <GtkEntry>;
  result res :: <GtkEntryCompletion>;
  c-name: "gtk_entry_get_completion";
end;

define C-function gtk-entry-layout-index-to-text-index
  input parameter entry :: <GtkEntry>;
  input parameter layout_index :: <gint>;
  result res :: <gint>;
  c-name: "gtk_entry_layout_index_to_text_index";
end;

define C-function gtk-entry-text-index-to-layout-index
  input parameter entry :: <GtkEntry>;
  input parameter text_index :: <gint>;
  result res :: <gint>;
  c-name: "gtk_entry_text_index_to_layout_index";
end;

define C-function gtk-entry-new-with-max-length
  input parameter max :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_entry_new_with_max_length";
end;

define C-function gtk-entry-append-text
  input parameter entry :: <GtkEntry>;
  input parameter text :: <c-string>;
  c-name: "gtk_entry_append_text";
end;

define C-function gtk-entry-prepend-text
  input parameter entry :: <GtkEntry>;
  input parameter text :: <c-string>;
  c-name: "gtk_entry_prepend_text";
end;

define C-function gtk-entry-set-position
  input parameter entry :: <GtkEntry>;
  input parameter position :: <gint>;
  c-name: "gtk_entry_set_position";
end;

define C-function gtk-entry-select-region
  input parameter entry :: <GtkEntry>;
  input parameter start :: <gint>;
  input parameter end :: <gint>;
  c-name: "gtk_entry_select_region";
end;

define C-function gtk-entry-set-editable
  input parameter entry :: <GtkEntry>;
  input parameter editable :: <gboolean>;
  c-name: "gtk_entry_set_editable";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5976>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5977>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5978>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5979>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5980>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5981>"*/
define C-subtype <_GtkEntryCompletionClass> (<C-void*>) end;
define constant <GtkEntryCompletionClass> = <_GtkEntryCompletionClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5975>"*/
define constant <GtkEntryCompletionMatchFunc> = <anonymous-5975>;

define C-function gtk-entry-completion-get-type
  result res :: <GType>;
  c-name: "gtk_entry_completion_get_type";
end;

define C-function gtk-entry-completion-new
  result res :: <GtkEntryCompletion>;
  c-name: "gtk_entry_completion_new";
end;

define C-function gtk-entry-completion-get-entry
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <GtkWidget>;
  c-name: "gtk_entry_completion_get_entry";
end;

define C-function gtk-entry-completion-set-model
  input parameter completion :: <GtkEntryCompletion>;
  input parameter model :: <GtkTreeModel>;
  c-name: "gtk_entry_completion_set_model";
end;

define C-function gtk-entry-completion-get-model
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_entry_completion_get_model";
end;

define C-function gtk-entry-completion-set-match-func
  input parameter completion :: <GtkEntryCompletion>;
  input parameter func :: <GtkEntryCompletionMatchFunc>;
  input parameter func_data :: <gpointer>;
  input parameter func_notify :: <GDestroyNotify>;
  c-name: "gtk_entry_completion_set_match_func";
end;

define C-function gtk-entry-completion-set-minimum-key-length
  input parameter completion :: <GtkEntryCompletion>;
  input parameter length :: <gint>;
  c-name: "gtk_entry_completion_set_minimum_key_length";
end;

define C-function gtk-entry-completion-get-minimum-key-length
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gint>;
  c-name: "gtk_entry_completion_get_minimum_key_length";
end;

define C-function gtk-entry-completion-complete
  input parameter completion :: <GtkEntryCompletion>;
  c-name: "gtk_entry_completion_complete";
end;

define C-function gtk-entry-completion-insert-prefix
  input parameter completion :: <GtkEntryCompletion>;
  c-name: "gtk_entry_completion_insert_prefix";
end;

define C-function gtk-entry-completion-insert-action-text
  input parameter completion :: <GtkEntryCompletion>;
  input parameter index_ :: <gint>;
  input parameter text :: <c-string>;
  c-name: "gtk_entry_completion_insert_action_text";
end;

define C-function gtk-entry-completion-insert-action-markup
  input parameter completion :: <GtkEntryCompletion>;
  input parameter index_ :: <gint>;
  input parameter markup :: <c-string>;
  c-name: "gtk_entry_completion_insert_action_markup";
end;

define C-function gtk-entry-completion-delete-action
  input parameter completion :: <GtkEntryCompletion>;
  input parameter index_ :: <gint>;
  c-name: "gtk_entry_completion_delete_action";
end;

define C-function gtk-entry-completion-set-inline-completion
  input parameter completion :: <GtkEntryCompletion>;
  input parameter inline_completion :: <gboolean>;
  c-name: "gtk_entry_completion_set_inline_completion";
end;

define C-function gtk-entry-completion-get-inline-completion
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gboolean>;
  c-name: "gtk_entry_completion_get_inline_completion";
end;

define C-function gtk-entry-completion-set-popup-completion
  input parameter completion :: <GtkEntryCompletion>;
  input parameter popup_completion :: <gboolean>;
  c-name: "gtk_entry_completion_set_popup_completion";
end;

define C-function gtk-entry-completion-get-popup-completion
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gboolean>;
  c-name: "gtk_entry_completion_get_popup_completion";
end;

define C-function gtk-entry-completion-set-popup-set-width
  input parameter completion :: <GtkEntryCompletion>;
  input parameter popup_set_width :: <gboolean>;
  c-name: "gtk_entry_completion_set_popup_set_width";
end;

define C-function gtk-entry-completion-get-popup-set-width
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gboolean>;
  c-name: "gtk_entry_completion_get_popup_set_width";
end;

define C-function gtk-entry-completion-set-popup-single-match
  input parameter completion :: <GtkEntryCompletion>;
  input parameter popup_single_match :: <gboolean>;
  c-name: "gtk_entry_completion_set_popup_single_match";
end;

define C-function gtk-entry-completion-get-popup-single-match
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gboolean>;
  c-name: "gtk_entry_completion_get_popup_single_match";
end;

define C-function gtk-entry-completion-set-text-column
  input parameter completion :: <GtkEntryCompletion>;
  input parameter column :: <gint>;
  c-name: "gtk_entry_completion_set_text_column";
end;

define C-function gtk-entry-completion-get-text-column
  input parameter completion :: <GtkEntryCompletion>;
  result res :: <gint>;
  c-name: "gtk_entry_completion_get_text_column";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5957>"*/
define constant <GtkTreeModelFilterVisibleFunc> = <anonymous-5957>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5958>"*/
define constant <GtkTreeModelFilterModifyFunc> = <anonymous-5958>;

define C-subtype <_GtkTreeModelFilterPrivate> (<C-void*>) end;
define constant <GtkTreeModelFilterPrivate> = <_GtkTreeModelFilterPrivate>;

define C-subtype <_GtkTreeModelFilter> (<C-void*>) end;
define constant <GtkTreeModelFilter> = <_GtkTreeModelFilter>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5959>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5960>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5961>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5962>"*/
define C-subtype <_GtkTreeModelFilterClass> (<C-void*>) end;
define constant <GtkTreeModelFilterClass> = <_GtkTreeModelFilterClass>;

define C-function gtk-tree-model-filter-get-type
  result res :: <GType>;
  c-name: "gtk_tree_model_filter_get_type";
end;

define C-function gtk-tree-model-filter-new
  input parameter child_model :: <GtkTreeModel>;
  input parameter root :: <GtkTreePath>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_model_filter_new";
end;

define C-function gtk-tree-model-filter-set-visible-func
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter func :: <GtkTreeModelFilterVisibleFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_model_filter_set_visible_func";
end;

define C-function gtk-tree-model-filter-set-modify-func
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter n_columns :: <gint>;
  input parameter types :: <GType*>;
  input parameter func :: <GtkTreeModelFilterModifyFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_model_filter_set_modify_func";
end;

define C-function gtk-tree-model-filter-set-visible-column
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter column :: <gint>;
  c-name: "gtk_tree_model_filter_set_visible_column";
end;

define C-function gtk-tree-model-filter-get-model
  input parameter filter :: <GtkTreeModelFilter>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_model_filter_get_model";
end;

define C-function gtk-tree-model-filter-convert-child-iter-to-iter
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter filter_iter :: <GtkTreeIter>;
  input parameter child_iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_filter_convert_child_iter_to_iter";
end;

define C-function gtk-tree-model-filter-convert-iter-to-child-iter
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter child_iter :: <GtkTreeIter>;
  input parameter filter_iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_filter_convert_iter_to_child_iter";
end;

define C-function gtk-tree-model-filter-convert-child-path-to-path
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter child_path :: <GtkTreePath>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_model_filter_convert_child_path_to_path";
end;

define C-function gtk-tree-model-filter-convert-path-to-child-path
  input parameter filter :: <GtkTreeModelFilter>;
  input parameter filter_path :: <GtkTreePath>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_model_filter_convert_path_to_child_path";
end;

define C-function gtk-tree-model-filter-refilter
  input parameter filter :: <GtkTreeModelFilter>;
  c-name: "gtk_tree_model_filter_refilter";
end;

define C-function gtk-tree-model-filter-clear-cache
  input parameter filter :: <GtkTreeModelFilter>;
  c-name: "gtk_tree_model_filter_clear_cache";
end;

define C-subtype <_GtkListStore> (<GObject>, <GtkTreeModel>, <GtkTreeDragSource>, <GtkTreeDragDest>, <GtkTreeSortable>) end;
define constant <GtkListStore> = <_GtkListStore>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5932>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5933>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5934>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5935>"*/
define C-subtype <_GtkListStoreClass> (<C-void*>) end;
define constant <GtkListStoreClass> = <_GtkListStoreClass>;

define C-function gtk-list-store-get-type
  result res :: <GType>;
  c-name: "gtk_list_store_get_type";
end;

define C-function gtk-list-store-new
  input parameter n_columns :: <gint>;
  result res :: <GtkListStore>;
  c-name: "gtk_list_store_new";
end;

define C-function gtk-list-store-newv
  input parameter n_columns :: <gint>;
  input parameter types :: <GType*>;
  result res :: <GtkListStore>;
  c-name: "gtk_list_store_newv";
end;

define C-function gtk-list-store-set-column-types
  input parameter list_store :: <GtkListStore>;
  input parameter n_columns :: <gint>;
  input parameter types :: <GType*>;
  c-name: "gtk_list_store_set_column_types";
end;

define C-function gtk-list-store-set-value
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter column :: <gint>;
  input parameter value :: <GValue>;
  c-name: "gtk_list_store_set_value";
end;

define C-function gtk-list-store-set
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_list_store_set";
end;

define C-function gtk-list-store-set-valist
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_list_store_set_valist";
end;

define C-function gtk-list-store-remove
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_list_store_remove";
end;

define C-function gtk-list-store-insert
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <gint>;
  c-name: "gtk_list_store_insert";
end;

define C-function gtk-list-store-insert-before
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter sibling :: <GtkTreeIter>;
  c-name: "gtk_list_store_insert_before";
end;

define C-function gtk-list-store-insert-after
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter sibling :: <GtkTreeIter>;
  c-name: "gtk_list_store_insert_after";
end;

define C-function gtk-list-store-insert-with-values
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <gint>;
  c-name: "gtk_list_store_insert_with_values";
end;

define C-function gtk-list-store-insert-with-valuesv
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <gint>;
  input parameter columns :: <gint*>;
  input parameter values :: <GValue>;
  input parameter n_values :: <gint>;
  c-name: "gtk_list_store_insert_with_valuesv";
end;

define C-function gtk-list-store-prepend
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_list_store_prepend";
end;

define C-function gtk-list-store-append
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_list_store_append";
end;

define C-function gtk-list-store-clear
  input parameter list_store :: <GtkListStore>;
  c-name: "gtk_list_store_clear";
end;

define C-function gtk-list-store-iter-is-valid
  input parameter list_store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_list_store_iter_is_valid";
end;

define C-function gtk-list-store-reorder
  input parameter store :: <GtkListStore>;
  input parameter new_order :: <gint*>;
  c-name: "gtk_list_store_reorder";
end;

define C-function gtk-list-store-swap
  input parameter store :: <GtkListStore>;
  input parameter a :: <GtkTreeIter>;
  input parameter b :: <GtkTreeIter>;
  c-name: "gtk_list_store_swap";
end;

define C-function gtk-list-store-move-after
  input parameter store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <GtkTreeIter>;
  c-name: "gtk_list_store_move_after";
end;

define C-function gtk-list-store-move-before
  input parameter store :: <GtkListStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <GtkTreeIter>;
  c-name: "gtk_list_store_move_before";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4126>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4127>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4128>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4129>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4130>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4131>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4132>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4133>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4134>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4135>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4136>"*/
define C-subtype <_GtkMenuShellClass> (<C-void*>) end;
define constant <GtkMenuShellClass> = <_GtkMenuShellClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4164>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4165>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4166>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4167>"*/
define C-subtype <_GtkMenuClass> (<C-void*>) end;
define constant <GtkMenuClass> = <_GtkMenuClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4155>"*/
define constant <GtkMenuDetachFunc> = <anonymous-4155>;

define C-function gtk-menu-get-type
  result res :: <GType>;
  c-name: "gtk_menu_get_type";
end;

define C-function gtk-menu-new
  result res :: <GtkWidget>;
  c-name: "gtk_menu_new";
end;

define C-function gtk-menu-popup
  input parameter menu :: <GtkMenu>;
  input parameter parent_menu_shell :: <GtkWidget>;
  input parameter parent_menu_item :: <GtkWidget>;
  input parameter func :: <GtkMenuPositionFunc>;
  input parameter data :: <gpointer>;
  input parameter button :: <guint>;
  input parameter activate_time :: <guint32>;
  c-name: "gtk_menu_popup";
end;

define C-function gtk-menu-reposition
  input parameter menu :: <GtkMenu>;
  c-name: "gtk_menu_reposition";
end;

define C-function gtk-menu-popdown
  input parameter menu :: <GtkMenu>;
  c-name: "gtk_menu_popdown";
end;

define C-function gtk-menu-get-active
  input parameter menu :: <GtkMenu>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_get_active";
end;

define C-function gtk-menu-set-active
  input parameter menu :: <GtkMenu>;
  input parameter index_ :: <guint>;
  c-name: "gtk_menu_set_active";
end;

define C-function gtk-menu-set-accel-group
  input parameter menu :: <GtkMenu>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "gtk_menu_set_accel_group";
end;

define C-function gtk-menu-get-accel-group
  input parameter menu :: <GtkMenu>;
  result res :: <GtkAccelGroup>;
  c-name: "gtk_menu_get_accel_group";
end;

define C-function gtk-menu-set-accel-path
  input parameter menu :: <GtkMenu>;
  input parameter accel_path :: <c-string>;
  c-name: "gtk_menu_set_accel_path";
end;

define C-function gtk-menu-attach-to-widget
  input parameter menu :: <GtkMenu>;
  input parameter attach_widget :: <GtkWidget>;
  input parameter detacher :: <GtkMenuDetachFunc>;
  c-name: "gtk_menu_attach_to_widget";
end;

define C-function gtk-menu-detach
  input parameter menu :: <GtkMenu>;
  c-name: "gtk_menu_detach";
end;

define C-function gtk-menu-get-attach-widget
  input parameter menu :: <GtkMenu>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_get_attach_widget";
end;

define C-function gtk-menu-set-tearoff-state
  input parameter menu :: <GtkMenu>;
  input parameter torn_off :: <gboolean>;
  c-name: "gtk_menu_set_tearoff_state";
end;

define C-function gtk-menu-get-tearoff-state
  input parameter menu :: <GtkMenu>;
  result res :: <gboolean>;
  c-name: "gtk_menu_get_tearoff_state";
end;

define C-function gtk-menu-set-title
  input parameter menu :: <GtkMenu>;
  input parameter title :: <c-string>;
  c-name: "gtk_menu_set_title";
end;

define C-function gtk-menu-get-title
  input parameter menu :: <GtkMenu>;
  result res :: <c-string>;
  c-name: "gtk_menu_get_title";
end;

define C-function gtk-menu-reorder-child
  input parameter menu :: <GtkMenu>;
  input parameter child :: <GtkWidget>;
  input parameter position :: <gint>;
  c-name: "gtk_menu_reorder_child";
end;

define C-function gtk-menu-set-screen
  input parameter menu :: <GtkMenu>;
  input parameter screen :: <GdkScreen>;
  c-name: "gtk_menu_set_screen";
end;

define C-function gtk-menu-attach
  input parameter menu :: <GtkMenu>;
  input parameter child :: <GtkWidget>;
  input parameter left_attach :: <guint>;
  input parameter right_attach :: <guint>;
  input parameter top_attach :: <guint>;
  input parameter bottom_attach :: <guint>;
  c-name: "gtk_menu_attach";
end;

define C-function gtk-menu-set-monitor
  input parameter menu :: <GtkMenu>;
  input parameter monitor_num :: <gint>;
  c-name: "gtk_menu_set_monitor";
end;

define C-function gtk-menu-get-for-attach-widget
  input parameter widget :: <GtkWidget>;
  result res :: <GList>;
  c-name: "gtk_menu_get_for_attach_widget";
end;

define C-function gtk-menu-shell-get-type
  result res :: <GType>;
  c-name: "gtk_menu_shell_get_type";
end;

define C-function gtk-menu-shell-append
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_menu_shell_append";
end;

define C-function gtk-menu-shell-prepend
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_menu_shell_prepend";
end;

define C-function gtk-menu-shell-insert
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter child :: <GtkWidget>;
  input parameter position :: <gint>;
  c-name: "gtk_menu_shell_insert";
end;

define C-function gtk-menu-shell-deactivate
  input parameter menu_shell :: <GtkMenuShell>;
  c-name: "gtk_menu_shell_deactivate";
end;

define C-function gtk-menu-shell-select-item
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter menu_item :: <GtkWidget>;
  c-name: "gtk_menu_shell_select_item";
end;

define C-function gtk-menu-shell-deselect
  input parameter menu_shell :: <GtkMenuShell>;
  c-name: "gtk_menu_shell_deselect";
end;

define C-function gtk-menu-shell-activate-item
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter menu_item :: <GtkWidget>;
  input parameter force_deactivate :: <gboolean>;
  c-name: "gtk_menu_shell_activate_item";
end;

define C-function gtk-menu-shell-select-first
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter search_sensitive :: <gboolean>;
  c-name: "gtk_menu_shell_select_first";
end;

define C-function _gtk-menu-shell-select-last
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter search_sensitive :: <gboolean>;
  c-name: "_gtk_menu_shell_select_last";
end;

define C-function _gtk-menu-shell-activate
  input parameter menu_shell :: <GtkMenuShell>;
  c-name: "_gtk_menu_shell_activate";
end;

define C-function _gtk-menu-shell-get-popup-delay
  input parameter menu_shell :: <GtkMenuShell>;
  result res :: <gint>;
  c-name: "_gtk_menu_shell_get_popup_delay";
end;

define C-function gtk-menu-shell-cancel
  input parameter menu_shell :: <GtkMenuShell>;
  c-name: "gtk_menu_shell_cancel";
end;

define C-function _gtk-menu-shell-add-mnemonic
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter keyval :: <guint>;
  input parameter target :: <GtkWidget>;
  c-name: "_gtk_menu_shell_add_mnemonic";
end;

define C-function _gtk-menu-shell-remove-mnemonic
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter keyval :: <guint>;
  input parameter target :: <GtkWidget>;
  c-name: "_gtk_menu_shell_remove_mnemonic";
end;

define C-function gtk-menu-shell-get-take-focus
  input parameter menu_shell :: <GtkMenuShell>;
  result res :: <gboolean>;
  c-name: "gtk_menu_shell_get_take_focus";
end;

define C-function gtk-menu-shell-set-take-focus
  input parameter menu_shell :: <GtkMenuShell>;
  input parameter take_focus :: <gboolean>;
  c-name: "gtk_menu_shell_set_take_focus";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5897>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5898>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5899>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5900>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5901>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5902>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5903>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5904>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5905>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5906>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5907>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5908>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5909>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5910>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5911>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5912>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5913>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5914>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5915>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5916>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5917>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5918>"*/
define C-subtype <_GtkIMContextClass> (<C-void*>) end;
define constant <GtkIMContextClass> = <_GtkIMContextClass>;

define C-function gtk-im-context-get-type
  result res :: <GType>;
  c-name: "gtk_im_context_get_type";
end;

define C-function gtk-im-context-set-client-window
  input parameter context :: <GtkIMContext>;
  input parameter window :: <GdkWindow>;
  c-name: "gtk_im_context_set_client_window";
end;

define C-function gtk-im-context-get-preedit-string
  input parameter context :: <GtkIMContext>;
  input parameter str :: <gchar**>;
  input parameter attrs :: <PangoAttrList*>;
  input parameter cursor_pos :: <gint*>;
  c-name: "gtk_im_context_get_preedit_string";
end;

define C-function gtk-im-context-filter-keypress
  input parameter context :: <GtkIMContext>;
  input parameter event :: <GdkEventKey>;
  result res :: <gboolean>;
  c-name: "gtk_im_context_filter_keypress";
end;

define C-function gtk-im-context-focus-in
  input parameter context :: <GtkIMContext>;
  c-name: "gtk_im_context_focus_in";
end;

define C-function gtk-im-context-focus-out
  input parameter context :: <GtkIMContext>;
  c-name: "gtk_im_context_focus_out";
end;

define C-function gtk-im-context-reset
  input parameter context :: <GtkIMContext>;
  c-name: "gtk_im_context_reset";
end;

define C-function gtk-im-context-set-cursor-location
  input parameter context :: <GtkIMContext>;
  input parameter area :: <GdkRectangle>;
  c-name: "gtk_im_context_set_cursor_location";
end;

define C-function gtk-im-context-set-use-preedit
  input parameter context :: <GtkIMContext>;
  input parameter use_preedit :: <gboolean>;
  c-name: "gtk_im_context_set_use_preedit";
end;

define C-function gtk-im-context-set-surrounding
  input parameter context :: <GtkIMContext>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  input parameter cursor_index :: <gint>;
  c-name: "gtk_im_context_set_surrounding";
end;

define C-function gtk-im-context-get-surrounding
  input parameter context :: <GtkIMContext>;
  input parameter text :: <gchar**>;
  input parameter cursor_index :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_im_context_get_surrounding";
end;

define C-function gtk-im-context-delete-surrounding
  input parameter context :: <GtkIMContext>;
  input parameter offset :: <gint>;
  input parameter n_chars :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_im_context_delete_surrounding";
end;

define C-subtype <_GtkEditable> (<C-void*>) end;
define constant <GtkEditable> = <_GtkEditable>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5873>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5874>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5875>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5876>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5877>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5878>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5879>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5880>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5881>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5882>"*/
define C-subtype <_GtkEditableClass> (<C-void*>) end;
define constant <GtkEditableClass> = <_GtkEditableClass>;

define C-function gtk-editable-get-type
  result res :: <GType>;
  c-name: "gtk_editable_get_type";
end;

define C-function gtk-editable-select-region
  input parameter editable :: <GtkEditable>;
  input parameter start :: <gint>;
  input parameter end :: <gint>;
  c-name: "gtk_editable_select_region";
end;

define C-function gtk-editable-get-selection-bounds
  input parameter editable :: <GtkEditable>;
  input parameter start :: <gint*>;
  input parameter end :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_editable_get_selection_bounds";
end;

define C-function gtk-editable-insert-text
  input parameter editable :: <GtkEditable>;
  input parameter new_text :: <c-string>;
  input parameter new_text_length :: <gint>;
  input parameter position :: <gint*>;
  c-name: "gtk_editable_insert_text";
end;

define C-function gtk-editable-delete-text
  input parameter editable :: <GtkEditable>;
  input parameter start_pos :: <gint>;
  input parameter end_pos :: <gint>;
  c-name: "gtk_editable_delete_text";
end;

define C-function gtk-editable-get-chars
  input parameter editable :: <GtkEditable>;
  input parameter start_pos :: <gint>;
  input parameter end_pos :: <gint>;
  result res :: <c-string>;
  c-name: "gtk_editable_get_chars";
end;

define C-function gtk-editable-cut-clipboard
  input parameter editable :: <GtkEditable>;
  c-name: "gtk_editable_cut_clipboard";
end;

define C-function gtk-editable-copy-clipboard
  input parameter editable :: <GtkEditable>;
  c-name: "gtk_editable_copy_clipboard";
end;

define C-function gtk-editable-paste-clipboard
  input parameter editable :: <GtkEditable>;
  c-name: "gtk_editable_paste_clipboard";
end;

define C-function gtk-editable-delete-selection
  input parameter editable :: <GtkEditable>;
  c-name: "gtk_editable_delete_selection";
end;

define C-function gtk-editable-set-position
  input parameter editable :: <GtkEditable>;
  input parameter position :: <gint>;
  c-name: "gtk_editable_set_position";
end;

define C-function gtk-editable-get-position
  input parameter editable :: <GtkEditable>;
  result res :: <gint>;
  c-name: "gtk_editable_get_position";
end;

define C-function gtk-editable-set-editable
  input parameter editable :: <GtkEditable>;
  input parameter is_editable :: <gboolean>;
  c-name: "gtk_editable_set_editable";
end;

define C-function gtk-editable-get-editable
  input parameter editable :: <GtkEditable>;
  result res :: <gboolean>;
  c-name: "gtk_editable_get_editable";
end;

define constant <GtkDestDefaults> = limited(<integer>, min: 1, max: 7);
define constant $GTK-DEST-DEFAULT-MOTION :: <GtkDestDefaults> = 1;
define constant $GTK-DEST-DEFAULT-HIGHLIGHT :: <GtkDestDefaults> = 2;
define constant $GTK-DEST-DEFAULT-DROP :: <GtkDestDefaults> = 4;
define constant $GTK-DEST-DEFAULT-ALL :: <GtkDestDefaults> = 7;

define constant <GtkTargetFlags> = limited(<integer>, min: 1, max: 2);
define constant $GTK-TARGET-SAME-APP :: <GtkTargetFlags> = 1;
define constant $GTK-TARGET-SAME-WIDGET :: <GtkTargetFlags> = 2;

define C-function gtk-drag-get-data
  input parameter widget :: <GtkWidget>;
  input parameter context :: <GdkDragContext>;
  input parameter target :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  c-name: "gtk_drag_get_data";
end;

define C-function gtk-drag-finish
  input parameter context :: <GdkDragContext>;
  input parameter success :: <gboolean>;
  input parameter del :: <gboolean>;
  input parameter time_ :: <guint32>;
  c-name: "gtk_drag_finish";
end;

define C-function gtk-drag-get-source-widget
  input parameter context :: <GdkDragContext>;
  result res :: <GtkWidget>;
  c-name: "gtk_drag_get_source_widget";
end;

define C-function gtk-drag-highlight
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_highlight";
end;

define C-function gtk-drag-unhighlight
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_unhighlight";
end;

define C-function gtk-drag-dest-set
  input parameter widget :: <GtkWidget>;
  input parameter flags :: <GtkDestDefaults>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_drag_dest_set";
end;

define C-function gtk-drag-dest-set-proxy
  input parameter widget :: <GtkWidget>;
  input parameter proxy_window :: <GdkWindow>;
  input parameter protocol :: <GdkDragProtocol>;
  input parameter use_coordinates :: <gboolean>;
  c-name: "gtk_drag_dest_set_proxy";
end;

define C-function gtk-drag-dest-unset
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_dest_unset";
end;

define C-subtype <_GtkTargetList> (<C-void*>) end;
define constant <GtkTargetList> = <_GtkTargetList>;

define C-function gtk-drag-dest-find-target
  input parameter widget :: <GtkWidget>;
  input parameter context :: <GdkDragContext>;
  input parameter target_list :: <GtkTargetList>;
  result res :: <GdkAtom>;
  c-name: "gtk_drag_dest_find_target";
end;

define C-function gtk-drag-dest-get-target-list
  input parameter widget :: <GtkWidget>;
  result res :: <GtkTargetList>;
  c-name: "gtk_drag_dest_get_target_list";
end;

define C-function gtk-drag-dest-set-target-list
  input parameter widget :: <GtkWidget>;
  input parameter target_list :: <GtkTargetList>;
  c-name: "gtk_drag_dest_set_target_list";
end;

define C-function gtk-drag-dest-add-text-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_dest_add_text_targets";
end;

define C-function gtk-drag-dest-add-image-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_dest_add_image_targets";
end;

define C-function gtk-drag-dest-add-uri-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_dest_add_uri_targets";
end;

define C-function gtk-drag-dest-set-track-motion
  input parameter widget :: <GtkWidget>;
  input parameter track_motion :: <gboolean>;
  c-name: "gtk_drag_dest_set_track_motion";
end;

define C-function gtk-drag-dest-get-track-motion
  input parameter widget :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_drag_dest_get_track_motion";
end;

define C-function gtk-drag-source-set
  input parameter widget :: <GtkWidget>;
  input parameter start_button_mask :: <GdkModifierType>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_drag_source_set";
end;

define C-function gtk-drag-source-unset
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_source_unset";
end;

define C-function gtk-drag-source-get-target-list
  input parameter widget :: <GtkWidget>;
  result res :: <GtkTargetList>;
  c-name: "gtk_drag_source_get_target_list";
end;

define C-function gtk-drag-source-set-target-list
  input parameter widget :: <GtkWidget>;
  input parameter target_list :: <GtkTargetList>;
  c-name: "gtk_drag_source_set_target_list";
end;

define C-function gtk-drag-source-add-text-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_source_add_text_targets";
end;

define C-function gtk-drag-source-add-image-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_source_add_image_targets";
end;

define C-function gtk-drag-source-add-uri-targets
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_drag_source_add_uri_targets";
end;

define C-function gtk-drag-source-set-icon
  input parameter widget :: <GtkWidget>;
  input parameter colormap :: <GdkColormap>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_drag_source_set_icon";
end;

define C-function gtk-drag-source-set-icon-pixbuf
  input parameter widget :: <GtkWidget>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_drag_source_set_icon_pixbuf";
end;

define C-function gtk-drag-source-set-icon-stock
  input parameter widget :: <GtkWidget>;
  input parameter stock_id :: <c-string>;
  c-name: "gtk_drag_source_set_icon_stock";
end;

define C-function gtk-drag-source-set-icon-name
  input parameter widget :: <GtkWidget>;
  input parameter icon_name :: <c-string>;
  c-name: "gtk_drag_source_set_icon_name";
end;

define C-function gtk-drag-begin
  input parameter widget :: <GtkWidget>;
  input parameter targets :: <GtkTargetList>;
  input parameter actions :: <GdkDragAction>;
  input parameter button :: <gint>;
  input parameter event :: <GdkEvent>;
  result res :: <GdkDragContext>;
  c-name: "gtk_drag_begin";
end;

define C-function gtk-drag-set-icon-widget
  input parameter context :: <GdkDragContext>;
  input parameter widget :: <GtkWidget>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_icon_widget";
end;

define C-function gtk-drag-set-icon-pixmap
  input parameter context :: <GdkDragContext>;
  input parameter colormap :: <GdkColormap>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_icon_pixmap";
end;

define C-function gtk-drag-set-icon-pixbuf
  input parameter context :: <GdkDragContext>;
  input parameter pixbuf :: <GdkPixbuf>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_icon_pixbuf";
end;

define C-function gtk-drag-set-icon-stock
  input parameter context :: <GdkDragContext>;
  input parameter stock_id :: <c-string>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_icon_stock";
end;

define C-function gtk-drag-set-icon-name
  input parameter context :: <GdkDragContext>;
  input parameter icon_name :: <c-string>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_icon_name";
end;

define C-function gtk-drag-set-icon-default
  input parameter context :: <GdkDragContext>;
  c-name: "gtk_drag_set_icon_default";
end;

define C-function gtk-drag-check-threshold
  input parameter widget :: <GtkWidget>;
  input parameter start_x :: <gint>;
  input parameter start_y :: <gint>;
  input parameter current_x :: <gint>;
  input parameter current_y :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_drag_check_threshold";
end;

define C-function _gtk-drag-source-handle-event
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEvent>;
  c-name: "_gtk_drag_source_handle_event";
end;

define C-function _gtk-drag-dest-handle-event
  input parameter toplevel :: <GtkWidget>;
  input parameter event :: <GdkEvent>;
  c-name: "_gtk_drag_dest_handle_event";
end;

define C-function gtk-drag-set-default-icon
  input parameter colormap :: <GdkColormap>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  input parameter hot_x :: <gint>;
  input parameter hot_y :: <gint>;
  c-name: "gtk_drag_set_default_icon";
end;

define C-subtype <_GtkTargetPair> (<C-void*>) end;
define constant <GtkTargetPair> = <_GtkTargetPair>;

define C-function gtk-target-list-new
  input parameter targets :: <GtkTargetEntry>;
  input parameter ntargets :: <guint>;
  result res :: <GtkTargetList>;
  c-name: "gtk_target_list_new";
end;

define C-function gtk-target-list-ref
  input parameter list :: <GtkTargetList>;
  result res :: <GtkTargetList>;
  c-name: "gtk_target_list_ref";
end;

define C-function gtk-target-list-unref
  input parameter list :: <GtkTargetList>;
  c-name: "gtk_target_list_unref";
end;

define C-function gtk-target-list-add
  input parameter list :: <GtkTargetList>;
  input parameter target :: <GdkAtom>;
  input parameter flags :: <guint>;
  input parameter info :: <guint>;
  c-name: "gtk_target_list_add";
end;

define C-function gtk-target-list-add-text-targets
  input parameter list :: <GtkTargetList>;
  input parameter info :: <guint>;
  c-name: "gtk_target_list_add_text_targets";
end;

define C-subtype <_GtkTextTagTable> (<GObject>) end;
define constant <GtkTextTagTable> = <_GtkTextTagTable>;

define C-subtype <_GtkTextBTree> (<C-void*>) end;
define constant <GtkTextBTree> = <_GtkTextBTree>;

define C-subtype <_GtkTextLogAttrCache> (<C-void*>) end;
define constant <GtkTextLogAttrCache> = <_GtkTextLogAttrCache>;

define C-subtype <_GtkTextBuffer> (<GObject>) end;
define constant <GtkTextBuffer> = <_GtkTextBuffer>;

define C-function gtk-target-list-add-rich-text-targets
  input parameter list :: <GtkTargetList>;
  input parameter info :: <guint>;
  input parameter deserializable :: <gboolean>;
  input parameter buffer :: <GtkTextBuffer>;
  c-name: "gtk_target_list_add_rich_text_targets";
end;

define C-function gtk-target-list-add-image-targets
  input parameter list :: <GtkTargetList>;
  input parameter info :: <guint>;
  input parameter writable :: <gboolean>;
  c-name: "gtk_target_list_add_image_targets";
end;

define C-function gtk-target-list-add-uri-targets
  input parameter list :: <GtkTargetList>;
  input parameter info :: <guint>;
  c-name: "gtk_target_list_add_uri_targets";
end;

define C-function gtk-target-list-add-table
  input parameter list :: <GtkTargetList>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter ntargets :: <guint>;
  c-name: "gtk_target_list_add_table";
end;

define C-function gtk-target-list-remove
  input parameter list :: <GtkTargetList>;
  input parameter target :: <GdkAtom>;
  c-name: "gtk_target_list_remove";
end;

define C-function gtk-target-list-find
  input parameter list :: <GtkTargetList>;
  input parameter target :: <GdkAtom>;
  input parameter info :: <guint*>;
  result res :: <gboolean>;
  c-name: "gtk_target_list_find";
end;

define C-function gtk-target-table-new-from-list
  input parameter list :: <GtkTargetList>;
  input parameter n_targets :: <gint*>;
  result res :: <GtkTargetEntry>;
  c-name: "gtk_target_table_new_from_list";
end;

define C-function gtk-target-table-free
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  c-name: "gtk_target_table_free";
end;

define C-function gtk-selection-owner-set
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  result res :: <gboolean>;
  c-name: "gtk_selection_owner_set";
end;

define C-function gtk-selection-owner-set-for-display
  input parameter display :: <GdkDisplay>;
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  result res :: <gboolean>;
  c-name: "gtk_selection_owner_set_for_display";
end;

define C-function gtk-selection-add-target
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  input parameter target :: <GdkAtom>;
  input parameter info :: <guint>;
  c-name: "gtk_selection_add_target";
end;

define C-function gtk-selection-add-targets
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter ntargets :: <guint>;
  c-name: "gtk_selection_add_targets";
end;

define C-function gtk-selection-clear-targets
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  c-name: "gtk_selection_clear_targets";
end;

define C-function gtk-selection-convert
  input parameter widget :: <GtkWidget>;
  input parameter selection :: <GdkAtom>;
  input parameter target :: <GdkAtom>;
  input parameter time_ :: <guint32>;
  result res :: <gboolean>;
  c-name: "gtk_selection_convert";
end;

define C-function gtk-selection-data-set
  input parameter selection_data :: <GtkSelectionData>;
  input parameter type :: <GdkAtom>;
  input parameter format :: <gint>;
  input parameter data :: <guchar*>;
  input parameter length :: <gint>;
  c-name: "gtk_selection_data_set";
end;

define C-function gtk-selection-data-set-text
  input parameter selection_data :: <GtkSelectionData>;
  input parameter str :: <c-string>;
  input parameter len :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_set_text";
end;

define C-function gtk-selection-data-get-text
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <guchar*>;
  c-name: "gtk_selection_data_get_text";
end;

define C-function gtk-selection-data-set-pixbuf
  input parameter selection_data :: <GtkSelectionData>;
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_set_pixbuf";
end;

define C-function gtk-selection-data-get-pixbuf
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_selection_data_get_pixbuf";
end;

define C-function gtk-selection-data-set-uris
  input parameter selection_data :: <GtkSelectionData>;
  input parameter uris :: <gchar**>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_set_uris";
end;

define C-function gtk-selection-data-get-uris
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gchar**>;
  c-name: "gtk_selection_data_get_uris";
end;

define C-pointer-type <GdkAtom**> => <GdkAtom*>;
define C-function gtk-selection-data-get-targets
  input parameter selection_data :: <GtkSelectionData>;
  input parameter targets :: <GdkAtom**>;
  input parameter n_atoms :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_get_targets";
end;

define C-function gtk-selection-data-targets-include-text
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_targets_include_text";
end;

define C-function gtk-selection-data-targets-include-rich-text
  input parameter selection_data :: <GtkSelectionData>;
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_targets_include_rich_text";
end;

define C-function gtk-selection-data-targets-include-image
  input parameter selection_data :: <GtkSelectionData>;
  input parameter writable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_targets_include_image";
end;

define C-function gtk-selection-data-targets-include-uri
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gboolean>;
  c-name: "gtk_selection_data_targets_include_uri";
end;

define C-function gtk-targets-include-text
  input parameter targets :: <GdkAtom*>;
  input parameter n_targets :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_targets_include_text";
end;

define C-function gtk-targets-include-rich-text
  input parameter targets :: <GdkAtom*>;
  input parameter n_targets :: <gint>;
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gboolean>;
  c-name: "gtk_targets_include_rich_text";
end;

define C-function gtk-targets-include-image
  input parameter targets :: <GdkAtom*>;
  input parameter n_targets :: <gint>;
  input parameter writable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_targets_include_image";
end;

define C-function gtk-targets-include-uri
  input parameter targets :: <GdkAtom*>;
  input parameter n_targets :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_targets_include_uri";
end;

define C-function gtk-selection-remove-all
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_selection_remove_all";
end;

define C-function gtk-selection-clear
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEventSelection>;
  result res :: <gboolean>;
  c-name: "gtk_selection_clear";
end;

define C-function _gtk-selection-request
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEventSelection>;
  result res :: <gboolean>;
  c-name: "_gtk_selection_request";
end;

define C-function _gtk-selection-incr-event
  input parameter window :: <GdkWindow>;
  input parameter event :: <GdkEventProperty>;
  result res :: <gboolean>;
  c-name: "_gtk_selection_incr_event";
end;

define C-function _gtk-selection-notify
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEventSelection>;
  result res :: <gboolean>;
  c-name: "_gtk_selection_notify";
end;

define C-function _gtk-selection-property-notify
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEventProperty>;
  result res :: <gboolean>;
  c-name: "_gtk_selection_property_notify";
end;

define C-function gtk-selection-data-get-type
  result res :: <GType>;
  c-name: "gtk_selection_data_get_type";
end;

define C-function gtk-selection-data-copy
  input parameter data :: <GtkSelectionData>;
  result res :: <GtkSelectionData>;
  c-name: "gtk_selection_data_copy";
end;

define C-function gtk-selection-data-free
  input parameter data :: <GtkSelectionData>;
  c-name: "gtk_selection_data_free";
end;

define C-function gtk-target-list-get-type
  result res :: <GType>;
  c-name: "gtk_target_list_get_type";
end;

define constant <GtkTextSearchFlags> = limited(<integer>, min: 1, max: 2);
define constant $GTK-TEXT-SEARCH-VISIBLE-ONLY :: <GtkTextSearchFlags> = 1;
define constant $GTK-TEXT-SEARCH-TEXT-ONLY :: <GtkTextSearchFlags> = 2;

define C-subtype <_GtkTextIter> (<C-void*>) end;
define constant <GtkTextIter> = <_GtkTextIter>;

define C-function gtk-text-iter-get-buffer
  input parameter iter :: <GtkTextIter>;
  result res :: <GtkTextBuffer>;
  c-name: "gtk_text_iter_get_buffer";
end;

define C-function gtk-text-iter-copy
  input parameter iter :: <GtkTextIter>;
  result res :: <GtkTextIter>;
  c-name: "gtk_text_iter_copy";
end;

define C-function gtk-text-iter-free
  input parameter iter :: <GtkTextIter>;
  c-name: "gtk_text_iter_free";
end;

define C-function gtk-text-iter-get-type
  result res :: <GType>;
  c-name: "gtk_text_iter_get_type";
end;

define C-function gtk-text-iter-get-offset
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_offset";
end;

define C-function gtk-text-iter-get-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_line";
end;

define C-function gtk-text-iter-get-line-offset
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_line_offset";
end;

define C-function gtk-text-iter-get-line-index
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_line_index";
end;

define C-function gtk-text-iter-get-visible-line-offset
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_visible_line_offset";
end;

define C-function gtk-text-iter-get-visible-line-index
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_visible_line_index";
end;

define C-function gtk-text-iter-get-char
  input parameter iter :: <GtkTextIter>;
  result res :: <gunichar>;
  c-name: "gtk_text_iter_get_char";
end;

define C-function gtk-text-iter-get-slice
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <c-string>;
  c-name: "gtk_text_iter_get_slice";
end;

define C-function gtk-text-iter-get-text
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <c-string>;
  c-name: "gtk_text_iter_get_text";
end;

define C-function gtk-text-iter-get-visible-slice
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <c-string>;
  c-name: "gtk_text_iter_get_visible_slice";
end;

define C-function gtk-text-iter-get-visible-text
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <c-string>;
  c-name: "gtk_text_iter_get_visible_text";
end;

define C-function gtk-text-iter-get-pixbuf
  input parameter iter :: <GtkTextIter>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_text_iter_get_pixbuf";
end;

define C-function gtk-text-iter-get-marks
  input parameter iter :: <GtkTextIter>;
  result res :: <GSList>;
  c-name: "gtk_text_iter_get_marks";
end;

define C-subtype <_GtkTextChildAnchor> (<GObject>) end;
define constant <GtkTextChildAnchor> = <_GtkTextChildAnchor>;

define C-function gtk-text-iter-get-child-anchor
  input parameter iter :: <GtkTextIter>;
  result res :: <GtkTextChildAnchor>;
  c-name: "gtk_text_iter_get_child_anchor";
end;

define C-function gtk-text-iter-get-toggled-tags
  input parameter iter :: <GtkTextIter>;
  input parameter toggled_on :: <gboolean>;
  result res :: <GSList>;
  c-name: "gtk_text_iter_get_toggled_tags";
end;

define C-subtype <_GtkTextAppearance> (<C-void*>) end;
define constant <GtkTextAppearance> = <_GtkTextAppearance>;

define C-subtype <_GtkTextAttributes> (<C-void*>) end;
define constant <GtkTextAttributes> = <_GtkTextAttributes>;

define C-subtype <_GtkTextTag> (<GObject>) end;
define constant <GtkTextTag> = <_GtkTextTag>;

define C-function gtk-text-iter-begins-tag
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_begins_tag";
end;

define C-function gtk-text-iter-ends-tag
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_ends_tag";
end;

define C-function gtk-text-iter-toggles-tag
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_toggles_tag";
end;

define C-function gtk-text-iter-has-tag
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_has_tag";
end;

define C-function gtk-text-iter-get-tags
  input parameter iter :: <GtkTextIter>;
  result res :: <GSList>;
  c-name: "gtk_text_iter_get_tags";
end;

define C-function gtk-text-iter-editable
  input parameter iter :: <GtkTextIter>;
  input parameter default_setting :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_editable";
end;

define C-function gtk-text-iter-can-insert
  input parameter iter :: <GtkTextIter>;
  input parameter default_editability :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_can_insert";
end;

define C-function gtk-text-iter-starts-word
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_starts_word";
end;

define C-function gtk-text-iter-ends-word
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_ends_word";
end;

define C-function gtk-text-iter-inside-word
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_inside_word";
end;

define C-function gtk-text-iter-starts-sentence
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_starts_sentence";
end;

define C-function gtk-text-iter-ends-sentence
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_ends_sentence";
end;

define C-function gtk-text-iter-inside-sentence
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_inside_sentence";
end;

define C-function gtk-text-iter-starts-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_starts_line";
end;

define C-function gtk-text-iter-ends-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_ends_line";
end;

define C-function gtk-text-iter-is-cursor-position
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_is_cursor_position";
end;

define C-function gtk-text-iter-get-chars-in-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_chars_in_line";
end;

define C-function gtk-text-iter-get-bytes-in-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_get_bytes_in_line";
end;

define C-function gtk-text-iter-get-attributes
  input parameter iter :: <GtkTextIter>;
  input parameter values :: <GtkTextAttributes>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_get_attributes";
end;

define C-function gtk-text-iter-get-language
  input parameter iter :: <GtkTextIter>;
  result res :: <PangoLanguage>;
  c-name: "gtk_text_iter_get_language";
end;

define C-function gtk-text-iter-is-end
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_is_end";
end;

define C-function gtk-text-iter-is-start
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_is_start";
end;

define C-function gtk-text-iter-forward-char
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_char";
end;

define C-function gtk-text-iter-backward-char
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_char";
end;

define C-function gtk-text-iter-forward-chars
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_chars";
end;

define C-function gtk-text-iter-backward-chars
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_chars";
end;

define C-function gtk-text-iter-forward-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_line";
end;

define C-function gtk-text-iter-backward-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_line";
end;

define C-function gtk-text-iter-forward-lines
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_lines";
end;

define C-function gtk-text-iter-backward-lines
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_lines";
end;

define C-function gtk-text-iter-forward-word-end
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_word_end";
end;

define C-function gtk-text-iter-backward-word-start
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_word_start";
end;

define C-function gtk-text-iter-forward-word-ends
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_word_ends";
end;

define C-function gtk-text-iter-backward-word-starts
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_word_starts";
end;

define C-function gtk-text-iter-forward-visible-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_line";
end;

define C-function gtk-text-iter-backward-visible-line
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_line";
end;

define C-function gtk-text-iter-forward-visible-lines
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_lines";
end;

define C-function gtk-text-iter-backward-visible-lines
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_lines";
end;

define C-function gtk-text-iter-forward-visible-word-end
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_word_end";
end;

define C-function gtk-text-iter-backward-visible-word-start
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_word_start";
end;

define C-function gtk-text-iter-forward-visible-word-ends
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_word_ends";
end;

define C-function gtk-text-iter-backward-visible-word-starts
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_word_starts";
end;

define C-function gtk-text-iter-forward-sentence-end
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_sentence_end";
end;

define C-function gtk-text-iter-backward-sentence-start
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_sentence_start";
end;

define C-function gtk-text-iter-forward-sentence-ends
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_sentence_ends";
end;

define C-function gtk-text-iter-backward-sentence-starts
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_sentence_starts";
end;

define C-function gtk-text-iter-forward-cursor-position
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_cursor_position";
end;

define C-function gtk-text-iter-backward-cursor-position
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_cursor_position";
end;

define C-function gtk-text-iter-forward-cursor-positions
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_cursor_positions";
end;

define C-function gtk-text-iter-backward-cursor-positions
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_cursor_positions";
end;

define C-function gtk-text-iter-forward-visible-cursor-position
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_cursor_position";
end;

define C-function gtk-text-iter-backward-visible-cursor-position
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_cursor_position";
end;

define C-function gtk-text-iter-forward-visible-cursor-positions
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_visible_cursor_positions";
end;

define C-function gtk-text-iter-backward-visible-cursor-positions
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_visible_cursor_positions";
end;

define C-function gtk-text-iter-set-offset
  input parameter iter :: <GtkTextIter>;
  input parameter char_offset :: <gint>;
  c-name: "gtk_text_iter_set_offset";
end;

define C-function gtk-text-iter-set-line
  input parameter iter :: <GtkTextIter>;
  input parameter line_number :: <gint>;
  c-name: "gtk_text_iter_set_line";
end;

define C-function gtk-text-iter-set-line-offset
  input parameter iter :: <GtkTextIter>;
  input parameter char_on_line :: <gint>;
  c-name: "gtk_text_iter_set_line_offset";
end;

define C-function gtk-text-iter-set-line-index
  input parameter iter :: <GtkTextIter>;
  input parameter byte_on_line :: <gint>;
  c-name: "gtk_text_iter_set_line_index";
end;

define C-function gtk-text-iter-forward-to-end
  input parameter iter :: <GtkTextIter>;
  c-name: "gtk_text_iter_forward_to_end";
end;

define C-function gtk-text-iter-forward-to-line-end
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_to_line_end";
end;

define C-function gtk-text-iter-set-visible-line-offset
  input parameter iter :: <GtkTextIter>;
  input parameter char_on_line :: <gint>;
  c-name: "gtk_text_iter_set_visible_line_offset";
end;

define C-function gtk-text-iter-set-visible-line-index
  input parameter iter :: <GtkTextIter>;
  input parameter byte_on_line :: <gint>;
  c-name: "gtk_text_iter_set_visible_line_index";
end;

define C-function gtk-text-iter-forward-to-tag-toggle
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_to_tag_toggle";
end;

define C-function gtk-text-iter-backward-to-tag-toggle
  input parameter iter :: <GtkTextIter>;
  input parameter tag :: <GtkTextTag>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_to_tag_toggle";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5508>"*/
define constant <GtkTextCharPredicate> = <anonymous-5508>;

define C-function gtk-text-iter-forward-find-char
  input parameter iter :: <GtkTextIter>;
  input parameter pred :: <GtkTextCharPredicate>;
  input parameter user_data :: <gpointer>;
  input parameter limit :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_find_char";
end;

define C-function gtk-text-iter-backward-find-char
  input parameter iter :: <GtkTextIter>;
  input parameter pred :: <GtkTextCharPredicate>;
  input parameter user_data :: <gpointer>;
  input parameter limit :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_find_char";
end;

define C-function gtk-text-iter-forward-search
  input parameter iter :: <GtkTextIter>;
  input parameter str :: <c-string>;
  input parameter flags :: <GtkTextSearchFlags>;
  input parameter match_start :: <GtkTextIter>;
  input parameter match_end :: <GtkTextIter>;
  input parameter limit :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_forward_search";
end;

define C-function gtk-text-iter-backward-search
  input parameter iter :: <GtkTextIter>;
  input parameter str :: <c-string>;
  input parameter flags :: <GtkTextSearchFlags>;
  input parameter match_start :: <GtkTextIter>;
  input parameter match_end :: <GtkTextIter>;
  input parameter limit :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_backward_search";
end;

define C-function gtk-text-iter-equal
  input parameter lhs :: <GtkTextIter>;
  input parameter rhs :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_equal";
end;

define C-function gtk-text-iter-compare
  input parameter lhs :: <GtkTextIter>;
  input parameter rhs :: <GtkTextIter>;
  result res :: <gint>;
  c-name: "gtk_text_iter_compare";
end;

define C-function gtk-text-iter-in-range
  input parameter iter :: <GtkTextIter>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_iter_in_range";
end;

define C-function gtk-text-iter-order
  input parameter first :: <GtkTextIter>;
  input parameter second :: <GtkTextIter>;
  c-name: "gtk_text_iter_order";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5416>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5417>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5418>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5419>"*/
define C-subtype <_GtkTextChildAnchorClass> (<C-void*>) end;
define constant <GtkTextChildAnchorClass> = <_GtkTextChildAnchorClass>;

define C-function gtk-text-child-anchor-get-type
  result res :: <GType>;
  c-name: "gtk_text_child_anchor_get_type";
end;

define C-function gtk-text-child-anchor-new
  result res :: <GtkTextChildAnchor>;
  c-name: "gtk_text_child_anchor_new";
end;

define C-function gtk-text-child-anchor-get-widgets
  input parameter anchor :: <GtkTextChildAnchor>;
  result res :: <GList>;
  c-name: "gtk_text_child_anchor_get_widgets";
end;

define C-function gtk-text-child-anchor-get-deleted
  input parameter anchor :: <GtkTextChildAnchor>;
  result res :: <gboolean>;
  c-name: "gtk_text_child_anchor_get_deleted";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5383>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5384>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5385>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5386>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5387>"*/
define C-subtype <_GtkTextTagClass> (<C-void*>) end;
define constant <GtkTextTagClass> = <_GtkTextTagClass>;

define C-function gtk-text-tag-get-type
  result res :: <GType>;
  c-name: "gtk_text_tag_get_type";
end;

define C-function gtk-text-tag-new
  input parameter name :: <c-string>;
  result res :: <GtkTextTag>;
  c-name: "gtk_text_tag_new";
end;

define C-function gtk-text-tag-get-priority
  input parameter tag :: <GtkTextTag>;
  result res :: <gint>;
  c-name: "gtk_text_tag_get_priority";
end;

define C-function gtk-text-tag-set-priority
  input parameter tag :: <GtkTextTag>;
  input parameter priority :: <gint>;
  c-name: "gtk_text_tag_set_priority";
end;

define C-function gtk-text-tag-event
  input parameter tag :: <GtkTextTag>;
  input parameter event_object :: <GObject>;
  input parameter event :: <GdkEvent>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_tag_event";
end;

define C-function gtk-text-attributes-new
  result res :: <GtkTextAttributes>;
  c-name: "gtk_text_attributes_new";
end;

define C-function gtk-text-attributes-copy
  input parameter src :: <GtkTextAttributes>;
  result res :: <GtkTextAttributes>;
  c-name: "gtk_text_attributes_copy";
end;

define C-function gtk-text-attributes-copy-values
  input parameter src :: <GtkTextAttributes>;
  input parameter dest :: <GtkTextAttributes>;
  c-name: "gtk_text_attributes_copy_values";
end;

define C-function gtk-text-attributes-unref
  input parameter values :: <GtkTextAttributes>;
  c-name: "gtk_text_attributes_unref";
end;

define C-function gtk-text-attributes-ref
  input parameter values :: <GtkTextAttributes>;
  result res :: <GtkTextAttributes>;
  c-name: "gtk_text_attributes_ref";
end;

define C-function gtk-text-attributes-get-type
  result res :: <GType>;
  c-name: "gtk_text_attributes_get_type";
end;

define C-subtype <_GtkTreeStore> (<GObject>, <GtkTreeModel>, <GtkTreeDragSource>, <GtkTreeDragDest>, <GtkTreeSortable>) end;
define constant <GtkTreeStore> = <_GtkTreeStore>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8146>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8147>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8148>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8149>"*/
define C-subtype <_GtkTreeStoreClass> (<C-void*>) end;
define constant <GtkTreeStoreClass> = <_GtkTreeStoreClass>;

define C-function gtk-tree-store-get-type
  result res :: <GType>;
  c-name: "gtk_tree_store_get_type";
end;

define C-function gtk-tree-store-new
  input parameter n_columns :: <gint>;
  result res :: <GtkTreeStore>;
  c-name: "gtk_tree_store_new";
end;

define C-function gtk-tree-store-newv
  input parameter n_columns :: <gint>;
  input parameter types :: <GType*>;
  result res :: <GtkTreeStore>;
  c-name: "gtk_tree_store_newv";
end;

define C-function gtk-tree-store-set-column-types
  input parameter tree_store :: <GtkTreeStore>;
  input parameter n_columns :: <gint>;
  input parameter types :: <GType*>;
  c-name: "gtk_tree_store_set_column_types";
end;

define C-function gtk-tree-store-set-value
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter column :: <gint>;
  input parameter value :: <GValue>;
  c-name: "gtk_tree_store_set_value";
end;

define C-function gtk-tree-store-set
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_store_set";
end;

define C-function gtk-tree-store-set-valist
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter var_args :: <va-list>;
  c-name: "gtk_tree_store_set_valist";
end;

define C-function gtk-tree-store-remove
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_store_remove";
end;

define C-function gtk-tree-store-insert
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter position :: <gint>;
  c-name: "gtk_tree_store_insert";
end;

define C-function gtk-tree-store-insert-before
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter sibling :: <GtkTreeIter>;
  c-name: "gtk_tree_store_insert_before";
end;

define C-function gtk-tree-store-insert-after
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter sibling :: <GtkTreeIter>;
  c-name: "gtk_tree_store_insert_after";
end;

define C-function gtk-tree-store-insert-with-values
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter position :: <gint>;
  c-name: "gtk_tree_store_insert_with_values";
end;

define C-function gtk-tree-store-insert-with-valuesv
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  input parameter position :: <gint>;
  input parameter columns :: <gint*>;
  input parameter values :: <GValue>;
  input parameter n_values :: <gint>;
  c-name: "gtk_tree_store_insert_with_valuesv";
end;

define C-function gtk-tree-store-prepend
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  c-name: "gtk_tree_store_prepend";
end;

define C-function gtk-tree-store-append
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter parent :: <GtkTreeIter>;
  c-name: "gtk_tree_store_append";
end;

define C-function gtk-tree-store-is-ancestor
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter descendant :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_store_is_ancestor";
end;

define C-function gtk-tree-store-iter-depth
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gint>;
  c-name: "gtk_tree_store_iter_depth";
end;

define C-function gtk-tree-store-clear
  input parameter tree_store :: <GtkTreeStore>;
  c-name: "gtk_tree_store_clear";
end;

define C-function gtk-tree-store-iter-is-valid
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_store_iter_is_valid";
end;

define C-function gtk-tree-store-reorder
  input parameter tree_store :: <GtkTreeStore>;
  input parameter parent :: <GtkTreeIter>;
  input parameter new_order :: <gint*>;
  c-name: "gtk_tree_store_reorder";
end;

define C-function gtk-tree-store-swap
  input parameter tree_store :: <GtkTreeStore>;
  input parameter a :: <GtkTreeIter>;
  input parameter b :: <GtkTreeIter>;
  c-name: "gtk_tree_store_swap";
end;

define C-function gtk-tree-store-move-before
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <GtkTreeIter>;
  c-name: "gtk_tree_store_move_before";
end;

define C-function gtk-tree-store-move-after
  input parameter tree_store :: <GtkTreeStore>;
  input parameter iter :: <GtkTreeIter>;
  input parameter position :: <GtkTreeIter>;
  c-name: "gtk_tree_store_move_after";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8119>"*/
define constant <GtkTreeSelectionForeachFunc> = <anonymous-8119>;

define C-function gtk-tree-selection-get-type
  result res :: <GType>;
  c-name: "gtk_tree_selection_get_type";
end;

define C-function gtk-tree-selection-set-mode
  input parameter selection :: <GtkTreeSelection>;
  input parameter type :: <GtkSelectionMode>;
  c-name: "gtk_tree_selection_set_mode";
end;

define C-function gtk-tree-selection-get-mode
  input parameter selection :: <GtkTreeSelection>;
  result res :: <GtkSelectionMode>;
  c-name: "gtk_tree_selection_get_mode";
end;

define C-function gtk-tree-selection-set-select-function
  input parameter selection :: <GtkTreeSelection>;
  input parameter func :: <GtkTreeSelectionFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_tree_selection_set_select_function";
end;

define C-function gtk-tree-selection-get-user-data
  input parameter selection :: <GtkTreeSelection>;
  result res :: <gpointer>;
  c-name: "gtk_tree_selection_get_user_data";
end;

define C-function gtk-tree-selection-get-tree-view
  input parameter selection :: <GtkTreeSelection>;
  result res :: <GtkTreeView>;
  c-name: "gtk_tree_selection_get_tree_view";
end;

define C-pointer-type <GtkTreeModel*> => <GtkTreeModel>;
define C-function gtk-tree-selection-get-selected
  input parameter selection :: <GtkTreeSelection>;
  input parameter model :: <GtkTreeModel*>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_selection_get_selected";
end;

define C-function gtk-tree-selection-get-selected-rows
  input parameter selection :: <GtkTreeSelection>;
  input parameter model :: <GtkTreeModel*>;
  result res :: <GList>;
  c-name: "gtk_tree_selection_get_selected_rows";
end;

define C-function gtk-tree-selection-count-selected-rows
  input parameter selection :: <GtkTreeSelection>;
  result res :: <gint>;
  c-name: "gtk_tree_selection_count_selected_rows";
end;

define C-function gtk-tree-selection-selected-foreach
  input parameter selection :: <GtkTreeSelection>;
  input parameter func :: <GtkTreeSelectionForeachFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_tree_selection_selected_foreach";
end;

define C-function gtk-tree-selection-select-path
  input parameter selection :: <GtkTreeSelection>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_selection_select_path";
end;

define C-function gtk-tree-selection-unselect-path
  input parameter selection :: <GtkTreeSelection>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_tree_selection_unselect_path";
end;

define C-function gtk-tree-selection-select-iter
  input parameter selection :: <GtkTreeSelection>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_selection_select_iter";
end;

define C-function gtk-tree-selection-unselect-iter
  input parameter selection :: <GtkTreeSelection>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_tree_selection_unselect_iter";
end;

define C-function gtk-tree-selection-path-is-selected
  input parameter selection :: <GtkTreeSelection>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_selection_path_is_selected";
end;

define C-function gtk-tree-selection-iter-is-selected
  input parameter selection :: <GtkTreeSelection>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_selection_iter_is_selected";
end;

define C-function gtk-tree-selection-select-all
  input parameter selection :: <GtkTreeSelection>;
  c-name: "gtk_tree_selection_select_all";
end;

define C-function gtk-tree-selection-unselect-all
  input parameter selection :: <GtkTreeSelection>;
  c-name: "gtk_tree_selection_unselect_all";
end;

define C-function gtk-tree-selection-select-range
  input parameter selection :: <GtkTreeSelection>;
  input parameter start_path :: <GtkTreePath>;
  input parameter end_path :: <GtkTreePath>;
  c-name: "gtk_tree_selection_select_range";
end;

define C-function gtk-tree-selection-unselect-range
  input parameter selection :: <GtkTreeSelection>;
  input parameter start_path :: <GtkTreePath>;
  input parameter end_path :: <GtkTreePath>;
  c-name: "gtk_tree_selection_unselect_range";
end;

define C-subtype <_GtkTreeModelSort> (<GObject>, <GtkTreeModel>, <GtkTreeSortable>) end;
define constant <GtkTreeModelSort> = <_GtkTreeModelSort>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8104>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8105>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8106>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8107>"*/
define C-subtype <_GtkTreeModelSortClass> (<C-void*>) end;
define constant <GtkTreeModelSortClass> = <_GtkTreeModelSortClass>;

define C-function gtk-tree-model-sort-get-type
  result res :: <GType>;
  c-name: "gtk_tree_model_sort_get_type";
end;

define C-function gtk-tree-model-sort-new-with-model
  input parameter child_model :: <GtkTreeModel>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_model_sort_new_with_model";
end;

define C-function gtk-tree-model-sort-get-model
  input parameter tree_model :: <GtkTreeModelSort>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_tree_model_sort_get_model";
end;

define C-function gtk-tree-model-sort-convert-child-path-to-path
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  input parameter child_path :: <GtkTreePath>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_model_sort_convert_child_path_to_path";
end;

define C-function gtk-tree-model-sort-convert-child-iter-to-iter
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  input parameter sort_iter :: <GtkTreeIter>;
  input parameter child_iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_sort_convert_child_iter_to_iter";
end;

define C-function gtk-tree-model-sort-convert-path-to-child-path
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  input parameter sorted_path :: <GtkTreePath>;
  result res :: <GtkTreePath>;
  c-name: "gtk_tree_model_sort_convert_path_to_child_path";
end;

define C-function gtk-tree-model-sort-convert-iter-to-child-iter
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  input parameter child_iter :: <GtkTreeIter>;
  input parameter sorted_iter :: <GtkTreeIter>;
  c-name: "gtk_tree_model_sort_convert_iter_to_child_iter";
end;

define C-function gtk-tree-model-sort-reset-default-sort-func
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  c-name: "gtk_tree_model_sort_reset_default_sort_func";
end;

define C-function gtk-tree-model-sort-clear-cache
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  c-name: "gtk_tree_model_sort_clear_cache";
end;

define C-function gtk-tree-model-sort-iter-is-valid
  input parameter tree_model_sort :: <GtkTreeModelSort>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_tree_model_sort_iter_is_valid";
end;

define C-subtype <_GtkTreeDragSource> (<C-void*>) end;
define constant <GtkTreeDragSource> = <_GtkTreeDragSource>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8090>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8091>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8092>"*/
define C-subtype <_GtkTreeDragSourceIface> (<C-void*>) end;
define constant <GtkTreeDragSourceIface> = <_GtkTreeDragSourceIface>;

define C-function gtk-tree-drag-source-get-type
  result res :: <GType>;
  c-name: "gtk_tree_drag_source_get_type";
end;

define C-function gtk-tree-drag-source-row-draggable
  input parameter drag_source :: <GtkTreeDragSource>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_drag_source_row_draggable";
end;

define C-function gtk-tree-drag-source-drag-data-delete
  input parameter drag_source :: <GtkTreeDragSource>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_drag_source_drag_data_delete";
end;

define C-function gtk-tree-drag-source-drag-data-get
  input parameter drag_source :: <GtkTreeDragSource>;
  input parameter path :: <GtkTreePath>;
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gboolean>;
  c-name: "gtk_tree_drag_source_drag_data_get";
end;

define C-subtype <_GtkTreeDragDest> (<C-void*>) end;
define constant <GtkTreeDragDest> = <_GtkTreeDragDest>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8097>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8098>"*/
define C-subtype <_GtkTreeDragDestIface> (<C-void*>) end;
define constant <GtkTreeDragDestIface> = <_GtkTreeDragDestIface>;

define C-function gtk-tree-drag-dest-get-type
  result res :: <GType>;
  c-name: "gtk_tree_drag_dest_get_type";
end;

define C-function gtk-tree-drag-dest-drag-data-received
  input parameter drag_dest :: <GtkTreeDragDest>;
  input parameter dest :: <GtkTreePath>;
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gboolean>;
  c-name: "gtk_tree_drag_dest_drag_data_received";
end;

define C-function gtk-tree-drag-dest-row-drop-possible
  input parameter drag_dest :: <GtkTreeDragDest>;
  input parameter dest_path :: <GtkTreePath>;
  input parameter selection_data :: <GtkSelectionData>;
  result res :: <gboolean>;
  c-name: "gtk_tree_drag_dest_row_drop_possible";
end;

define C-function gtk-tree-set-row-drag-data
  input parameter selection_data :: <GtkSelectionData>;
  input parameter tree_model :: <GtkTreeModel>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_tree_set_row_drag_data";
end;

define C-function gtk-tree-get-row-drag-data
  input parameter selection_data :: <GtkSelectionData>;
  input parameter tree_model :: <GtkTreeModel*>;
  input parameter path :: <GtkTreePath*>;
  result res :: <gboolean>;
  c-name: "gtk_tree_get_row_drag_data";
end;

define constant <GtkTooltips> = <_GtkTooltips>;

define C-subtype <_GtkTooltipsData> (<C-void*>) end;
define constant <GtkTooltipsData> = <_GtkTooltipsData>;

define C-subtype <_GtkTooltips> (<GtkObject>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6928>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6929>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6930>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6931>"*/
define C-subtype <_GtkTooltipsClass> (<C-void*>) end;
define constant <GtkTooltipsClass> = <_GtkTooltipsClass>;

define C-function gtk-tooltips-get-type
  result res :: <GType>;
  c-name: "gtk_tooltips_get_type";
end;

define C-function gtk-tooltips-new
  result res :: <GtkTooltips>;
  c-name: "gtk_tooltips_new";
end;

define C-function gtk-tooltips-enable
  input parameter tooltips :: <GtkTooltips>;
  c-name: "gtk_tooltips_enable";
end;

define C-function gtk-tooltips-disable
  input parameter tooltips :: <GtkTooltips>;
  c-name: "gtk_tooltips_disable";
end;

define C-function gtk-tooltips-set-delay
  input parameter tooltips :: <GtkTooltips>;
  input parameter delay :: <guint>;
  c-name: "gtk_tooltips_set_delay";
end;

define C-function gtk-tooltips-set-tip
  input parameter tooltips :: <GtkTooltips>;
  input parameter widget :: <GtkWidget>;
  input parameter tip_text :: <c-string>;
  input parameter tip_private :: <c-string>;
  c-name: "gtk_tooltips_set_tip";
end;

define C-function gtk-tooltips-data-get
  input parameter widget :: <GtkWidget>;
  result res :: <GtkTooltipsData>;
  c-name: "gtk_tooltips_data_get";
end;

define C-function gtk-tooltips-force-window
  input parameter tooltips :: <GtkTooltips>;
  c-name: "gtk_tooltips_force_window";
end;

define C-function _gtk-tooltips-toggle-keyboard-mode
  input parameter widget :: <GtkWidget>;
  c-name: "_gtk_tooltips_toggle_keyboard_mode";
end;

define C-pointer-type <GtkTooltips*> => <GtkTooltips>;
define C-function gtk-tooltips-get-info-from-tip-window
  input parameter tip_window :: <GtkWindow>;
  input parameter tooltips :: <GtkTooltips*>;
  input parameter current_widget :: <GtkWidget*>;
  result res :: <gboolean>;
  c-name: "gtk_tooltips_get_info_from_tip_window";
end;

define C-subtype <_GtkToolItemPrivate> (<C-void*>) end;
define constant <GtkToolItemPrivate> = <_GtkToolItemPrivate>;

define C-subtype <_GtkToolItem> (<C-void*>) end;
define constant <GtkToolItem> = <_GtkToolItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6942>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6943>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6944>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6945>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6946>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6947>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6948>"*/
define C-subtype <_GtkToolItemClass> (<C-void*>) end;
define constant <GtkToolItemClass> = <_GtkToolItemClass>;

define C-function gtk-tool-item-get-type
  result res :: <GType>;
  c-name: "gtk_tool_item_get_type";
end;

define C-function gtk-tool-item-new
  result res :: <GtkToolItem>;
  c-name: "gtk_tool_item_new";
end;

define C-function gtk-tool-item-set-homogeneous
  input parameter tool_item :: <GtkToolItem>;
  input parameter homogeneous :: <gboolean>;
  c-name: "gtk_tool_item_set_homogeneous";
end;

define C-function gtk-tool-item-get-homogeneous
  input parameter tool_item :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_homogeneous";
end;

define C-function gtk-tool-item-set-expand
  input parameter tool_item :: <GtkToolItem>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_tool_item_set_expand";
end;

define C-function gtk-tool-item-get-expand
  input parameter tool_item :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_expand";
end;

define C-function gtk-tool-item-set-tooltip
  input parameter tool_item :: <GtkToolItem>;
  input parameter tooltips :: <GtkTooltips>;
  input parameter tip_text :: <c-string>;
  input parameter tip_private :: <c-string>;
  c-name: "gtk_tool_item_set_tooltip";
end;

define C-function gtk-tool-item-set-use-drag-window
  input parameter toolitem :: <GtkToolItem>;
  input parameter use_drag_window :: <gboolean>;
  c-name: "gtk_tool_item_set_use_drag_window";
end;

define C-function gtk-tool-item-get-use-drag-window
  input parameter toolitem :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_use_drag_window";
end;

define C-function gtk-tool-item-set-visible-horizontal
  input parameter toolitem :: <GtkToolItem>;
  input parameter visible_horizontal :: <gboolean>;
  c-name: "gtk_tool_item_set_visible_horizontal";
end;

define C-function gtk-tool-item-get-visible-horizontal
  input parameter toolitem :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_visible_horizontal";
end;

define C-function gtk-tool-item-set-visible-vertical
  input parameter toolitem :: <GtkToolItem>;
  input parameter visible_vertical :: <gboolean>;
  c-name: "gtk_tool_item_set_visible_vertical";
end;

define C-function gtk-tool-item-get-visible-vertical
  input parameter toolitem :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_visible_vertical";
end;

define C-function gtk-tool-item-get-is-important
  input parameter tool_item :: <GtkToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_tool_item_get_is_important";
end;

define C-function gtk-tool-item-set-is-important
  input parameter tool_item :: <GtkToolItem>;
  input parameter is_important :: <gboolean>;
  c-name: "gtk_tool_item_set_is_important";
end;

define C-function gtk-tool-item-get-icon-size
  input parameter tool_item :: <GtkToolItem>;
  result res :: <GtkIconSize>;
  c-name: "gtk_tool_item_get_icon_size";
end;

define C-function gtk-tool-item-get-orientation
  input parameter tool_item :: <GtkToolItem>;
  result res :: <GtkOrientation>;
  c-name: "gtk_tool_item_get_orientation";
end;

define C-function gtk-tool-item-get-toolbar-style
  input parameter tool_item :: <GtkToolItem>;
  result res :: <GtkToolbarStyle>;
  c-name: "gtk_tool_item_get_toolbar_style";
end;

define C-function gtk-tool-item-get-relief-style
  input parameter tool_item :: <GtkToolItem>;
  result res :: <GtkReliefStyle>;
  c-name: "gtk_tool_item_get_relief_style";
end;

define C-function gtk-tool-item-retrieve-proxy-menu-item
  input parameter tool_item :: <GtkToolItem>;
  result res :: <GtkWidget>;
  c-name: "gtk_tool_item_retrieve_proxy_menu_item";
end;

define C-function gtk-tool-item-get-proxy-menu-item
  input parameter tool_item :: <GtkToolItem>;
  input parameter menu_item_id :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_tool_item_get_proxy_menu_item";
end;

define C-function gtk-tool-item-set-proxy-menu-item
  input parameter tool_item :: <GtkToolItem>;
  input parameter menu_item_id :: <c-string>;
  input parameter menu_item :: <GtkWidget>;
  c-name: "gtk_tool_item_set_proxy_menu_item";
end;

define C-function gtk-tool-item-rebuild-menu
  input parameter tool_item :: <GtkToolItem>;
  c-name: "gtk_tool_item_rebuild_menu";
end;

define C-function _gtk-tool-item-toolbar-reconfigured
  input parameter tool_item :: <GtkToolItem>;
  c-name: "_gtk_tool_item_toolbar_reconfigured";
end;

define C-subtype <_GtkItem> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkItem> = <_GtkItem>;

define C-subtype <_GtkMenuItem> (<GtkItem>, <AtkImplementorIface>) end;
define constant <GtkMenuItem> = <_GtkMenuItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5293>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5294>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5295>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5296>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5297>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5298>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5299>"*/
define C-subtype <_GtkItemClass> (<C-void*>) end;
define constant <GtkItemClass> = <_GtkItemClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5311>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5312>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5313>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5314>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5315>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5316>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5317>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5318>"*/
define C-subtype <_GtkMenuItemClass> (<C-void*>) end;
define constant <GtkMenuItemClass> = <_GtkMenuItemClass>;

define C-function gtk-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_menu_item_get_type";
end;

define C-function gtk-menu-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_menu_item_new";
end;

define C-function gtk-menu-item-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_item_new_with_label";
end;

define C-function gtk-menu-item-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_item_new_with_mnemonic";
end;

define C-function gtk-menu-item-set-submenu
  input parameter menu_item :: <GtkMenuItem>;
  input parameter submenu :: <GtkWidget>;
  c-name: "gtk_menu_item_set_submenu";
end;

define C-function gtk-menu-item-get-submenu
  input parameter menu_item :: <GtkMenuItem>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_item_get_submenu";
end;

define C-function gtk-menu-item-remove-submenu
  input parameter menu_item :: <GtkMenuItem>;
  c-name: "gtk_menu_item_remove_submenu";
end;

define C-function gtk-menu-item-select
  input parameter menu_item :: <GtkMenuItem>;
  c-name: "gtk_menu_item_select";
end;

define C-function gtk-menu-item-deselect
  input parameter menu_item :: <GtkMenuItem>;
  c-name: "gtk_menu_item_deselect";
end;

define C-function gtk-menu-item-activate
  input parameter menu_item :: <GtkMenuItem>;
  c-name: "gtk_menu_item_activate";
end;

define C-function gtk-menu-item-toggle-size-request
  input parameter menu_item :: <GtkMenuItem>;
  input parameter requisition :: <gint*>;
  c-name: "gtk_menu_item_toggle_size_request";
end;

define C-function gtk-menu-item-toggle-size-allocate
  input parameter menu_item :: <GtkMenuItem>;
  input parameter allocation :: <gint>;
  c-name: "gtk_menu_item_toggle_size_allocate";
end;

define C-function gtk-menu-item-set-right-justified
  input parameter menu_item :: <GtkMenuItem>;
  input parameter right_justified :: <gboolean>;
  c-name: "gtk_menu_item_set_right_justified";
end;

define C-function gtk-menu-item-get-right-justified
  input parameter menu_item :: <GtkMenuItem>;
  result res :: <gboolean>;
  c-name: "gtk_menu_item_get_right_justified";
end;

define C-function gtk-menu-item-set-accel-path
  input parameter menu_item :: <GtkMenuItem>;
  input parameter accel_path :: <c-string>;
  c-name: "gtk_menu_item_set_accel_path";
end;

define C-function _gtk-menu-item-refresh-accel-path
  input parameter menu_item :: <GtkMenuItem>;
  input parameter prefix :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  input parameter group_changed :: <gboolean>;
  c-name: "_gtk_menu_item_refresh_accel_path";
end;

define C-function _gtk-menu-item-is-selectable
  input parameter menu_item :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "_gtk_menu_item_is_selectable";
end;

define C-function _gtk-menu-item-popup-submenu
  input parameter menu_item :: <GtkWidget>;
  c-name: "_gtk_menu_item_popup_submenu";
end;

define C-function gtk-item-get-type
  result res :: <GType>;
  c-name: "gtk_item_get_type";
end;

define C-function gtk-item-select
  input parameter item :: <GtkItem>;
  c-name: "gtk_item_select";
end;

define C-function gtk-item-deselect
  input parameter item :: <GtkItem>;
  c-name: "gtk_item_deselect";
end;

define C-function gtk-item-toggle
  input parameter item :: <GtkItem>;
  c-name: "gtk_item_toggle";
end;

define C-subtype <_GtkToolButtonPrivate> (<C-void*>) end;
define constant <GtkToolButtonPrivate> = <_GtkToolButtonPrivate>;

define C-subtype <_GtkToolButton> (<C-void*>) end;
define constant <GtkToolButton> = <_GtkToolButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6973>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6974>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6975>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6976>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6977>"*/
define C-subtype <_GtkToolButtonClass> (<C-void*>) end;
define constant <GtkToolButtonClass> = <_GtkToolButtonClass>;

define C-function gtk-tool-button-get-type
  result res :: <GType>;
  c-name: "gtk_tool_button_get_type";
end;

define C-function gtk-tool-button-new
  input parameter icon_widget :: <GtkWidget>;
  input parameter label :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_tool_button_new";
end;

define C-function gtk-tool-button-new-from-stock
  input parameter stock_id :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_tool_button_new_from_stock";
end;

define C-function gtk-tool-button-set-label
  input parameter button :: <GtkToolButton>;
  input parameter label :: <c-string>;
  c-name: "gtk_tool_button_set_label";
end;

define C-function gtk-tool-button-get-label
  input parameter button :: <GtkToolButton>;
  result res :: <c-string>;
  c-name: "gtk_tool_button_get_label";
end;

define C-function gtk-tool-button-set-use-underline
  input parameter button :: <GtkToolButton>;
  input parameter use_underline :: <gboolean>;
  c-name: "gtk_tool_button_set_use_underline";
end;

define C-function gtk-tool-button-get-use-underline
  input parameter button :: <GtkToolButton>;
  result res :: <gboolean>;
  c-name: "gtk_tool_button_get_use_underline";
end;

define C-function gtk-tool-button-set-stock-id
  input parameter button :: <GtkToolButton>;
  input parameter stock_id :: <c-string>;
  c-name: "gtk_tool_button_set_stock_id";
end;

define C-function gtk-tool-button-get-stock-id
  input parameter button :: <GtkToolButton>;
  result res :: <c-string>;
  c-name: "gtk_tool_button_get_stock_id";
end;

define C-function gtk-tool-button-set-icon-name
  input parameter button :: <GtkToolButton>;
  input parameter icon_name :: <c-string>;
  c-name: "gtk_tool_button_set_icon_name";
end;

define C-function gtk-tool-button-get-icon-name
  input parameter button :: <GtkToolButton>;
  result res :: <c-string>;
  c-name: "gtk_tool_button_get_icon_name";
end;

define C-function gtk-tool-button-set-icon-widget
  input parameter button :: <GtkToolButton>;
  input parameter icon_widget :: <GtkWidget>;
  c-name: "gtk_tool_button_set_icon_widget";
end;

define C-function gtk-tool-button-get-icon-widget
  input parameter button :: <GtkToolButton>;
  result res :: <GtkWidget>;
  c-name: "gtk_tool_button_get_icon_widget";
end;

define C-function gtk-tool-button-set-label-widget
  input parameter button :: <GtkToolButton>;
  input parameter label_widget :: <GtkWidget>;
  c-name: "gtk_tool_button_set_label_widget";
end;

define C-function gtk-tool-button-get-label-widget
  input parameter button :: <GtkToolButton>;
  result res :: <GtkWidget>;
  c-name: "gtk_tool_button_get_label_widget";
end;

define C-function _gtk-tool-button-get-button
  input parameter button :: <GtkToolButton>;
  result res :: <GtkWidget>;
  c-name: "_gtk_tool_button_get_button";
end;

define constant <GtkToolbarChildType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-TOOLBAR-CHILD-SPACE :: <GtkToolbarChildType> = 0;
define constant $GTK-TOOLBAR-CHILD-BUTTON :: <GtkToolbarChildType> = 1;
define constant $GTK-TOOLBAR-CHILD-TOGGLEBUTTON :: <GtkToolbarChildType> = 2;
define constant $GTK-TOOLBAR-CHILD-RADIOBUTTON :: <GtkToolbarChildType> = 3;
define constant $GTK-TOOLBAR-CHILD-WIDGET :: <GtkToolbarChildType> = 4;

define C-subtype <_GtkToolbarChild> (<C-void*>) end;
define constant <GtkToolbarChild> = <_GtkToolbarChild>;

define constant <GtkToolbarSpaceStyle> = limited(<integer>, min: 0, max: 1);
define constant $GTK-TOOLBAR-SPACE-EMPTY :: <GtkToolbarSpaceStyle> = 0;
define constant $GTK-TOOLBAR-SPACE-LINE :: <GtkToolbarSpaceStyle> = 1;

define C-subtype <_GtkToolbar> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkToolbar> = <_GtkToolbar>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8045>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8046>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8047>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8048>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8049>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8050>"*/
define C-subtype <_GtkToolbarClass> (<C-void*>) end;
define constant <GtkToolbarClass> = <_GtkToolbarClass>;

define C-subtype <_GtkToolbarPrivate> (<C-void*>) end;
define constant <GtkToolbarPrivate> = <_GtkToolbarPrivate>;

define C-function gtk-toolbar-get-type
  result res :: <GType>;
  c-name: "gtk_toolbar_get_type";
end;

define C-function gtk-toolbar-new
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_new";
end;

define C-function gtk-toolbar-insert
  input parameter toolbar :: <GtkToolbar>;
  input parameter item :: <GtkToolItem>;
  input parameter pos :: <gint>;
  c-name: "gtk_toolbar_insert";
end;

define C-function gtk-toolbar-get-item-index
  input parameter toolbar :: <GtkToolbar>;
  input parameter item :: <GtkToolItem>;
  result res :: <gint>;
  c-name: "gtk_toolbar_get_item_index";
end;

define C-function gtk-toolbar-get-n-items
  input parameter toolbar :: <GtkToolbar>;
  result res :: <gint>;
  c-name: "gtk_toolbar_get_n_items";
end;

define C-function gtk-toolbar-get-nth-item
  input parameter toolbar :: <GtkToolbar>;
  input parameter n :: <gint>;
  result res :: <GtkToolItem>;
  c-name: "gtk_toolbar_get_nth_item";
end;

define C-function gtk-toolbar-get-show-arrow
  input parameter toolbar :: <GtkToolbar>;
  result res :: <gboolean>;
  c-name: "gtk_toolbar_get_show_arrow";
end;

define C-function gtk-toolbar-set-show-arrow
  input parameter toolbar :: <GtkToolbar>;
  input parameter show_arrow :: <gboolean>;
  c-name: "gtk_toolbar_set_show_arrow";
end;

define C-function gtk-toolbar-get-orientation
  input parameter toolbar :: <GtkToolbar>;
  result res :: <GtkOrientation>;
  c-name: "gtk_toolbar_get_orientation";
end;

define C-function gtk-toolbar-set-orientation
  input parameter toolbar :: <GtkToolbar>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_toolbar_set_orientation";
end;

define C-function gtk-toolbar-get-tooltips
  input parameter toolbar :: <GtkToolbar>;
  result res :: <gboolean>;
  c-name: "gtk_toolbar_get_tooltips";
end;

define C-function gtk-toolbar-set-tooltips
  input parameter toolbar :: <GtkToolbar>;
  input parameter enable :: <gboolean>;
  c-name: "gtk_toolbar_set_tooltips";
end;

define C-function gtk-toolbar-get-style
  input parameter toolbar :: <GtkToolbar>;
  result res :: <GtkToolbarStyle>;
  c-name: "gtk_toolbar_get_style";
end;

define C-function gtk-toolbar-set-style
  input parameter toolbar :: <GtkToolbar>;
  input parameter style :: <GtkToolbarStyle>;
  c-name: "gtk_toolbar_set_style";
end;

define C-function gtk-toolbar-unset-style
  input parameter toolbar :: <GtkToolbar>;
  c-name: "gtk_toolbar_unset_style";
end;

define C-function gtk-toolbar-get-icon-size
  input parameter toolbar :: <GtkToolbar>;
  result res :: <GtkIconSize>;
  c-name: "gtk_toolbar_get_icon_size";
end;

define C-function gtk-toolbar-get-relief-style
  input parameter toolbar :: <GtkToolbar>;
  result res :: <GtkReliefStyle>;
  c-name: "gtk_toolbar_get_relief_style";
end;

define C-function gtk-toolbar-get-drop-index
  input parameter toolbar :: <GtkToolbar>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <gint>;
  c-name: "gtk_toolbar_get_drop_index";
end;

define C-function gtk-toolbar-set-drop-highlight-item
  input parameter toolbar :: <GtkToolbar>;
  input parameter tool_item :: <GtkToolItem>;
  input parameter index_ :: <gint>;
  c-name: "gtk_toolbar_set_drop_highlight_item";
end;

define C-function _gtk-toolbar-elide-underscores
  input parameter original :: <c-string>;
  result res :: <c-string>;
  c-name: "_gtk_toolbar_elide_underscores";
end;

define C-function _gtk-toolbar-paint-space-line
  input parameter widget :: <GtkWidget>;
  input parameter toolbar :: <GtkToolbar>;
  input parameter area :: <GdkRectangle>;
  input parameter allocation :: <GtkAllocation>;
  c-name: "_gtk_toolbar_paint_space_line";
end;

define C-function _gtk-toolbar-get-default-space-size
  result res :: <gint>;
  c-name: "_gtk_toolbar_get_default_space_size";
end;

define C-function _gtk-toolbar-rebuild-menu
  input parameter toolbar :: <GtkToolbar>;
  c-name: "_gtk_toolbar_rebuild_menu";
end;

define C-function gtk-toolbar-set-icon-size
  input parameter toolbar :: <GtkToolbar>;
  input parameter icon_size :: <GtkIconSize>;
  c-name: "gtk_toolbar_set_icon_size";
end;

define C-function gtk-toolbar-unset-icon-size
  input parameter toolbar :: <GtkToolbar>;
  c-name: "gtk_toolbar_unset_icon_size";
end;

define C-function gtk-toolbar-append-item
  input parameter toolbar :: <GtkToolbar>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_append_item";
end;

define C-function gtk-toolbar-prepend-item
  input parameter toolbar :: <GtkToolbar>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_prepend_item";
end;

define C-function gtk-toolbar-insert-item
  input parameter toolbar :: <GtkToolbar>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  input parameter position :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_insert_item";
end;

define C-function gtk-toolbar-insert-stock
  input parameter toolbar :: <GtkToolbar>;
  input parameter stock_id :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  input parameter position :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_insert_stock";
end;

define C-function gtk-toolbar-append-space
  input parameter toolbar :: <GtkToolbar>;
  c-name: "gtk_toolbar_append_space";
end;

define C-function gtk-toolbar-prepend-space
  input parameter toolbar :: <GtkToolbar>;
  c-name: "gtk_toolbar_prepend_space";
end;

define C-function gtk-toolbar-insert-space
  input parameter toolbar :: <GtkToolbar>;
  input parameter position :: <gint>;
  c-name: "gtk_toolbar_insert_space";
end;

define C-function gtk-toolbar-remove-space
  input parameter toolbar :: <GtkToolbar>;
  input parameter position :: <gint>;
  c-name: "gtk_toolbar_remove_space";
end;

define C-function gtk-toolbar-append-element
  input parameter toolbar :: <GtkToolbar>;
  input parameter type :: <GtkToolbarChildType>;
  input parameter widget :: <GtkWidget>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_append_element";
end;

define C-function gtk-toolbar-prepend-element
  input parameter toolbar :: <GtkToolbar>;
  input parameter type :: <GtkToolbarChildType>;
  input parameter widget :: <GtkWidget>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_prepend_element";
end;

define C-function gtk-toolbar-insert-element
  input parameter toolbar :: <GtkToolbar>;
  input parameter type :: <GtkToolbarChildType>;
  input parameter widget :: <GtkWidget>;
  input parameter text :: <c-string>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter icon :: <GtkWidget>;
  input parameter callback :: <GtkSignalFunc>;
  input parameter user_data :: <gpointer>;
  input parameter position :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_toolbar_insert_element";
end;

define C-function gtk-toolbar-append-widget
  input parameter toolbar :: <GtkToolbar>;
  input parameter widget :: <GtkWidget>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  c-name: "gtk_toolbar_append_widget";
end;

define C-function gtk-toolbar-prepend-widget
  input parameter toolbar :: <GtkToolbar>;
  input parameter widget :: <GtkWidget>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  c-name: "gtk_toolbar_prepend_widget";
end;

define C-function gtk-toolbar-insert-widget
  input parameter toolbar :: <GtkToolbar>;
  input parameter widget :: <GtkWidget>;
  input parameter tooltip_text :: <c-string>;
  input parameter tooltip_private_text :: <c-string>;
  input parameter position :: <gint>;
  c-name: "gtk_toolbar_insert_widget";
end;

define C-pointer-type <GtkType*> => <GtkType>;
define C-function gtk-signal-newv
  input parameter name :: <c-string>;
  input parameter signal_flags :: <GtkSignalRunType>;
  input parameter object_type :: <GtkType>;
  input parameter function_offset :: <guint>;
  input parameter marshaller :: <GtkSignalMarshaller>;
  input parameter return_val :: <GtkType>;
  input parameter n_args :: <guint>;
  input parameter args :: <GtkType*>;
  result res :: <guint>;
  c-name: "gtk_signal_newv";
end;

define C-function gtk-signal-new
  input parameter name :: <c-string>;
  input parameter signal_flags :: <GtkSignalRunType>;
  input parameter object_type :: <GtkType>;
  input parameter function_offset :: <guint>;
  input parameter marshaller :: <GtkSignalMarshaller>;
  input parameter return_val :: <GtkType>;
  input parameter n_args :: <guint>;
  result res :: <guint>;
  c-name: "gtk_signal_new";
end;

define C-function gtk-signal-emit-stop-by-name
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  c-name: "gtk_signal_emit_stop_by_name";
end;

define C-function gtk-signal-connect-object-while-alive
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  input parameter func :: <GtkSignalFunc>;
  input parameter alive_object :: <GtkObject>;
  c-name: "gtk_signal_connect_object_while_alive";
end;

define C-function gtk-signal-connect-while-alive
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  input parameter func :: <GtkSignalFunc>;
  input parameter func_data :: <gpointer>;
  input parameter alive_object :: <GtkObject>;
  c-name: "gtk_signal_connect_while_alive";
end;

define C-function gtk-signal-connect-full
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  input parameter func :: <GtkSignalFunc>;
  input parameter unsupported :: <GtkCallbackMarshal>;
  input parameter data :: <gpointer>;
  input parameter destroy_func :: <GtkDestroyNotify>;
  input parameter object_signal :: <gint>;
  input parameter after :: <gint>;
  result res :: <gulong>;
  c-name: "gtk_signal_connect_full";
end;

define C-function gtk-signal-emitv
  input parameter object :: <GtkObject>;
  input parameter signal_id :: <guint>;
  input parameter args :: <GtkArg>;
  c-name: "gtk_signal_emitv";
end;

define C-function gtk-signal-emit
  input parameter object :: <GtkObject>;
  input parameter signal_id :: <guint>;
  c-name: "gtk_signal_emit";
end;

define C-function gtk-signal-emit-by-name
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  c-name: "gtk_signal_emit_by_name";
end;

define C-function gtk-signal-emitv-by-name
  input parameter object :: <GtkObject>;
  input parameter name :: <c-string>;
  input parameter args :: <GtkArg>;
  c-name: "gtk_signal_emitv_by_name";
end;

define C-function gtk-signal-compat-matched
  input parameter object :: <GtkObject>;
  input parameter func :: <GtkSignalFunc>;
  input parameter data :: <gpointer>;
  input parameter match :: <GSignalMatchType>;
  input parameter action :: <guint>;
  c-name: "gtk_signal_compat_matched";
end;

define constant gtk-signal-default-marshaller = g-cclosure-marshal-VOID--VOID;

define C-function gtk-marshal-BOOLEAN--VOID
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__VOID";
end;

define C-function gtk-marshal-BOOLEAN--POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__POINTER";
end;

define C-function gtk-marshal-BOOLEAN--POINTER-POINTER-INT-INT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT";
end;

define C-function gtk-marshal-BOOLEAN--POINTER-INT-INT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__POINTER_INT_INT";
end;

define C-function gtk-marshal-BOOLEAN--POINTER-INT-INT-UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT";
end;

define C-function gtk-marshal-BOOLEAN--POINTER-STRING-STRING-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER";
end;

define C-function gtk-marshal-ENUM--ENUM
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_ENUM__ENUM";
end;

define C-function gtk-marshal-INT--POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_INT__POINTER";
end;

define C-function gtk-marshal-INT--POINTER-CHAR-CHAR
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_INT__POINTER_CHAR_CHAR";
end;

define C-function gtk-marshal-VOID--ENUM-FLOAT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__ENUM_FLOAT";
end;

define C-function gtk-marshal-VOID--ENUM-FLOAT-BOOLEAN
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN";
end;

define C-function gtk-marshal-VOID--INT-INT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__INT_INT";
end;

define C-function gtk-marshal-VOID--INT-INT-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__INT_INT_POINTER";
end;

define C-function gtk-marshal-VOID--POINTER-INT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_INT";
end;

define C-function gtk-marshal-VOID--POINTER-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_POINTER";
end;

define C-function gtk-marshal-VOID--POINTER-POINTER-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_POINTER_POINTER";
end;

define C-function gtk-marshal-VOID--POINTER-STRING-STRING
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_STRING_STRING";
end;

define C-function gtk-marshal-VOID--POINTER-UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_UINT";
end;

define C-function gtk-marshal-VOID--POINTER-UINT-ENUM
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_UINT_ENUM";
end;

define C-function gtk-marshal-VOID--POINTER-POINTER-UINT-UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_POINTER_UINT_UINT";
end;

define C-function gtk-marshal-VOID--POINTER-INT-INT-POINTER-UINT-UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT";
end;

define C-function gtk-marshal-VOID--POINTER-UINT-UINT
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__POINTER_UINT_UINT";
end;

define C-function gtk-marshal-VOID--STRING-INT-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__STRING_INT_POINTER";
end;

define C-function gtk-marshal-VOID--UINT-POINTER-UINT-ENUM-ENUM-POINTER
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER";
end;

define C-function gtk-marshal-VOID--UINT-POINTER-UINT-UINT-ENUM
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM";
end;

define C-function gtk-marshal-VOID--UINT-STRING
  input parameter closure :: <GClosure>;
  input parameter return_value :: <GValue>;
  input parameter n_param_values :: <guint>;
  input parameter param_values :: <GValue>;
  input parameter invocation_hint :: <gpointer>;
  input parameter marshal_data :: <gpointer>;
  c-name: "gtk_marshal_VOID__UINT_STRING";
end;

define constant gtk-marshal-BOOL--NONE = gtk-marshal-BOOLEAN--VOID;

define constant gtk-marshal-BOOL--POINTER = gtk-marshal-BOOLEAN--POINTER;

define constant gtk-marshal-BOOL--POINTER-POINTER-INT-INT = gtk-marshal-BOOLEAN--POINTER-POINTER-INT-INT;

define constant gtk-marshal-BOOL--POINTER-INT-INT = gtk-marshal-BOOLEAN--POINTER-INT-INT;

define constant gtk-marshal-BOOL--POINTER-INT-INT-UINT = gtk-marshal-BOOLEAN--POINTER-INT-INT-UINT;

define constant gtk-marshal-BOOL--POINTER-STRING-STRING-POINTER = gtk-marshal-BOOLEAN--POINTER-STRING-STRING-POINTER;

define constant gtk-marshal-VOID--BOOLEAN = g-cclosure-marshal-VOID--BOOLEAN;

define constant gtk-marshal-NONE--BOOL = g-cclosure-marshal-VOID--BOOLEAN;

define constant gtk-marshal-VOID--BOXED = g-cclosure-marshal-VOID--BOXED;

define constant gtk-marshal-NONE--BOXED = g-cclosure-marshal-VOID--BOXED;

define constant gtk-marshal-VOID--ENUM = g-cclosure-marshal-VOID--ENUM;

define constant gtk-marshal-NONE--ENUM = g-cclosure-marshal-VOID--ENUM;

define constant gtk-marshal-NONE--ENUM-FLOAT = gtk-marshal-VOID--ENUM-FLOAT;

define constant gtk-marshal-NONE--ENUM-FLOAT-BOOL = gtk-marshal-VOID--ENUM-FLOAT-BOOLEAN;

define constant gtk-marshal-VOID--INT = g-cclosure-marshal-VOID--INT;

define constant gtk-marshal-NONE--INT = g-cclosure-marshal-VOID--INT;

define constant gtk-marshal-NONE--INT-INT = gtk-marshal-VOID--INT-INT;

define constant gtk-marshal-NONE--INT-INT-POINTER = gtk-marshal-VOID--INT-INT-POINTER;

define constant gtk-marshal-VOID--VOID = g-cclosure-marshal-VOID--VOID;

define constant gtk-marshal-NONE--NONE = g-cclosure-marshal-VOID--VOID;

define constant gtk-marshal-VOID--OBJECT = g-cclosure-marshal-VOID--OBJECT;

define constant gtk-marshal-NONE--OBJECT = g-cclosure-marshal-VOID--OBJECT;

define constant gtk-marshal-VOID--POINTER = g-cclosure-marshal-VOID--POINTER;

define constant gtk-marshal-NONE--POINTER = g-cclosure-marshal-VOID--POINTER;

define constant gtk-marshal-NONE--POINTER-INT = gtk-marshal-VOID--POINTER-INT;

define constant gtk-marshal-NONE--POINTER-POINTER = gtk-marshal-VOID--POINTER-POINTER;

define constant gtk-marshal-NONE--POINTER-POINTER-POINTER = gtk-marshal-VOID--POINTER-POINTER-POINTER;

define constant gtk-marshal-NONE--POINTER-STRING-STRING = gtk-marshal-VOID--POINTER-STRING-STRING;

define constant gtk-marshal-NONE--POINTER-UINT = gtk-marshal-VOID--POINTER-UINT;

define constant gtk-marshal-NONE--POINTER-UINT-ENUM = gtk-marshal-VOID--POINTER-UINT-ENUM;

define constant gtk-marshal-NONE--POINTER-POINTER-UINT-UINT = gtk-marshal-VOID--POINTER-POINTER-UINT-UINT;

define constant gtk-marshal-NONE--POINTER-INT-INT-POINTER-UINT-UINT = gtk-marshal-VOID--POINTER-INT-INT-POINTER-UINT-UINT;

define constant gtk-marshal-NONE--POINTER-UINT-UINT = gtk-marshal-VOID--POINTER-UINT-UINT;

define constant gtk-marshal-VOID--STRING = g-cclosure-marshal-VOID--STRING;

define constant gtk-marshal-NONE--STRING = g-cclosure-marshal-VOID--STRING;

define constant gtk-marshal-NONE--STRING-INT-POINTER = gtk-marshal-VOID--STRING-INT-POINTER;

define constant gtk-marshal-VOID--UINT = g-cclosure-marshal-VOID--UINT;

define constant gtk-marshal-NONE--UINT = g-cclosure-marshal-VOID--UINT;

define constant gtk-marshal-NONE--UINT-POINTER-UINT-ENUM-ENUM-POINTER = gtk-marshal-VOID--UINT-POINTER-UINT-ENUM-ENUM-POINTER;

define constant gtk-marshal-NONE--UINT-POINTER-UINT-UINT-ENUM = gtk-marshal-VOID--UINT-POINTER-UINT-UINT-ENUM;

define constant gtk-marshal-NONE--UINT-STRING = gtk-marshal-VOID--UINT-STRING;

define C-subtype <_GtkMisc> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkMisc> = <_GtkMisc>;

define C-subtype <_GtkPixmap> (<GtkMisc>, <AtkImplementorIface>) end;
define constant <GtkPixmap> = <_GtkPixmap>;

define C-subtype <_GtkMiscClass> (<C-void*>) end;
define constant <GtkMiscClass> = <_GtkMiscClass>;

define C-subtype <_GtkPixmapClass> (<C-void*>) end;
define constant <GtkPixmapClass> = <_GtkPixmapClass>;

define C-function gtk-pixmap-get-type
  result res :: <GtkType>;
  c-name: "gtk_pixmap_get_type";
end;

define C-function gtk-pixmap-new
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  result res :: <GtkWidget>;
  c-name: "gtk_pixmap_new";
end;

define C-function gtk-pixmap-set
  input parameter pixmap :: <GtkPixmap>;
  input parameter val :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_pixmap_set";
end;

define C-function gtk-pixmap-get
  input parameter pixmap :: <GtkPixmap>;
  input parameter val :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  c-name: "gtk_pixmap_get";
end;

define C-function gtk-pixmap-set-build-insensitive
  input parameter pixmap :: <GtkPixmap>;
  input parameter build :: <gboolean>;
  c-name: "gtk_pixmap_set_build_insensitive";
end;

define C-function gtk-misc-get-type
  result res :: <GType>;
  c-name: "gtk_misc_get_type";
end;

define C-function gtk-misc-set-alignment
  input parameter misc :: <GtkMisc>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  c-name: "gtk_misc_set_alignment";
end;

define C-pointer-type <gfloat*> => <gfloat>;
define C-function gtk-misc-get-alignment
  input parameter misc :: <GtkMisc>;
  input parameter xalign :: <gfloat*>;
  input parameter yalign :: <gfloat*>;
  c-name: "gtk_misc_get_alignment";
end;

define C-function gtk-misc-set-padding
  input parameter misc :: <GtkMisc>;
  input parameter xpad :: <gint>;
  input parameter ypad :: <gint>;
  c-name: "gtk_misc_set_padding";
end;

define C-function gtk-misc-get-padding
  input parameter misc :: <GtkMisc>;
  input parameter xpad :: <gint*>;
  input parameter ypad :: <gint*>;
  c-name: "gtk_misc_get_padding";
end;

define C-subtype <_GtkToggleToolButtonPrivate> (<C-void*>) end;
define constant <GtkToggleToolButtonPrivate> = <_GtkToggleToolButtonPrivate>;

define C-subtype <_GtkToggleToolButton> (<C-void*>) end;
define constant <GtkToggleToolButton> = <_GtkToggleToolButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7467>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7468>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7469>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7470>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7471>"*/
define C-subtype <_GtkToggleToolButtonClass> (<C-void*>) end;
define constant <GtkToggleToolButtonClass> = <_GtkToggleToolButtonClass>;

define C-function gtk-toggle-tool-button-get-type
  result res :: <GType>;
  c-name: "gtk_toggle_tool_button_get_type";
end;

define C-function gtk-toggle-tool-button-new
  result res :: <GtkToolItem>;
  c-name: "gtk_toggle_tool_button_new";
end;

define C-function gtk-toggle-tool-button-new-from-stock
  input parameter stock_id :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_toggle_tool_button_new_from_stock";
end;

define C-function gtk-toggle-tool-button-set-active
  input parameter button :: <GtkToggleToolButton>;
  input parameter is_active :: <gboolean>;
  c-name: "gtk_toggle_tool_button_set_active";
end;

define C-function gtk-toggle-tool-button-get-active
  input parameter button :: <GtkToggleToolButton>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_tool_button_get_active";
end;

define C-subtype <_GtkButton> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkButton> = <_GtkButton>;

define C-subtype <_GtkToggleButton> (<GtkButton>, <AtkImplementorIface>) end;
define constant <GtkToggleButton> = <_GtkToggleButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4883>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4884>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4885>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4886>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4887>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4888>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4889>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4890>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4891>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4892>"*/
define C-subtype <_GtkButtonClass> (<C-void*>) end;
define constant <GtkButtonClass> = <_GtkButtonClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5267>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5268>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5269>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5270>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5271>"*/
define C-subtype <_GtkToggleButtonClass> (<C-void*>) end;
define constant <GtkToggleButtonClass> = <_GtkToggleButtonClass>;

define C-function gtk-toggle-button-get-type
  result res :: <GType>;
  c-name: "gtk_toggle_button_get_type";
end;

define C-function gtk-toggle-button-new
  result res :: <GtkWidget>;
  c-name: "gtk_toggle_button_new";
end;

define C-function gtk-toggle-button-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_toggle_button_new_with_label";
end;

define C-function gtk-toggle-button-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_toggle_button_new_with_mnemonic";
end;

define C-function gtk-toggle-button-set-mode
  input parameter toggle_button :: <GtkToggleButton>;
  input parameter draw_indicator :: <gboolean>;
  c-name: "gtk_toggle_button_set_mode";
end;

define C-function gtk-toggle-button-get-mode
  input parameter toggle_button :: <GtkToggleButton>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_button_get_mode";
end;

define C-function gtk-toggle-button-set-active
  input parameter toggle_button :: <GtkToggleButton>;
  input parameter is_active :: <gboolean>;
  c-name: "gtk_toggle_button_set_active";
end;

define C-function gtk-toggle-button-get-active
  input parameter toggle_button :: <GtkToggleButton>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_button_get_active";
end;

define C-function gtk-toggle-button-toggled
  input parameter toggle_button :: <GtkToggleButton>;
  c-name: "gtk_toggle_button_toggled";
end;

define C-function gtk-toggle-button-set-inconsistent
  input parameter toggle_button :: <GtkToggleButton>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_toggle_button_set_inconsistent";
end;

define C-function gtk-toggle-button-get-inconsistent
  input parameter toggle_button :: <GtkToggleButton>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_button_get_inconsistent";
end;

define constant gtk-toggle-button-set-state = gtk-toggle-button-set-active;

define C-function gtk-button-get-type
  result res :: <GType>;
  c-name: "gtk_button_get_type";
end;

define C-function gtk-button-new
  result res :: <GtkWidget>;
  c-name: "gtk_button_new";
end;

define C-function gtk-button-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_button_new_with_label";
end;

define C-function gtk-button-new-from-stock
  input parameter stock_id :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_button_new_from_stock";
end;

define C-function gtk-button-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_button_new_with_mnemonic";
end;

define C-function gtk-button-pressed
  input parameter button :: <GtkButton>;
  c-name: "gtk_button_pressed";
end;

define C-function gtk-button-released
  input parameter button :: <GtkButton>;
  c-name: "gtk_button_released";
end;

define C-function gtk-button-clicked
  input parameter button :: <GtkButton>;
  c-name: "gtk_button_clicked";
end;

define C-function gtk-button-enter
  input parameter button :: <GtkButton>;
  c-name: "gtk_button_enter";
end;

define C-function gtk-button-leave
  input parameter button :: <GtkButton>;
  c-name: "gtk_button_leave";
end;

define C-function gtk-button-set-relief
  input parameter button :: <GtkButton>;
  input parameter newstyle :: <GtkReliefStyle>;
  c-name: "gtk_button_set_relief";
end;

define C-function gtk-button-get-relief
  input parameter button :: <GtkButton>;
  result res :: <GtkReliefStyle>;
  c-name: "gtk_button_get_relief";
end;

define C-function gtk-button-set-label
  input parameter button :: <GtkButton>;
  input parameter label :: <c-string>;
  c-name: "gtk_button_set_label";
end;

define C-function gtk-button-get-label
  input parameter button :: <GtkButton>;
  result res :: <c-string>;
  c-name: "gtk_button_get_label";
end;

define C-function gtk-button-set-use-underline
  input parameter button :: <GtkButton>;
  input parameter use_underline :: <gboolean>;
  c-name: "gtk_button_set_use_underline";
end;

define C-function gtk-button-get-use-underline
  input parameter button :: <GtkButton>;
  result res :: <gboolean>;
  c-name: "gtk_button_get_use_underline";
end;

define C-function gtk-button-set-use-stock
  input parameter button :: <GtkButton>;
  input parameter use_stock :: <gboolean>;
  c-name: "gtk_button_set_use_stock";
end;

define C-function gtk-button-get-use-stock
  input parameter button :: <GtkButton>;
  result res :: <gboolean>;
  c-name: "gtk_button_get_use_stock";
end;

define C-function gtk-button-set-focus-on-click
  input parameter button :: <GtkButton>;
  input parameter focus_on_click :: <gboolean>;
  c-name: "gtk_button_set_focus_on_click";
end;

define C-function gtk-button-get-focus-on-click
  input parameter button :: <GtkButton>;
  result res :: <gboolean>;
  c-name: "gtk_button_get_focus_on_click";
end;

define C-function gtk-button-set-alignment
  input parameter button :: <GtkButton>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  c-name: "gtk_button_set_alignment";
end;

define C-function gtk-button-get-alignment
  input parameter button :: <GtkButton>;
  input parameter xalign :: <gfloat*>;
  input parameter yalign :: <gfloat*>;
  c-name: "gtk_button_get_alignment";
end;

define C-function gtk-button-set-image
  input parameter button :: <GtkButton>;
  input parameter image :: <GtkWidget>;
  c-name: "gtk_button_set_image";
end;

define C-function gtk-button-get-image
  input parameter button :: <GtkButton>;
  result res :: <GtkWidget>;
  c-name: "gtk_button_get_image";
end;

define C-function gtk-button-set-image-position
  input parameter button :: <GtkButton>;
  input parameter position :: <GtkPositionType>;
  c-name: "gtk_button_set_image_position";
end;

define C-function gtk-button-get-image-position
  input parameter button :: <GtkButton>;
  result res :: <GtkPositionType>;
  c-name: "gtk_button_get_image_position";
end;

define C-function _gtk-button-set-depressed
  input parameter button :: <GtkButton>;
  input parameter depressed :: <gboolean>;
  c-name: "_gtk_button_set_depressed";
end;

define C-function _gtk-button-paint
  input parameter button :: <GtkButton>;
  input parameter area :: <GdkRectangle>;
  input parameter state_type :: <GtkStateType>;
  input parameter shadow_type :: <GtkShadowType>;
  input parameter main_detail :: <c-string>;
  input parameter default_detail :: <c-string>;
  c-name: "_gtk_button_paint";
end;

define constant <GtkImageType> = limited(<integer>, min: 0, max: 7);
define constant $GTK-IMAGE-EMPTY :: <GtkImageType> = 0;
define constant $GTK-IMAGE-PIXMAP :: <GtkImageType> = 1;
define constant $GTK-IMAGE-IMAGE :: <GtkImageType> = 2;
define constant $GTK-IMAGE-PIXBUF :: <GtkImageType> = 3;
define constant $GTK-IMAGE-STOCK :: <GtkImageType> = 4;
define constant $GTK-IMAGE-ICON-SET :: <GtkImageType> = 5;
define constant $GTK-IMAGE-ANIMATION :: <GtkImageType> = 6;
define constant $GTK-IMAGE-ICON-NAME :: <GtkImageType> = 7;

define C-subtype <_GtkImagePixmapData> (<C-void*>) end;
define constant <GtkImagePixmapData> = <_GtkImagePixmapData>;

define C-subtype <_GtkImageImageData> (<C-void*>) end;
define constant <GtkImageImageData> = <_GtkImageImageData>;

define C-subtype <_GtkImagePixbufData> (<C-void*>) end;
define constant <GtkImagePixbufData> = <_GtkImagePixbufData>;

define C-subtype <_GtkImageStockData> (<C-void*>) end;
define constant <GtkImageStockData> = <_GtkImageStockData>;

define C-subtype <_GtkImageIconSetData> (<C-void*>) end;
define constant <GtkImageIconSetData> = <_GtkImageIconSetData>;

define C-subtype <_GtkImageAnimationData> (<C-void*>) end;
define constant <GtkImageAnimationData> = <_GtkImageAnimationData>;

define C-subtype <_GtkImageIconNameData> (<C-void*>) end;
define constant <GtkImageIconNameData> = <_GtkImageIconNameData>;

 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-4838>"*/
define C-subtype <_GtkImage> (<GtkMisc>, <AtkImplementorIface>) end;
define constant <GtkImage> = <_GtkImage>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4839>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4840>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4841>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4842>"*/
define C-subtype <_GtkImageClass> (<C-void*>) end;
define constant <GtkImageClass> = <_GtkImageClass>;

define C-function gtk-image-get-type
  result res :: <GType>;
  c-name: "gtk_image_get_type";
end;

define C-function gtk-image-new
  result res :: <GtkWidget>;
  c-name: "gtk_image_new";
end;

define C-function gtk-image-new-from-pixmap
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_pixmap";
end;

define C-function gtk-image-new-from-image
  input parameter image :: <GdkImage>;
  input parameter mask :: <GdkBitmap>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_image";
end;

define C-function gtk-image-new-from-file-utf8
  input parameter filename :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_file_utf8";
end;

define C-function gtk-image-new-from-pixbuf
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_pixbuf";
end;

define C-function gtk-image-new-from-stock
  input parameter stock_id :: <c-string>;
  input parameter size :: <GtkIconSize>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_stock";
end;

define C-function gtk-image-new-from-icon-set
  input parameter icon_set :: <GtkIconSet>;
  input parameter size :: <GtkIconSize>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_icon_set";
end;

define C-function gtk-image-new-from-animation
  input parameter animation :: <GdkPixbufAnimation>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_animation";
end;

define C-function gtk-image-new-from-icon-name
  input parameter icon_name :: <c-string>;
  input parameter size :: <GtkIconSize>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_new_from_icon_name";
end;

define C-function gtk-image-clear
  input parameter image :: <GtkImage>;
  c-name: "gtk_image_clear";
end;

define C-function gtk-image-set-from-pixmap
  input parameter image :: <GtkImage>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_image_set_from_pixmap";
end;

define C-function gtk-image-set-from-image
  input parameter image :: <GtkImage>;
  input parameter gdk_image :: <GdkImage>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_image_set_from_image";
end;

define C-function gtk-image-set-from-file-utf8
  input parameter image :: <GtkImage>;
  input parameter filename :: <c-string>;
  c-name: "gtk_image_set_from_file_utf8";
end;

define C-function gtk-image-set-from-pixbuf
  input parameter image :: <GtkImage>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_image_set_from_pixbuf";
end;

define C-function gtk-image-set-from-stock
  input parameter image :: <GtkImage>;
  input parameter stock_id :: <c-string>;
  input parameter size :: <GtkIconSize>;
  c-name: "gtk_image_set_from_stock";
end;

define C-function gtk-image-set-from-icon-set
  input parameter image :: <GtkImage>;
  input parameter icon_set :: <GtkIconSet>;
  input parameter size :: <GtkIconSize>;
  c-name: "gtk_image_set_from_icon_set";
end;

define C-function gtk-image-set-from-animation
  input parameter image :: <GtkImage>;
  input parameter animation :: <GdkPixbufAnimation>;
  c-name: "gtk_image_set_from_animation";
end;

define C-function gtk-image-set-from-icon-name
  input parameter image :: <GtkImage>;
  input parameter icon_name :: <c-string>;
  input parameter size :: <GtkIconSize>;
  c-name: "gtk_image_set_from_icon_name";
end;

define C-function gtk-image-set-pixel-size
  input parameter image :: <GtkImage>;
  input parameter pixel_size :: <gint>;
  c-name: "gtk_image_set_pixel_size";
end;

define C-function gtk-image-get-storage-type
  input parameter image :: <GtkImage>;
  result res :: <GtkImageType>;
  c-name: "gtk_image_get_storage_type";
end;

define C-function gtk-image-get-pixmap
  input parameter image :: <GtkImage>;
  input parameter pixmap :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  c-name: "gtk_image_get_pixmap";
end;

define C-pointer-type <GdkImage*> => <GdkImage>;
define C-function gtk-image-get-image
  input parameter image :: <GtkImage>;
  input parameter gdk_image :: <GdkImage*>;
  input parameter mask :: <GdkBitmap*>;
  c-name: "gtk_image_get_image";
end;

define C-function gtk-image-get-pixbuf
  input parameter image :: <GtkImage>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_image_get_pixbuf";
end;

define C-pointer-type <GtkIconSize*> => <GtkIconSize>;
define C-function gtk-image-get-stock
  input parameter image :: <GtkImage>;
  input parameter stock_id :: <gchar**>;
  input parameter size :: <GtkIconSize*>;
  c-name: "gtk_image_get_stock";
end;

define C-pointer-type <GtkIconSet*> => <GtkIconSet>;
define C-function gtk-image-get-icon-set
  input parameter image :: <GtkImage>;
  input parameter icon_set :: <GtkIconSet*>;
  input parameter size :: <GtkIconSize*>;
  c-name: "gtk_image_get_icon_set";
end;

define C-function gtk-image-get-animation
  input parameter image :: <GtkImage>;
  result res :: <GdkPixbufAnimation>;
  c-name: "gtk_image_get_animation";
end;

define C-function gtk-image-get-icon-name
  input parameter image :: <GtkImage>;
  input parameter icon_name :: <gchar**>;
  input parameter size :: <GtkIconSize*>;
  c-name: "gtk_image_get_icon_name";
end;

define C-function gtk-image-get-pixel-size
  input parameter image :: <GtkImage>;
  result res :: <gint>;
  c-name: "gtk_image_get_pixel_size";
end;

define C-function gtk-image-set
  input parameter image :: <GtkImage>;
  input parameter val :: <GdkImage>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_image_set";
end;

define C-function gtk-image-get
  input parameter image :: <GtkImage>;
  input parameter val :: <GdkImage*>;
  input parameter mask :: <GdkBitmap*>;
  c-name: "gtk_image_get";
end;

define constant gtk-image-new-from-file = gtk-image-new-from-file-utf8;

define constant gtk-image-set-from-file = gtk-image-set-from-file-utf8;

define C-subtype <_GtkToggleActionPrivate> (<C-void*>) end;
define constant <GtkToggleActionPrivate> = <_GtkToggleActionPrivate>;

define C-subtype <_GtkToggleAction> (<C-void*>) end;
define constant <GtkToggleAction> = <_GtkToggleAction>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7418>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7419>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7420>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7421>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7422>"*/
define C-subtype <_GtkToggleActionClass> (<C-void*>) end;
define constant <GtkToggleActionClass> = <_GtkToggleActionClass>;

define C-function gtk-toggle-action-get-type
  result res :: <GType>;
  c-name: "gtk_toggle_action_get_type";
end;

define C-function gtk-toggle-action-new
  input parameter name :: <c-string>;
  input parameter label :: <c-string>;
  input parameter tooltip :: <c-string>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkToggleAction>;
  c-name: "gtk_toggle_action_new";
end;

define C-function gtk-toggle-action-toggled
  input parameter action :: <GtkToggleAction>;
  c-name: "gtk_toggle_action_toggled";
end;

define C-function gtk-toggle-action-set-active
  input parameter action :: <GtkToggleAction>;
  input parameter is_active :: <gboolean>;
  c-name: "gtk_toggle_action_set_active";
end;

define C-function gtk-toggle-action-get-active
  input parameter action :: <GtkToggleAction>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_action_get_active";
end;

define C-function gtk-toggle-action-set-draw-as-radio
  input parameter action :: <GtkToggleAction>;
  input parameter draw_as_radio :: <gboolean>;
  c-name: "gtk_toggle_action_set_draw_as_radio";
end;

define C-function gtk-toggle-action-get-draw-as-radio
  input parameter action :: <GtkToggleAction>;
  result res :: <gboolean>;
  c-name: "gtk_toggle_action_get_draw_as_radio";
end;

define C-subtype <_GtkLabelSelectionInfo> (<C-void*>) end;
define constant <GtkLabelSelectionInfo> = <_GtkLabelSelectionInfo>;

define C-subtype <_GtkLabel> (<GtkMisc>, <AtkImplementorIface>) end;
define constant <GtkLabel> = <_GtkLabel>;

define C-subtype <_GtkTipsQuery> (<GtkLabel>, <AtkImplementorIface>) end;
define constant <GtkTipsQuery> = <_GtkTipsQuery>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4199>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4200>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4201>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4202>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4203>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4204>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4205>"*/
define C-subtype <_GtkLabelClass> (<C-void*>) end;
define constant <GtkLabelClass> = <_GtkLabelClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8027>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8028>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8029>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8030>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8031>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8032>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8033>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-8034>"*/
define C-subtype <_GtkTipsQueryClass> (<C-void*>) end;
define constant <GtkTipsQueryClass> = <_GtkTipsQueryClass>;

define C-function gtk-tips-query-get-type
  result res :: <GtkType>;
  c-name: "gtk_tips_query_get_type";
end;

define C-function gtk-tips-query-new
  result res :: <GtkWidget>;
  c-name: "gtk_tips_query_new";
end;

define C-function gtk-tips-query-start-query
  input parameter tips_query :: <GtkTipsQuery>;
  c-name: "gtk_tips_query_start_query";
end;

define C-function gtk-tips-query-stop-query
  input parameter tips_query :: <GtkTipsQuery>;
  c-name: "gtk_tips_query_stop_query";
end;

define C-function gtk-tips-query-set-caller
  input parameter tips_query :: <GtkTipsQuery>;
  input parameter caller :: <GtkWidget>;
  c-name: "gtk_tips_query_set_caller";
end;

define C-function gtk-tips-query-set-labels
  input parameter tips_query :: <GtkTipsQuery>;
  input parameter label_inactive :: <c-string>;
  input parameter label_no_tip :: <c-string>;
  c-name: "gtk_tips_query_set_labels";
end;

define C-function gtk-label-get-type
  result res :: <GType>;
  c-name: "gtk_label_get_type";
end;

define C-function gtk-label-new
  input parameter str :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_label_new";
end;

define C-function gtk-label-new-with-mnemonic
  input parameter str :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_label_new_with_mnemonic";
end;

define C-function gtk-label-set-text
  input parameter label :: <GtkLabel>;
  input parameter str :: <c-string>;
  c-name: "gtk_label_set_text";
end;

define C-function gtk-label-get-text
  input parameter label :: <GtkLabel>;
  result res :: <c-string>;
  c-name: "gtk_label_get_text";
end;

define C-function gtk-label-set-attributes
  input parameter label :: <GtkLabel>;
  input parameter attrs :: <PangoAttrList>;
  c-name: "gtk_label_set_attributes";
end;

define C-function gtk-label-get-attributes
  input parameter label :: <GtkLabel>;
  result res :: <PangoAttrList>;
  c-name: "gtk_label_get_attributes";
end;

define C-function gtk-label-set-label
  input parameter label :: <GtkLabel>;
  input parameter str :: <c-string>;
  c-name: "gtk_label_set_label";
end;

define C-function gtk-label-get-label
  input parameter label :: <GtkLabel>;
  result res :: <c-string>;
  c-name: "gtk_label_get_label";
end;

define C-function gtk-label-set-markup
  input parameter label :: <GtkLabel>;
  input parameter str :: <c-string>;
  c-name: "gtk_label_set_markup";
end;

define C-function gtk-label-set-use-markup
  input parameter label :: <GtkLabel>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_label_set_use_markup";
end;

define C-function gtk-label-get-use-markup
  input parameter label :: <GtkLabel>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_use_markup";
end;

define C-function gtk-label-set-use-underline
  input parameter label :: <GtkLabel>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_label_set_use_underline";
end;

define C-function gtk-label-get-use-underline
  input parameter label :: <GtkLabel>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_use_underline";
end;

define C-function gtk-label-set-markup-with-mnemonic
  input parameter label :: <GtkLabel>;
  input parameter str :: <c-string>;
  c-name: "gtk_label_set_markup_with_mnemonic";
end;

define C-function gtk-label-get-mnemonic-keyval
  input parameter label :: <GtkLabel>;
  result res :: <guint>;
  c-name: "gtk_label_get_mnemonic_keyval";
end;

define C-function gtk-label-set-mnemonic-widget
  input parameter label :: <GtkLabel>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_label_set_mnemonic_widget";
end;

define C-function gtk-label-get-mnemonic-widget
  input parameter label :: <GtkLabel>;
  result res :: <GtkWidget>;
  c-name: "gtk_label_get_mnemonic_widget";
end;

define C-function gtk-label-set-text-with-mnemonic
  input parameter label :: <GtkLabel>;
  input parameter str :: <c-string>;
  c-name: "gtk_label_set_text_with_mnemonic";
end;

define C-function gtk-label-set-justify
  input parameter label :: <GtkLabel>;
  input parameter jtype :: <GtkJustification>;
  c-name: "gtk_label_set_justify";
end;

define C-function gtk-label-get-justify
  input parameter label :: <GtkLabel>;
  result res :: <GtkJustification>;
  c-name: "gtk_label_get_justify";
end;

define C-function gtk-label-set-ellipsize
  input parameter label :: <GtkLabel>;
  input parameter mode :: <PangoEllipsizeMode>;
  c-name: "gtk_label_set_ellipsize";
end;

define C-function gtk-label-get-ellipsize
  input parameter label :: <GtkLabel>;
  result res :: <PangoEllipsizeMode>;
  c-name: "gtk_label_get_ellipsize";
end;

define C-function gtk-label-set-width-chars
  input parameter label :: <GtkLabel>;
  input parameter n_chars :: <gint>;
  c-name: "gtk_label_set_width_chars";
end;

define C-function gtk-label-get-width-chars
  input parameter label :: <GtkLabel>;
  result res :: <gint>;
  c-name: "gtk_label_get_width_chars";
end;

define C-function gtk-label-set-max-width-chars
  input parameter label :: <GtkLabel>;
  input parameter n_chars :: <gint>;
  c-name: "gtk_label_set_max_width_chars";
end;

define C-function gtk-label-get-max-width-chars
  input parameter label :: <GtkLabel>;
  result res :: <gint>;
  c-name: "gtk_label_get_max_width_chars";
end;

define C-function gtk-label-set-pattern
  input parameter label :: <GtkLabel>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_label_set_pattern";
end;

define C-function gtk-label-set-line-wrap
  input parameter label :: <GtkLabel>;
  input parameter wrap :: <gboolean>;
  c-name: "gtk_label_set_line_wrap";
end;

define C-function gtk-label-get-line-wrap
  input parameter label :: <GtkLabel>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_line_wrap";
end;

define C-function gtk-label-set-line-wrap-mode
  input parameter label :: <GtkLabel>;
  input parameter wrap_mode :: <PangoWrapMode>;
  c-name: "gtk_label_set_line_wrap_mode";
end;

define C-function gtk-label-get-line-wrap-mode
  input parameter label :: <GtkLabel>;
  result res :: <PangoWrapMode>;
  c-name: "gtk_label_get_line_wrap_mode";
end;

define C-function gtk-label-set-selectable
  input parameter label :: <GtkLabel>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_label_set_selectable";
end;

define C-function gtk-label-get-selectable
  input parameter label :: <GtkLabel>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_selectable";
end;

define C-function gtk-label-set-angle
  input parameter label :: <GtkLabel>;
  input parameter angle :: <gdouble>;
  c-name: "gtk_label_set_angle";
end;

define C-function gtk-label-get-angle
  input parameter label :: <GtkLabel>;
  result res :: <gdouble>;
  c-name: "gtk_label_get_angle";
end;

define C-function gtk-label-select-region
  input parameter label :: <GtkLabel>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  c-name: "gtk_label_select_region";
end;

define C-function gtk-label-get-selection-bounds
  input parameter label :: <GtkLabel>;
  input parameter start :: <gint*>;
  input parameter end :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_selection_bounds";
end;

define C-function gtk-label-get-layout
  input parameter label :: <GtkLabel>;
  result res :: <PangoLayout>;
  c-name: "gtk_label_get_layout";
end;

define C-function gtk-label-get-layout-offsets
  input parameter label :: <GtkLabel>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  c-name: "gtk_label_get_layout_offsets";
end;

define C-function gtk-label-set-single-line-mode
  input parameter label :: <GtkLabel>;
  input parameter single_line_mode :: <gboolean>;
  c-name: "gtk_label_set_single_line_mode";
end;

define C-function gtk-label-get-single-line-mode
  input parameter label :: <GtkLabel>;
  result res :: <gboolean>;
  c-name: "gtk_label_get_single_line_mode";
end;

define C-function gtk-label-get
  input parameter label :: <GtkLabel>;
  input parameter str :: <gchar**>;
  c-name: "gtk_label_get";
end;

define C-function gtk-label-parse-uline
  input parameter label :: <GtkLabel>;
  input parameter string :: <c-string>;
  result res :: <guint>;
  c-name: "gtk_label_parse_uline";
end;

define constant gtk-label-set = gtk-label-set-text;

define constant <GtkTextWindowType> = limited(<integer>, min: 0, max: 6);
define constant $GTK-TEXT-WINDOW-PRIVATE :: <GtkTextWindowType> = 0;
define constant $GTK-TEXT-WINDOW-WIDGET :: <GtkTextWindowType> = 1;
define constant $GTK-TEXT-WINDOW-TEXT :: <GtkTextWindowType> = 2;
define constant $GTK-TEXT-WINDOW-LEFT :: <GtkTextWindowType> = 3;
define constant $GTK-TEXT-WINDOW-RIGHT :: <GtkTextWindowType> = 4;
define constant $GTK-TEXT-WINDOW-TOP :: <GtkTextWindowType> = 5;
define constant $GTK-TEXT-WINDOW-BOTTOM :: <GtkTextWindowType> = 6;

define C-subtype <_GtkTextLayout> (<C-void*>) end;
define C-subtype <_GtkTextWindow> (<C-void*>) end;
define constant <GtkTextWindow> = <_GtkTextWindow>;

define C-subtype <_GtkTextMark> (<GObject>) end;
define constant <GtkTextMark> = <_GtkTextMark>;

define C-subtype <_GtkTextPendingScroll> (<C-void*>) end;
define constant <GtkTextPendingScroll> = <_GtkTextPendingScroll>;

define C-subtype <_GtkTextView> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkTextView> = <_GtkTextView>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7947>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7948>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7949>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7950>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7951>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7952>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7953>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7954>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7955>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7956>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7957>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7958>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7959>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7960>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7961>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7962>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7963>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7964>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7965>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7966>"*/
define C-subtype <_GtkTextViewClass> (<C-void*>) end;
define constant <GtkTextViewClass> = <_GtkTextViewClass>;

define C-function gtk-text-view-get-type
  result res :: <GType>;
  c-name: "gtk_text_view_get_type";
end;

define C-function gtk-text-view-new
  result res :: <GtkWidget>;
  c-name: "gtk_text_view_new";
end;

define C-function gtk-text-view-new-with-buffer
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkWidget>;
  c-name: "gtk_text_view_new_with_buffer";
end;

define C-function gtk-text-view-set-buffer
  input parameter text_view :: <GtkTextView>;
  input parameter buffer :: <GtkTextBuffer>;
  c-name: "gtk_text_view_set_buffer";
end;

define C-function gtk-text-view-get-buffer
  input parameter text_view :: <GtkTextView>;
  result res :: <GtkTextBuffer>;
  c-name: "gtk_text_view_get_buffer";
end;

define C-function gtk-text-view-scroll-to-iter
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter within_margin :: <gdouble>;
  input parameter use_align :: <gboolean>;
  input parameter xalign :: <gdouble>;
  input parameter yalign :: <gdouble>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_scroll_to_iter";
end;

define C-function gtk-text-view-scroll-to-mark
  input parameter text_view :: <GtkTextView>;
  input parameter mark :: <GtkTextMark>;
  input parameter within_margin :: <gdouble>;
  input parameter use_align :: <gboolean>;
  input parameter xalign :: <gdouble>;
  input parameter yalign :: <gdouble>;
  c-name: "gtk_text_view_scroll_to_mark";
end;

define C-function gtk-text-view-scroll-mark-onscreen
  input parameter text_view :: <GtkTextView>;
  input parameter mark :: <GtkTextMark>;
  c-name: "gtk_text_view_scroll_mark_onscreen";
end;

define C-function gtk-text-view-move-mark-onscreen
  input parameter text_view :: <GtkTextView>;
  input parameter mark :: <GtkTextMark>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_move_mark_onscreen";
end;

define C-function gtk-text-view-place-cursor-onscreen
  input parameter text_view :: <GtkTextView>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_place_cursor_onscreen";
end;

define C-function gtk-text-view-get-visible-rect
  input parameter text_view :: <GtkTextView>;
  input parameter visible_rect :: <GdkRectangle>;
  c-name: "gtk_text_view_get_visible_rect";
end;

define C-function gtk-text-view-set-cursor-visible
  input parameter text_view :: <GtkTextView>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_text_view_set_cursor_visible";
end;

define C-function gtk-text-view-get-cursor-visible
  input parameter text_view :: <GtkTextView>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_get_cursor_visible";
end;

define C-function gtk-text-view-get-iter-location
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter location :: <GdkRectangle>;
  c-name: "gtk_text_view_get_iter_location";
end;

define C-function gtk-text-view-get-iter-at-location
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_text_view_get_iter_at_location";
end;

define C-function gtk-text-view-get-iter-at-position
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter trailing :: <gint*>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_text_view_get_iter_at_position";
end;

define C-function gtk-text-view-get-line-yrange
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter y :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "gtk_text_view_get_line_yrange";
end;

define C-function gtk-text-view-get-line-at-y
  input parameter text_view :: <GtkTextView>;
  input parameter target_iter :: <GtkTextIter>;
  input parameter y :: <gint>;
  input parameter line_top :: <gint*>;
  c-name: "gtk_text_view_get_line_at_y";
end;

define C-function gtk-text-view-buffer-to-window-coords
  input parameter text_view :: <GtkTextView>;
  input parameter win :: <GtkTextWindowType>;
  input parameter buffer_x :: <gint>;
  input parameter buffer_y :: <gint>;
  input parameter window_x :: <gint*>;
  input parameter window_y :: <gint*>;
  c-name: "gtk_text_view_buffer_to_window_coords";
end;

define C-function gtk-text-view-window-to-buffer-coords
  input parameter text_view :: <GtkTextView>;
  input parameter win :: <GtkTextWindowType>;
  input parameter window_x :: <gint>;
  input parameter window_y :: <gint>;
  input parameter buffer_x :: <gint*>;
  input parameter buffer_y :: <gint*>;
  c-name: "gtk_text_view_window_to_buffer_coords";
end;

define C-function gtk-text-view-get-window
  input parameter text_view :: <GtkTextView>;
  input parameter win :: <GtkTextWindowType>;
  result res :: <GdkWindow>;
  c-name: "gtk_text_view_get_window";
end;

define C-function gtk-text-view-get-window-type
  input parameter text_view :: <GtkTextView>;
  input parameter window :: <GdkWindow>;
  result res :: <GtkTextWindowType>;
  c-name: "gtk_text_view_get_window_type";
end;

define C-function gtk-text-view-set-border-window-size
  input parameter text_view :: <GtkTextView>;
  input parameter type :: <GtkTextWindowType>;
  input parameter size :: <gint>;
  c-name: "gtk_text_view_set_border_window_size";
end;

define C-function gtk-text-view-get-border-window-size
  input parameter text_view :: <GtkTextView>;
  input parameter type :: <GtkTextWindowType>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_border_window_size";
end;

define C-function gtk-text-view-forward-display-line
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_forward_display_line";
end;

define C-function gtk-text-view-backward-display-line
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_backward_display_line";
end;

define C-function gtk-text-view-forward-display-line-end
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_forward_display_line_end";
end;

define C-function gtk-text-view-backward-display-line-start
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_backward_display_line_start";
end;

define C-function gtk-text-view-starts-display-line
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_starts_display_line";
end;

define C-function gtk-text-view-move-visually
  input parameter text_view :: <GtkTextView>;
  input parameter iter :: <GtkTextIter>;
  input parameter count :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_move_visually";
end;

define C-function gtk-text-view-add-child-at-anchor
  input parameter text_view :: <GtkTextView>;
  input parameter child :: <GtkWidget>;
  input parameter anchor :: <GtkTextChildAnchor>;
  c-name: "gtk_text_view_add_child_at_anchor";
end;

define C-function gtk-text-view-add-child-in-window
  input parameter text_view :: <GtkTextView>;
  input parameter child :: <GtkWidget>;
  input parameter which_window :: <GtkTextWindowType>;
  input parameter xpos :: <gint>;
  input parameter ypos :: <gint>;
  c-name: "gtk_text_view_add_child_in_window";
end;

define C-function gtk-text-view-move-child
  input parameter text_view :: <GtkTextView>;
  input parameter child :: <GtkWidget>;
  input parameter xpos :: <gint>;
  input parameter ypos :: <gint>;
  c-name: "gtk_text_view_move_child";
end;

define C-function gtk-text-view-set-wrap-mode
  input parameter text_view :: <GtkTextView>;
  input parameter wrap_mode :: <GtkWrapMode>;
  c-name: "gtk_text_view_set_wrap_mode";
end;

define C-function gtk-text-view-get-wrap-mode
  input parameter text_view :: <GtkTextView>;
  result res :: <GtkWrapMode>;
  c-name: "gtk_text_view_get_wrap_mode";
end;

define C-function gtk-text-view-set-editable
  input parameter text_view :: <GtkTextView>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_text_view_set_editable";
end;

define C-function gtk-text-view-get-editable
  input parameter text_view :: <GtkTextView>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_get_editable";
end;

define C-function gtk-text-view-set-overwrite
  input parameter text_view :: <GtkTextView>;
  input parameter overwrite :: <gboolean>;
  c-name: "gtk_text_view_set_overwrite";
end;

define C-function gtk-text-view-get-overwrite
  input parameter text_view :: <GtkTextView>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_get_overwrite";
end;

define C-function gtk-text-view-set-accepts-tab
  input parameter text_view :: <GtkTextView>;
  input parameter accepts_tab :: <gboolean>;
  c-name: "gtk_text_view_set_accepts_tab";
end;

define C-function gtk-text-view-get-accepts-tab
  input parameter text_view :: <GtkTextView>;
  result res :: <gboolean>;
  c-name: "gtk_text_view_get_accepts_tab";
end;

define C-function gtk-text-view-set-pixels-above-lines
  input parameter text_view :: <GtkTextView>;
  input parameter pixels_above_lines :: <gint>;
  c-name: "gtk_text_view_set_pixels_above_lines";
end;

define C-function gtk-text-view-get-pixels-above-lines
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_pixels_above_lines";
end;

define C-function gtk-text-view-set-pixels-below-lines
  input parameter text_view :: <GtkTextView>;
  input parameter pixels_below_lines :: <gint>;
  c-name: "gtk_text_view_set_pixels_below_lines";
end;

define C-function gtk-text-view-get-pixels-below-lines
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_pixels_below_lines";
end;

define C-function gtk-text-view-set-pixels-inside-wrap
  input parameter text_view :: <GtkTextView>;
  input parameter pixels_inside_wrap :: <gint>;
  c-name: "gtk_text_view_set_pixels_inside_wrap";
end;

define C-function gtk-text-view-get-pixels-inside-wrap
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_pixels_inside_wrap";
end;

define C-function gtk-text-view-set-justification
  input parameter text_view :: <GtkTextView>;
  input parameter justification :: <GtkJustification>;
  c-name: "gtk_text_view_set_justification";
end;

define C-function gtk-text-view-get-justification
  input parameter text_view :: <GtkTextView>;
  result res :: <GtkJustification>;
  c-name: "gtk_text_view_get_justification";
end;

define C-function gtk-text-view-set-left-margin
  input parameter text_view :: <GtkTextView>;
  input parameter left_margin :: <gint>;
  c-name: "gtk_text_view_set_left_margin";
end;

define C-function gtk-text-view-get-left-margin
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_left_margin";
end;

define C-function gtk-text-view-set-right-margin
  input parameter text_view :: <GtkTextView>;
  input parameter right_margin :: <gint>;
  c-name: "gtk_text_view_set_right_margin";
end;

define C-function gtk-text-view-get-right-margin
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_right_margin";
end;

define C-function gtk-text-view-set-indent
  input parameter text_view :: <GtkTextView>;
  input parameter indent :: <gint>;
  c-name: "gtk_text_view_set_indent";
end;

define C-function gtk-text-view-get-indent
  input parameter text_view :: <GtkTextView>;
  result res :: <gint>;
  c-name: "gtk_text_view_get_indent";
end;

define C-function gtk-text-view-set-tabs
  input parameter text_view :: <GtkTextView>;
  input parameter tabs :: <PangoTabArray>;
  c-name: "gtk_text_view_set_tabs";
end;

define C-function gtk-text-view-get-tabs
  input parameter text_view :: <GtkTextView>;
  result res :: <PangoTabArray>;
  c-name: "gtk_text_view_get_tabs";
end;

define C-function gtk-text-view-get-default-attributes
  input parameter text_view :: <GtkTextView>;
  result res :: <GtkTextAttributes>;
  c-name: "gtk_text_view_get_default_attributes";
end;

define constant $GTK-TEXT-VIEW-PRIORITY-VALIDATE = 125;

define constant <GtkTextBufferTargetInfo> = limited(<integer>, min: -3, max: -1);
define constant $GTK-TEXT-BUFFER-TARGET-INFO-BUFFER-CONTENTS :: <GtkTextBufferTargetInfo> = -1;
define constant $GTK-TEXT-BUFFER-TARGET-INFO-RICH-TEXT :: <GtkTextBufferTargetInfo> = -2;
define constant $GTK-TEXT-BUFFER-TARGET-INFO-TEXT :: <GtkTextBufferTargetInfo> = -3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7841>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7842>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7843>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7844>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7845>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7846>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7847>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7848>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7849>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7850>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7851>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7852>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7853>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7854>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7855>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7856>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7857>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7858>"*/
define C-subtype <_GtkTextBufferClass> (<C-void*>) end;
define constant <GtkTextBufferClass> = <_GtkTextBufferClass>;

define C-function gtk-text-buffer-get-type
  result res :: <GType>;
  c-name: "gtk_text_buffer_get_type";
end;

define C-function gtk-text-buffer-new
  input parameter table :: <GtkTextTagTable>;
  result res :: <GtkTextBuffer>;
  c-name: "gtk_text_buffer_new";
end;

define C-function gtk-text-buffer-get-line-count
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gint>;
  c-name: "gtk_text_buffer_get_line_count";
end;

define C-function gtk-text-buffer-get-char-count
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gint>;
  c-name: "gtk_text_buffer_get_char_count";
end;

define C-function gtk-text-buffer-get-tag-table
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTextTagTable>;
  c-name: "gtk_text_buffer_get_tag_table";
end;

define C-function gtk-text-buffer-set-text
  input parameter buffer :: <GtkTextBuffer>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  c-name: "gtk_text_buffer_set_text";
end;

define C-function gtk-text-buffer-insert
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  c-name: "gtk_text_buffer_insert";
end;

define C-function gtk-text-buffer-insert-at-cursor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  c-name: "gtk_text_buffer_insert_at_cursor";
end;

define C-function gtk-text-buffer-insert-interactive
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_insert_interactive";
end;

define C-function gtk-text-buffer-insert-interactive-at-cursor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_insert_interactive_at_cursor";
end;

define C-function gtk-text-buffer-insert-range
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_insert_range";
end;

define C-function gtk-text-buffer-insert-range-interactive
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_insert_range_interactive";
end;

define C-function gtk-text-buffer-insert-with-tags
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  input parameter first_tag :: <GtkTextTag>;
  c-name: "gtk_text_buffer_insert_with_tags";
end;

define C-function gtk-text-buffer-insert-with-tags-by-name
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  input parameter first_tag_name :: <c-string>;
  c-name: "gtk_text_buffer_insert_with_tags_by_name";
end;

define C-function gtk-text-buffer-delete
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_delete";
end;

define C-function gtk-text-buffer-delete-interactive
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start_iter :: <GtkTextIter>;
  input parameter end_iter :: <GtkTextIter>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_delete_interactive";
end;

define C-function gtk-text-buffer-backspace
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter interactive :: <gboolean>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_backspace";
end;

define C-function gtk-text-buffer-get-text
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  input parameter include_hidden_chars :: <gboolean>;
  result res :: <c-string>;
  c-name: "gtk_text_buffer_get_text";
end;

define C-function gtk-text-buffer-get-slice
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  input parameter include_hidden_chars :: <gboolean>;
  result res :: <c-string>;
  c-name: "gtk_text_buffer_get_slice";
end;

define C-function gtk-text-buffer-insert-pixbuf
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_text_buffer_insert_pixbuf";
end;

define C-function gtk-text-buffer-insert-child-anchor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter anchor :: <GtkTextChildAnchor>;
  c-name: "gtk_text_buffer_insert_child_anchor";
end;

define C-function gtk-text-buffer-create-child-anchor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  result res :: <GtkTextChildAnchor>;
  c-name: "gtk_text_buffer_create_child_anchor";
end;

define C-function gtk-text-buffer-create-mark
  input parameter buffer :: <GtkTextBuffer>;
  input parameter mark_name :: <c-string>;
  input parameter where :: <GtkTextIter>;
  input parameter left_gravity :: <gboolean>;
  result res :: <GtkTextMark>;
  c-name: "gtk_text_buffer_create_mark";
end;

define C-function gtk-text-buffer-move-mark
  input parameter buffer :: <GtkTextBuffer>;
  input parameter mark :: <GtkTextMark>;
  input parameter where :: <GtkTextIter>;
  c-name: "gtk_text_buffer_move_mark";
end;

define C-function gtk-text-buffer-delete-mark
  input parameter buffer :: <GtkTextBuffer>;
  input parameter mark :: <GtkTextMark>;
  c-name: "gtk_text_buffer_delete_mark";
end;

define C-function gtk-text-buffer-get-mark
  input parameter buffer :: <GtkTextBuffer>;
  input parameter name :: <c-string>;
  result res :: <GtkTextMark>;
  c-name: "gtk_text_buffer_get_mark";
end;

define C-function gtk-text-buffer-move-mark-by-name
  input parameter buffer :: <GtkTextBuffer>;
  input parameter name :: <c-string>;
  input parameter where :: <GtkTextIter>;
  c-name: "gtk_text_buffer_move_mark_by_name";
end;

define C-function gtk-text-buffer-delete-mark-by-name
  input parameter buffer :: <GtkTextBuffer>;
  input parameter name :: <c-string>;
  c-name: "gtk_text_buffer_delete_mark_by_name";
end;

define C-function gtk-text-buffer-get-insert
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTextMark>;
  c-name: "gtk_text_buffer_get_insert";
end;

define C-function gtk-text-buffer-get-selection-bound
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTextMark>;
  c-name: "gtk_text_buffer_get_selection_bound";
end;

define C-function gtk-text-buffer-place-cursor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter where :: <GtkTextIter>;
  c-name: "gtk_text_buffer_place_cursor";
end;

define C-function gtk-text-buffer-select-range
  input parameter buffer :: <GtkTextBuffer>;
  input parameter ins :: <GtkTextIter>;
  input parameter bound :: <GtkTextIter>;
  c-name: "gtk_text_buffer_select_range";
end;

define C-function gtk-text-buffer-apply-tag
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tag :: <GtkTextTag>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_apply_tag";
end;

define C-function gtk-text-buffer-remove-tag
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tag :: <GtkTextTag>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_remove_tag";
end;

define C-function gtk-text-buffer-apply-tag-by-name
  input parameter buffer :: <GtkTextBuffer>;
  input parameter name :: <c-string>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_apply_tag_by_name";
end;

define C-function gtk-text-buffer-remove-tag-by-name
  input parameter buffer :: <GtkTextBuffer>;
  input parameter name :: <c-string>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_remove_tag_by_name";
end;

define C-function gtk-text-buffer-remove-all-tags
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_remove_all_tags";
end;

define C-function gtk-text-buffer-create-tag
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tag_name :: <c-string>;
  input parameter first_property_name :: <c-string>;
  result res :: <GtkTextTag>;
  c-name: "gtk_text_buffer_create_tag";
end;

define C-function gtk-text-buffer-get-iter-at-line-offset
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter line_number :: <gint>;
  input parameter char_offset :: <gint>;
  c-name: "gtk_text_buffer_get_iter_at_line_offset";
end;

define C-function gtk-text-buffer-get-iter-at-line-index
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter line_number :: <gint>;
  input parameter byte_index :: <gint>;
  c-name: "gtk_text_buffer_get_iter_at_line_index";
end;

define C-function gtk-text-buffer-get-iter-at-offset
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter char_offset :: <gint>;
  c-name: "gtk_text_buffer_get_iter_at_offset";
end;

define C-function gtk-text-buffer-get-iter-at-line
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter line_number :: <gint>;
  c-name: "gtk_text_buffer_get_iter_at_line";
end;

define C-function gtk-text-buffer-get-start-iter
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  c-name: "gtk_text_buffer_get_start_iter";
end;

define C-function gtk-text-buffer-get-end-iter
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  c-name: "gtk_text_buffer_get_end_iter";
end;

define C-function gtk-text-buffer-get-bounds
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  c-name: "gtk_text_buffer_get_bounds";
end;

define C-function gtk-text-buffer-get-iter-at-mark
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter mark :: <GtkTextMark>;
  c-name: "gtk_text_buffer_get_iter_at_mark";
end;

define C-function gtk-text-buffer-get-iter-at-child-anchor
  input parameter buffer :: <GtkTextBuffer>;
  input parameter iter :: <GtkTextIter>;
  input parameter anchor :: <GtkTextChildAnchor>;
  c-name: "gtk_text_buffer_get_iter_at_child_anchor";
end;

define C-function gtk-text-buffer-get-modified
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_get_modified";
end;

define C-function gtk-text-buffer-set-modified
  input parameter buffer :: <GtkTextBuffer>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_text_buffer_set_modified";
end;

define C-function gtk-text-buffer-get-has-selection
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_get_has_selection";
end;

define C-function gtk-text-buffer-add-selection-clipboard
  input parameter buffer :: <GtkTextBuffer>;
  input parameter clipboard :: <GtkClipboard>;
  c-name: "gtk_text_buffer_add_selection_clipboard";
end;

define C-function gtk-text-buffer-remove-selection-clipboard
  input parameter buffer :: <GtkTextBuffer>;
  input parameter clipboard :: <GtkClipboard>;
  c-name: "gtk_text_buffer_remove_selection_clipboard";
end;

define C-function gtk-text-buffer-cut-clipboard
  input parameter buffer :: <GtkTextBuffer>;
  input parameter clipboard :: <GtkClipboard>;
  input parameter default_editable :: <gboolean>;
  c-name: "gtk_text_buffer_cut_clipboard";
end;

define C-function gtk-text-buffer-copy-clipboard
  input parameter buffer :: <GtkTextBuffer>;
  input parameter clipboard :: <GtkClipboard>;
  c-name: "gtk_text_buffer_copy_clipboard";
end;

define C-function gtk-text-buffer-paste-clipboard
  input parameter buffer :: <GtkTextBuffer>;
  input parameter clipboard :: <GtkClipboard>;
  input parameter override_location :: <GtkTextIter>;
  input parameter default_editable :: <gboolean>;
  c-name: "gtk_text_buffer_paste_clipboard";
end;

define C-function gtk-text-buffer-get-selection-bounds
  input parameter buffer :: <GtkTextBuffer>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_get_selection_bounds";
end;

define C-function gtk-text-buffer-delete-selection
  input parameter buffer :: <GtkTextBuffer>;
  input parameter interactive :: <gboolean>;
  input parameter default_editable :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_delete_selection";
end;

define C-function gtk-text-buffer-begin-user-action
  input parameter buffer :: <GtkTextBuffer>;
  c-name: "gtk_text_buffer_begin_user_action";
end;

define C-function gtk-text-buffer-end-user-action
  input parameter buffer :: <GtkTextBuffer>;
  c-name: "gtk_text_buffer_end_user_action";
end;

define C-function gtk-text-buffer-get-copy-target-list
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTargetList>;
  c-name: "gtk_text_buffer_get_copy_target_list";
end;

define C-function gtk-text-buffer-get-paste-target-list
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTargetList>;
  c-name: "gtk_text_buffer_get_paste_target_list";
end;

define C-function _gtk-text-buffer-spew
  input parameter buffer :: <GtkTextBuffer>;
  c-name: "_gtk_text_buffer_spew";
end;

define C-function _gtk-text-buffer-get-btree
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <GtkTextBTree>;
  c-name: "_gtk_text_buffer_get_btree";
end;

define C-function _gtk-text-buffer-get-line-log-attrs
  input parameter buffer :: <GtkTextBuffer>;
  input parameter anywhere_in_line :: <GtkTextIter>;
  input parameter char_len :: <gint*>;
  result res :: <PangoLogAttr>;
  c-name: "_gtk_text_buffer_get_line_log_attrs";
end;

define C-function _gtk-text-buffer-notify-will-remove-tag
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tag :: <GtkTextTag>;
  c-name: "_gtk_text_buffer_notify_will_remove_tag";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7827>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7828>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7829>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7830>"*/
define C-subtype <_GtkTextMarkClass> (<C-void*>) end;
define constant <GtkTextMarkClass> = <_GtkTextMarkClass>;

define C-function gtk-text-mark-get-type
  result res :: <GType>;
  c-name: "gtk_text_mark_get_type";
end;

define C-function gtk-text-mark-set-visible
  input parameter mark :: <GtkTextMark>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_text_mark_set_visible";
end;

define C-function gtk-text-mark-get-visible
  input parameter mark :: <GtkTextMark>;
  result res :: <gboolean>;
  c-name: "gtk_text_mark_get_visible";
end;

define C-function gtk-text-mark-get-name
  input parameter mark :: <GtkTextMark>;
  result res :: <c-string>;
  c-name: "gtk_text_mark_get_name";
end;

define C-function gtk-text-mark-get-deleted
  input parameter mark :: <GtkTextMark>;
  result res :: <gboolean>;
  c-name: "gtk_text_mark_get_deleted";
end;

define C-function gtk-text-mark-get-buffer
  input parameter mark :: <GtkTextMark>;
  result res :: <GtkTextBuffer>;
  c-name: "gtk_text_mark_get_buffer";
end;

define C-function gtk-text-mark-get-left-gravity
  input parameter mark :: <GtkTextMark>;
  result res :: <gboolean>;
  c-name: "gtk_text_mark_get_left_gravity";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7810>"*/
define constant <GtkTextTagTableForeach> = <anonymous-7810>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7811>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7812>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7813>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7814>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7815>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7816>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7817>"*/
define C-subtype <_GtkTextTagTableClass> (<C-void*>) end;
define constant <GtkTextTagTableClass> = <_GtkTextTagTableClass>;

define C-function gtk-text-tag-table-get-type
  result res :: <GType>;
  c-name: "gtk_text_tag_table_get_type";
end;

define C-function gtk-text-tag-table-new
  result res :: <GtkTextTagTable>;
  c-name: "gtk_text_tag_table_new";
end;

define C-function gtk-text-tag-table-add
  input parameter table :: <GtkTextTagTable>;
  input parameter tag :: <GtkTextTag>;
  c-name: "gtk_text_tag_table_add";
end;

define C-function gtk-text-tag-table-remove
  input parameter table :: <GtkTextTagTable>;
  input parameter tag :: <GtkTextTag>;
  c-name: "gtk_text_tag_table_remove";
end;

define C-function gtk-text-tag-table-lookup
  input parameter table :: <GtkTextTagTable>;
  input parameter name :: <c-string>;
  result res :: <GtkTextTag>;
  c-name: "gtk_text_tag_table_lookup";
end;

define C-function gtk-text-tag-table-foreach
  input parameter table :: <GtkTextTagTable>;
  input parameter func :: <GtkTextTagTableForeach>;
  input parameter data :: <gpointer>;
  c-name: "gtk_text_tag_table_foreach";
end;

define C-function gtk-text-tag-table-get-size
  input parameter table :: <GtkTextTagTable>;
  result res :: <gint>;
  c-name: "gtk_text_tag_table_get_size";
end;

define C-function _gtk-text-tag-table-add-buffer
  input parameter table :: <GtkTextTagTable>;
  input parameter buffer :: <gpointer>;
  c-name: "_gtk_text_tag_table_add_buffer";
end;

define C-function _gtk-text-tag-table-remove-buffer
  input parameter table :: <GtkTextTagTable>;
  input parameter buffer :: <gpointer>;
  c-name: "_gtk_text_tag_table_remove_buffer";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5562>"*/
define constant <GtkClipboardReceivedFunc> = <anonymous-5562>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5563>"*/
define constant <GtkClipboardTextReceivedFunc> = <anonymous-5563>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5564>"*/
define constant <GtkClipboardRichTextReceivedFunc> = <anonymous-5564>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5565>"*/
define constant <GtkClipboardImageReceivedFunc> = <anonymous-5565>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5566>"*/
define constant <GtkClipboardTargetsReceivedFunc> = <anonymous-5566>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5567>"*/
define constant <GtkClipboardGetFunc> = <anonymous-5567>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5568>"*/
define constant <GtkClipboardClearFunc> = <anonymous-5568>;

define C-function gtk-clipboard-get-type
  result res :: <GType>;
  c-name: "gtk_clipboard_get_type";
end;

define C-function gtk-clipboard-get-for-display
  input parameter display :: <GdkDisplay>;
  input parameter selection :: <GdkAtom>;
  result res :: <GtkClipboard>;
  c-name: "gtk_clipboard_get_for_display";
end;

define C-function gtk-clipboard-get
  input parameter selection :: <GdkAtom>;
  result res :: <GtkClipboard>;
  c-name: "gtk_clipboard_get";
end;

define C-function gtk-clipboard-get-display
  input parameter clipboard :: <GtkClipboard>;
  result res :: <GdkDisplay>;
  c-name: "gtk_clipboard_get_display";
end;

define C-function gtk-clipboard-set-with-data
  input parameter clipboard :: <GtkClipboard>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <guint>;
  input parameter get_func :: <GtkClipboardGetFunc>;
  input parameter clear_func :: <GtkClipboardClearFunc>;
  input parameter user_data :: <gpointer>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_set_with_data";
end;

define C-function gtk-clipboard-set-with-owner
  input parameter clipboard :: <GtkClipboard>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <guint>;
  input parameter get_func :: <GtkClipboardGetFunc>;
  input parameter clear_func :: <GtkClipboardClearFunc>;
  input parameter owner :: <GObject>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_set_with_owner";
end;

define C-function gtk-clipboard-get-owner
  input parameter clipboard :: <GtkClipboard>;
  result res :: <GObject>;
  c-name: "gtk_clipboard_get_owner";
end;

define C-function gtk-clipboard-clear
  input parameter clipboard :: <GtkClipboard>;
  c-name: "gtk_clipboard_clear";
end;

define C-function gtk-clipboard-set-text
  input parameter clipboard :: <GtkClipboard>;
  input parameter text :: <c-string>;
  input parameter len :: <gint>;
  c-name: "gtk_clipboard_set_text";
end;

define C-function gtk-clipboard-set-image
  input parameter clipboard :: <GtkClipboard>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_clipboard_set_image";
end;

define C-function gtk-clipboard-request-contents
  input parameter clipboard :: <GtkClipboard>;
  input parameter target :: <GdkAtom>;
  input parameter callback :: <GtkClipboardReceivedFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_clipboard_request_contents";
end;

define C-function gtk-clipboard-request-text
  input parameter clipboard :: <GtkClipboard>;
  input parameter callback :: <GtkClipboardTextReceivedFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_clipboard_request_text";
end;

define C-function gtk-clipboard-request-rich-text
  input parameter clipboard :: <GtkClipboard>;
  input parameter buffer :: <GtkTextBuffer>;
  input parameter callback :: <GtkClipboardRichTextReceivedFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_clipboard_request_rich_text";
end;

define C-function gtk-clipboard-request-image
  input parameter clipboard :: <GtkClipboard>;
  input parameter callback :: <GtkClipboardImageReceivedFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_clipboard_request_image";
end;

define C-function gtk-clipboard-request-targets
  input parameter clipboard :: <GtkClipboard>;
  input parameter callback :: <GtkClipboardTargetsReceivedFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_clipboard_request_targets";
end;

define C-function gtk-clipboard-wait-for-contents
  input parameter clipboard :: <GtkClipboard>;
  input parameter target :: <GdkAtom>;
  result res :: <GtkSelectionData>;
  c-name: "gtk_clipboard_wait_for_contents";
end;

define C-function gtk-clipboard-wait-for-text
  input parameter clipboard :: <GtkClipboard>;
  result res :: <c-string>;
  c-name: "gtk_clipboard_wait_for_text";
end;

define C-function gtk-clipboard-wait-for-rich-text
  input parameter clipboard :: <GtkClipboard>;
  input parameter buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom*>;
  input parameter length :: <gsize*>;
  result res :: <guint8*>;
  c-name: "gtk_clipboard_wait_for_rich_text";
end;

define C-function gtk-clipboard-wait-for-image
  input parameter clipboard :: <GtkClipboard>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_clipboard_wait_for_image";
end;

define C-function gtk-clipboard-wait-for-targets
  input parameter clipboard :: <GtkClipboard>;
  input parameter targets :: <GdkAtom**>;
  input parameter n_targets :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_wait_for_targets";
end;

define C-function gtk-clipboard-wait-is-text-available
  input parameter clipboard :: <GtkClipboard>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_wait_is_text_available";
end;

define C-function gtk-clipboard-wait-is-rich-text-available
  input parameter clipboard :: <GtkClipboard>;
  input parameter buffer :: <GtkTextBuffer>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_wait_is_rich_text_available";
end;

define C-function gtk-clipboard-wait-is-image-available
  input parameter clipboard :: <GtkClipboard>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_wait_is_image_available";
end;

define C-function gtk-clipboard-wait-is-target-available
  input parameter clipboard :: <GtkClipboard>;
  input parameter target :: <GdkAtom>;
  result res :: <gboolean>;
  c-name: "gtk_clipboard_wait_is_target_available";
end;

define C-function gtk-clipboard-set-can-store
  input parameter clipboard :: <GtkClipboard>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  c-name: "gtk_clipboard_set_can_store";
end;

define C-function gtk-clipboard-store
  input parameter clipboard :: <GtkClipboard>;
  c-name: "gtk_clipboard_store";
end;

define C-function _gtk-clipboard-handle-event
  input parameter event :: <GdkEventOwnerChange>;
  c-name: "_gtk_clipboard_handle_event";
end;

define C-function _gtk-clipboard-store-all
  c-name: "_gtk_clipboard_store_all";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7924>"*/
define constant <GtkTextBufferSerializeFunc> = <anonymous-7924>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7925>"*/
define constant <GtkTextBufferDeserializeFunc> = <anonymous-7925>;

define C-function gtk-text-buffer-register-serialize-format
  input parameter buffer :: <GtkTextBuffer>;
  input parameter mime_type :: <c-string>;
  input parameter function :: <GtkTextBufferSerializeFunc>;
  input parameter user_data :: <gpointer>;
  input parameter user_data_destroy :: <GDestroyNotify>;
  result res :: <GdkAtom>;
  c-name: "gtk_text_buffer_register_serialize_format";
end;

define C-function gtk-text-buffer-register-serialize-tagset
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tagset_name :: <c-string>;
  result res :: <GdkAtom>;
  c-name: "gtk_text_buffer_register_serialize_tagset";
end;

define C-function gtk-text-buffer-register-deserialize-format
  input parameter buffer :: <GtkTextBuffer>;
  input parameter mime_type :: <c-string>;
  input parameter function :: <GtkTextBufferDeserializeFunc>;
  input parameter user_data :: <gpointer>;
  input parameter user_data_destroy :: <GDestroyNotify>;
  result res :: <GdkAtom>;
  c-name: "gtk_text_buffer_register_deserialize_format";
end;

define C-function gtk-text-buffer-register-deserialize-tagset
  input parameter buffer :: <GtkTextBuffer>;
  input parameter tagset_name :: <c-string>;
  result res :: <GdkAtom>;
  c-name: "gtk_text_buffer_register_deserialize_tagset";
end;

define C-function gtk-text-buffer-unregister-serialize-format
  input parameter buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  c-name: "gtk_text_buffer_unregister_serialize_format";
end;

define C-function gtk-text-buffer-unregister-deserialize-format
  input parameter buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  c-name: "gtk_text_buffer_unregister_deserialize_format";
end;

define C-function gtk-text-buffer-deserialize-set-can-create-tags
  input parameter buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  input parameter can_create_tags :: <gboolean>;
  c-name: "gtk_text_buffer_deserialize_set_can_create_tags";
end;

define C-function gtk-text-buffer-deserialize-get-can-create-tags
  input parameter buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_deserialize_get_can_create_tags";
end;

define C-function gtk-text-buffer-get-serialize-formats
  input parameter buffer :: <GtkTextBuffer>;
  input parameter n_formats :: <gint*>;
  result res :: <GdkAtom*>;
  c-name: "gtk_text_buffer_get_serialize_formats";
end;

define C-function gtk-text-buffer-get-deserialize-formats
  input parameter buffer :: <GtkTextBuffer>;
  input parameter n_formats :: <gint*>;
  result res :: <GdkAtom*>;
  c-name: "gtk_text_buffer_get_deserialize_formats";
end;

define C-function gtk-text-buffer-serialize
  input parameter register_buffer :: <GtkTextBuffer>;
  input parameter content_buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  input parameter start :: <GtkTextIter>;
  input parameter end :: <GtkTextIter>;
  input parameter length :: <gsize*>;
  result res :: <guint8*>;
  c-name: "gtk_text_buffer_serialize";
end;

define C-function gtk-text-buffer-deserialize
  input parameter register_buffer :: <GtkTextBuffer>;
  input parameter content_buffer :: <GtkTextBuffer>;
  input parameter format :: <GdkAtom>;
  input parameter iter :: <GtkTextIter>;
  input parameter data :: <guint8*>;
  input parameter length :: <gsize>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_text_buffer_deserialize";
end;

define C-subtype <_GtkTearoffMenuItem> (<GtkMenuItem>, <AtkImplementorIface>) end;
define constant <GtkTearoffMenuItem> = <_GtkTearoffMenuItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7804>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7805>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7806>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7807>"*/
define C-subtype <_GtkTearoffMenuItemClass> (<C-void*>) end;
define constant <GtkTearoffMenuItemClass> = <_GtkTearoffMenuItemClass>;

define C-function gtk-tearoff-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_tearoff_menu_item_get_type";
end;

define C-function gtk-tearoff-menu-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_tearoff_menu_item_new";
end;

define C-subtype <_GtkTableRowCol> (<C-void*>) end;
define constant <GtkTableRowCol> = <_GtkTableRowCol>;

define C-subtype <_GtkTable> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkTable> = <_GtkTable>;

define C-subtype <_GtkTableClass> (<C-void*>) end;
define constant <GtkTableClass> = <_GtkTableClass>;

define C-subtype <_GtkTableChild> (<C-void*>) end;
define constant <GtkTableChild> = <_GtkTableChild>;

define C-function gtk-table-get-type
  result res :: <GType>;
  c-name: "gtk_table_get_type";
end;

define C-function gtk-table-new
  input parameter rows :: <guint>;
  input parameter columns :: <guint>;
  input parameter homogeneous :: <gboolean>;
  result res :: <GtkWidget>;
  c-name: "gtk_table_new";
end;

define C-function gtk-table-resize
  input parameter table :: <GtkTable>;
  input parameter rows :: <guint>;
  input parameter columns :: <guint>;
  c-name: "gtk_table_resize";
end;

define C-function gtk-table-attach
  input parameter table :: <GtkTable>;
  input parameter child :: <GtkWidget>;
  input parameter left_attach :: <guint>;
  input parameter right_attach :: <guint>;
  input parameter top_attach :: <guint>;
  input parameter bottom_attach :: <guint>;
  input parameter xoptions :: <GtkAttachOptions>;
  input parameter yoptions :: <GtkAttachOptions>;
  input parameter xpadding :: <guint>;
  input parameter ypadding :: <guint>;
  c-name: "gtk_table_attach";
end;

define C-function gtk-table-attach-defaults
  input parameter table :: <GtkTable>;
  input parameter widget :: <GtkWidget>;
  input parameter left_attach :: <guint>;
  input parameter right_attach :: <guint>;
  input parameter top_attach :: <guint>;
  input parameter bottom_attach :: <guint>;
  c-name: "gtk_table_attach_defaults";
end;

define C-function gtk-table-set-row-spacing
  input parameter table :: <GtkTable>;
  input parameter row :: <guint>;
  input parameter spacing :: <guint>;
  c-name: "gtk_table_set_row_spacing";
end;

define C-function gtk-table-get-row-spacing
  input parameter table :: <GtkTable>;
  input parameter row :: <guint>;
  result res :: <guint>;
  c-name: "gtk_table_get_row_spacing";
end;

define C-function gtk-table-set-col-spacing
  input parameter table :: <GtkTable>;
  input parameter column :: <guint>;
  input parameter spacing :: <guint>;
  c-name: "gtk_table_set_col_spacing";
end;

define C-function gtk-table-get-col-spacing
  input parameter table :: <GtkTable>;
  input parameter column :: <guint>;
  result res :: <guint>;
  c-name: "gtk_table_get_col_spacing";
end;

define C-function gtk-table-set-row-spacings
  input parameter table :: <GtkTable>;
  input parameter spacing :: <guint>;
  c-name: "gtk_table_set_row_spacings";
end;

define C-function gtk-table-get-default-row-spacing
  input parameter table :: <GtkTable>;
  result res :: <guint>;
  c-name: "gtk_table_get_default_row_spacing";
end;

define C-function gtk-table-set-col-spacings
  input parameter table :: <GtkTable>;
  input parameter spacing :: <guint>;
  c-name: "gtk_table_set_col_spacings";
end;

define C-function gtk-table-get-default-col-spacing
  input parameter table :: <GtkTable>;
  result res :: <guint>;
  c-name: "gtk_table_get_default_col_spacing";
end;

define C-function gtk-table-set-homogeneous
  input parameter table :: <GtkTable>;
  input parameter homogeneous :: <gboolean>;
  c-name: "gtk_table_set_homogeneous";
end;

define C-function gtk-table-get-homogeneous
  input parameter table :: <GtkTable>;
  result res :: <gboolean>;
  c-name: "gtk_table_get_homogeneous";
end;

define C-subtype <_GtkStockItem> (<C-void*>) end;
define constant <GtkStockItem> = <_GtkStockItem>;

define C-function gtk-stock-add
  input parameter items :: <GtkStockItem>;
  input parameter n_items :: <guint>;
  c-name: "gtk_stock_add";
end;

define C-function gtk-stock-add-static
  input parameter items :: <GtkStockItem>;
  input parameter n_items :: <guint>;
  c-name: "gtk_stock_add_static";
end;

define C-function gtk-stock-lookup
  input parameter stock_id :: <c-string>;
  input parameter item :: <GtkStockItem>;
  result res :: <gboolean>;
  c-name: "gtk_stock_lookup";
end;

define C-function gtk-stock-list-ids
  result res :: <GSList>;
  c-name: "gtk_stock_list_ids";
end;

define C-function gtk-stock-item-copy
  input parameter item :: <GtkStockItem>;
  result res :: <GtkStockItem>;
  c-name: "gtk_stock_item_copy";
end;

define C-function gtk-stock-item-free
  input parameter item :: <GtkStockItem>;
  c-name: "gtk_stock_item_free";
end;

define C-function gtk-stock-set-translate-func
  input parameter domain :: <c-string>;
  input parameter func :: <GtkTranslateFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GtkDestroyNotify>;
  c-name: "gtk_stock_set_translate_func";
end;

define constant $GTK-STOCK-DIALOG-AUTHENTICATION = "gtk-dialog-authentication";

define constant $GTK-STOCK-DIALOG-INFO = "gtk-dialog-info";

define constant $GTK-STOCK-DIALOG-WARNING = "gtk-dialog-warning";

define constant $GTK-STOCK-DIALOG-ERROR = "gtk-dialog-error";

define constant $GTK-STOCK-DIALOG-QUESTION = "gtk-dialog-question";

define constant $GTK-STOCK-DND = "gtk-dnd";

define constant $GTK-STOCK-DND-MULTIPLE = "gtk-dnd-multiple";

define constant $GTK-STOCK-ABOUT = "gtk-about";

define constant $GTK-STOCK-ADD = "gtk-add";

define constant $GTK-STOCK-APPLY = "gtk-apply";

define constant $GTK-STOCK-BOLD = "gtk-bold";

define constant $GTK-STOCK-CANCEL = "gtk-cancel";

define constant $GTK-STOCK-CDROM = "gtk-cdrom";

define constant $GTK-STOCK-CLEAR = "gtk-clear";

define constant $GTK-STOCK-CLOSE = "gtk-close";

define constant $GTK-STOCK-COLOR-PICKER = "gtk-color-picker";

define constant $GTK-STOCK-CONVERT = "gtk-convert";

define constant $GTK-STOCK-CONNECT = "gtk-connect";

define constant $GTK-STOCK-COPY = "gtk-copy";

define constant $GTK-STOCK-CUT = "gtk-cut";

define constant $GTK-STOCK-DELETE = "gtk-delete";

define constant $GTK-STOCK-DIRECTORY = "gtk-directory";

define constant $GTK-STOCK-DISCONNECT = "gtk-disconnect";

define constant $GTK-STOCK-EDIT = "gtk-edit";

define constant $GTK-STOCK-EXECUTE = "gtk-execute";

define constant $GTK-STOCK-FILE = "gtk-file";

define constant $GTK-STOCK-FIND = "gtk-find";

define constant $GTK-STOCK-FIND-AND-REPLACE = "gtk-find-and-replace";

define constant $GTK-STOCK-FLOPPY = "gtk-floppy";

define constant $GTK-STOCK-FULLSCREEN = "gtk-fullscreen";

define constant $GTK-STOCK-GOTO-BOTTOM = "gtk-goto-bottom";

define constant $GTK-STOCK-GOTO-FIRST = "gtk-goto-first";

define constant $GTK-STOCK-GOTO-LAST = "gtk-goto-last";

define constant $GTK-STOCK-GOTO-TOP = "gtk-goto-top";

define constant $GTK-STOCK-GO-BACK = "gtk-go-back";

define constant $GTK-STOCK-GO-DOWN = "gtk-go-down";

define constant $GTK-STOCK-GO-FORWARD = "gtk-go-forward";

define constant $GTK-STOCK-GO-UP = "gtk-go-up";

define constant $GTK-STOCK-HARDDISK = "gtk-harddisk";

define constant $GTK-STOCK-HELP = "gtk-help";

define constant $GTK-STOCK-HOME = "gtk-home";

define constant $GTK-STOCK-INDEX = "gtk-index";

define constant $GTK-STOCK-INDENT = "gtk-indent";

define constant $GTK-STOCK-INFO = "gtk-info";

define constant $GTK-STOCK-UNINDENT = "gtk-unindent";

define constant $GTK-STOCK-ITALIC = "gtk-italic";

define constant $GTK-STOCK-JUMP-TO = "gtk-jump-to";

define constant $GTK-STOCK-JUSTIFY-CENTER = "gtk-justify-center";

define constant $GTK-STOCK-JUSTIFY-FILL = "gtk-justify-fill";

define constant $GTK-STOCK-JUSTIFY-LEFT = "gtk-justify-left";

define constant $GTK-STOCK-JUSTIFY-RIGHT = "gtk-justify-right";

define constant $GTK-STOCK-LEAVE-FULLSCREEN = "gtk-leave-fullscreen";

define constant $GTK-STOCK-MISSING-IMAGE = "gtk-missing-image";

define constant $GTK-STOCK-MEDIA-FORWARD = "gtk-media-forward";

define constant $GTK-STOCK-MEDIA-NEXT = "gtk-media-next";

define constant $GTK-STOCK-MEDIA-PAUSE = "gtk-media-pause";

define constant $GTK-STOCK-MEDIA-PLAY = "gtk-media-play";

define constant $GTK-STOCK-MEDIA-PREVIOUS = "gtk-media-previous";

define constant $GTK-STOCK-MEDIA-RECORD = "gtk-media-record";

define constant $GTK-STOCK-MEDIA-REWIND = "gtk-media-rewind";

define constant $GTK-STOCK-MEDIA-STOP = "gtk-media-stop";

define constant $GTK-STOCK-NETWORK = "gtk-network";

define constant $GTK-STOCK-NEW = "gtk-new";

define constant $GTK-STOCK-NO = "gtk-no";

define constant $GTK-STOCK-OK = "gtk-ok";

define constant $GTK-STOCK-OPEN = "gtk-open";

define constant $GTK-STOCK-ORIENTATION-PORTRAIT = "gtk-orientation-portrait";

define constant $GTK-STOCK-ORIENTATION-LANDSCAPE = "gtk-orientation-landscape";

define constant $GTK-STOCK-ORIENTATION-REVERSE-LANDSCAPE = "gtk-orientation-reverse-landscape";

define constant $GTK-STOCK-ORIENTATION-REVERSE-PORTRAIT = "gtk-orientation-reverse-portrait";

define constant $GTK-STOCK-PASTE = "gtk-paste";

define constant $GTK-STOCK-PREFERENCES = "gtk-preferences";

define constant $GTK-STOCK-PRINT = "gtk-print";

define constant $GTK-STOCK-PRINT-PREVIEW = "gtk-print-preview";

define constant $GTK-STOCK-PROPERTIES = "gtk-properties";

define constant $GTK-STOCK-QUIT = "gtk-quit";

define constant $GTK-STOCK-REDO = "gtk-redo";

define constant $GTK-STOCK-REFRESH = "gtk-refresh";

define constant $GTK-STOCK-REMOVE = "gtk-remove";

define constant $GTK-STOCK-REVERT-TO-SAVED = "gtk-revert-to-saved";

define constant $GTK-STOCK-SAVE = "gtk-save";

define constant $GTK-STOCK-SAVE-AS = "gtk-save-as";

define constant $GTK-STOCK-SELECT-ALL = "gtk-select-all";

define constant $GTK-STOCK-SELECT-COLOR = "gtk-select-color";

define constant $GTK-STOCK-SELECT-FONT = "gtk-select-font";

define constant $GTK-STOCK-SORT-ASCENDING = "gtk-sort-ascending";

define constant $GTK-STOCK-SORT-DESCENDING = "gtk-sort-descending";

define constant $GTK-STOCK-SPELL-CHECK = "gtk-spell-check";

define constant $GTK-STOCK-STOP = "gtk-stop";

define constant $GTK-STOCK-STRIKETHROUGH = "gtk-strikethrough";

define constant $GTK-STOCK-UNDELETE = "gtk-undelete";

define constant $GTK-STOCK-UNDERLINE = "gtk-underline";

define constant $GTK-STOCK-UNDO = "gtk-undo";

define constant $GTK-STOCK-YES = "gtk-yes";

define constant $GTK-STOCK-ZOOM-100 = "gtk-zoom-100";

define constant $GTK-STOCK-ZOOM-FIT = "gtk-zoom-fit";

define constant $GTK-STOCK-ZOOM-IN = "gtk-zoom-in";

define constant $GTK-STOCK-ZOOM-OUT = "gtk-zoom-out";

define C-subtype <_GtkStatusIconPrivate> (<C-void*>) end;
define constant <GtkStatusIconPrivate> = <_GtkStatusIconPrivate>;

define C-subtype <_GtkStatusIcon> (<C-void*>) end;
define constant <GtkStatusIcon> = <_GtkStatusIcon>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7743>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7744>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7745>"*/
define C-subtype <_GtkStatusIconClass> (<C-void*>) end;
define constant <GtkStatusIconClass> = <_GtkStatusIconClass>;

define C-function gtk-status-icon-get-type
  result res :: <GType>;
  c-name: "gtk_status_icon_get_type";
end;

define C-function gtk-status-icon-new
  result res :: <GtkStatusIcon>;
  c-name: "gtk_status_icon_new";
end;

define C-function gtk-status-icon-new-from-pixbuf
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GtkStatusIcon>;
  c-name: "gtk_status_icon_new_from_pixbuf";
end;

define C-function gtk-status-icon-new-from-file
  input parameter filename :: <c-string>;
  result res :: <GtkStatusIcon>;
  c-name: "gtk_status_icon_new_from_file";
end;

define C-function gtk-status-icon-new-from-stock
  input parameter stock_id :: <c-string>;
  result res :: <GtkStatusIcon>;
  c-name: "gtk_status_icon_new_from_stock";
end;

define C-function gtk-status-icon-new-from-icon-name
  input parameter icon_name :: <c-string>;
  result res :: <GtkStatusIcon>;
  c-name: "gtk_status_icon_new_from_icon_name";
end;

define C-function gtk-status-icon-set-from-pixbuf
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_status_icon_set_from_pixbuf";
end;

define C-function gtk-status-icon-set-from-file
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter filename :: <c-string>;
  c-name: "gtk_status_icon_set_from_file";
end;

define C-function gtk-status-icon-set-from-stock
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter stock_id :: <c-string>;
  c-name: "gtk_status_icon_set_from_stock";
end;

define C-function gtk-status-icon-set-from-icon-name
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter icon_name :: <c-string>;
  c-name: "gtk_status_icon_set_from_icon_name";
end;

define C-function gtk-status-icon-get-storage-type
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <GtkImageType>;
  c-name: "gtk_status_icon_get_storage_type";
end;

define C-function gtk-status-icon-get-pixbuf
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_status_icon_get_pixbuf";
end;

define C-function gtk-status-icon-get-stock
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <c-string>;
  c-name: "gtk_status_icon_get_stock";
end;

define C-function gtk-status-icon-get-icon-name
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <c-string>;
  c-name: "gtk_status_icon_get_icon_name";
end;

define C-function gtk-status-icon-get-size
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <gint>;
  c-name: "gtk_status_icon_get_size";
end;

define C-function gtk-status-icon-set-tooltip
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter tooltip_text :: <c-string>;
  c-name: "gtk_status_icon_set_tooltip";
end;

define C-function gtk-status-icon-set-visible
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_status_icon_set_visible";
end;

define C-function gtk-status-icon-get-visible
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <gboolean>;
  c-name: "gtk_status_icon_get_visible";
end;

define C-function gtk-status-icon-set-blinking
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter blinking :: <gboolean>;
  c-name: "gtk_status_icon_set_blinking";
end;

define C-function gtk-status-icon-get-blinking
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <gboolean>;
  c-name: "gtk_status_icon_get_blinking";
end;

define C-function gtk-status-icon-is-embedded
  input parameter status_icon :: <GtkStatusIcon>;
  result res :: <gboolean>;
  c-name: "gtk_status_icon_is_embedded";
end;

define C-function gtk-status-icon-position-menu
  input parameter menu :: <GtkMenu>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter push_in :: <gboolean*>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_status_icon_position_menu";
end;

define C-pointer-type <GtkOrientation*> => <GtkOrientation>;
define C-function gtk-status-icon-get-geometry
  input parameter status_icon :: <GtkStatusIcon>;
  input parameter screen :: <GdkScreen*>;
  input parameter area :: <GdkRectangle>;
  input parameter orientation :: <GtkOrientation*>;
  result res :: <gboolean>;
  c-name: "gtk_status_icon_get_geometry";
end;

define C-subtype <_GtkHBox> (<GtkBox>, <AtkImplementorIface>) end;
define constant <GtkHBox> = <_GtkHBox>;

define C-subtype <_GtkStatusbar> (<GtkHBox>, <AtkImplementorIface>) end;
define constant <GtkStatusbar> = <_GtkStatusbar>;

define C-subtype <_GtkHBoxClass> (<C-void*>) end;
define constant <GtkHBoxClass> = <_GtkHBoxClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7729>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7730>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7731>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7732>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7733>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7734>"*/
define C-subtype <_GtkStatusbarClass> (<C-void*>) end;
define constant <GtkStatusbarClass> = <_GtkStatusbarClass>;

define C-function gtk-statusbar-get-type
  result res :: <GType>;
  c-name: "gtk_statusbar_get_type";
end;

define C-function gtk-statusbar-new
  result res :: <GtkWidget>;
  c-name: "gtk_statusbar_new";
end;

define C-function gtk-statusbar-get-context-id
  input parameter statusbar :: <GtkStatusbar>;
  input parameter context_description :: <c-string>;
  result res :: <guint>;
  c-name: "gtk_statusbar_get_context_id";
end;

define C-function gtk-statusbar-push
  input parameter statusbar :: <GtkStatusbar>;
  input parameter context_id :: <guint>;
  input parameter text :: <c-string>;
  result res :: <guint>;
  c-name: "gtk_statusbar_push";
end;

define C-function gtk-statusbar-pop
  input parameter statusbar :: <GtkStatusbar>;
  input parameter context_id :: <guint>;
  c-name: "gtk_statusbar_pop";
end;

define C-function gtk-statusbar-remove
  input parameter statusbar :: <GtkStatusbar>;
  input parameter context_id :: <guint>;
  input parameter message_id :: <guint>;
  c-name: "gtk_statusbar_remove";
end;

define C-function gtk-statusbar-set-has-resize-grip
  input parameter statusbar :: <GtkStatusbar>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_statusbar_set_has_resize_grip";
end;

define C-function gtk-statusbar-get-has-resize-grip
  input parameter statusbar :: <GtkStatusbar>;
  result res :: <gboolean>;
  c-name: "gtk_statusbar_get_has_resize_grip";
end;

define C-function gtk-hbox-get-type
  result res :: <GType>;
  c-name: "gtk_hbox_get_type";
end;

define C-function gtk-hbox-new
  input parameter homogeneous :: <gboolean>;
  input parameter spacing :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_hbox_new";
end;

define constant <GtkSpinButtonUpdatePolicy> = limited(<integer>, min: 0, max: 1);
define constant $GTK-UPDATE-ALWAYS :: <GtkSpinButtonUpdatePolicy> = 0;
define constant $GTK-UPDATE-IF-VALID :: <GtkSpinButtonUpdatePolicy> = 1;

define constant <GtkSpinType> = limited(<integer>, min: 0, max: 6);
define constant $GTK-SPIN-STEP-FORWARD :: <GtkSpinType> = 0;
define constant $GTK-SPIN-STEP-BACKWARD :: <GtkSpinType> = 1;
define constant $GTK-SPIN-PAGE-FORWARD :: <GtkSpinType> = 2;
define constant $GTK-SPIN-PAGE-BACKWARD :: <GtkSpinType> = 3;
define constant $GTK-SPIN-HOME :: <GtkSpinType> = 4;
define constant $GTK-SPIN-END :: <GtkSpinType> = 5;
define constant $GTK-SPIN-USER-DEFINED :: <GtkSpinType> = 6;

define C-subtype <_GtkSpinButton> (<GtkEntry>, <AtkImplementorIface>, <GtkEditable>, <GtkCellEditable>) end;
define constant <GtkSpinButton> = <_GtkSpinButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7695>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7696>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7697>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7698>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7699>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7700>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7701>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7702>"*/
define C-subtype <_GtkSpinButtonClass> (<C-void*>) end;
define constant <GtkSpinButtonClass> = <_GtkSpinButtonClass>;

define C-function gtk-spin-button-get-type
  result res :: <GType>;
  c-name: "gtk_spin_button_get_type";
end;

define C-function gtk-spin-button-configure
  input parameter spin_button :: <GtkSpinButton>;
  input parameter adjustment :: <GtkAdjustment>;
  input parameter climb_rate :: <gdouble>;
  input parameter digits :: <guint>;
  c-name: "gtk_spin_button_configure";
end;

define C-function gtk-spin-button-new
  input parameter adjustment :: <GtkAdjustment>;
  input parameter climb_rate :: <gdouble>;
  input parameter digits :: <guint>;
  result res :: <GtkWidget>;
  c-name: "gtk_spin_button_new";
end;

define C-function gtk-spin-button-new-with-range
  input parameter min :: <gdouble>;
  input parameter max :: <gdouble>;
  input parameter step :: <gdouble>;
  result res :: <GtkWidget>;
  c-name: "gtk_spin_button_new_with_range";
end;

define C-function gtk-spin-button-set-adjustment
  input parameter spin_button :: <GtkSpinButton>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_spin_button_set_adjustment";
end;

define C-function gtk-spin-button-get-adjustment
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_spin_button_get_adjustment";
end;

define C-function gtk-spin-button-set-digits
  input parameter spin_button :: <GtkSpinButton>;
  input parameter digits :: <guint>;
  c-name: "gtk_spin_button_set_digits";
end;

define C-function gtk-spin-button-get-digits
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <guint>;
  c-name: "gtk_spin_button_get_digits";
end;

define C-function gtk-spin-button-set-increments
  input parameter spin_button :: <GtkSpinButton>;
  input parameter step :: <gdouble>;
  input parameter page :: <gdouble>;
  c-name: "gtk_spin_button_set_increments";
end;

define C-function gtk-spin-button-get-increments
  input parameter spin_button :: <GtkSpinButton>;
  input parameter step :: <gdouble*>;
  input parameter page :: <gdouble*>;
  c-name: "gtk_spin_button_get_increments";
end;

define C-function gtk-spin-button-set-range
  input parameter spin_button :: <GtkSpinButton>;
  input parameter min :: <gdouble>;
  input parameter max :: <gdouble>;
  c-name: "gtk_spin_button_set_range";
end;

define C-function gtk-spin-button-get-range
  input parameter spin_button :: <GtkSpinButton>;
  input parameter min :: <gdouble*>;
  input parameter max :: <gdouble*>;
  c-name: "gtk_spin_button_get_range";
end;

define C-function gtk-spin-button-get-value
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <gdouble>;
  c-name: "gtk_spin_button_get_value";
end;

define C-function gtk-spin-button-get-value-as-int
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <gint>;
  c-name: "gtk_spin_button_get_value_as_int";
end;

define C-function gtk-spin-button-set-value
  input parameter spin_button :: <GtkSpinButton>;
  input parameter value :: <gdouble>;
  c-name: "gtk_spin_button_set_value";
end;

define C-function gtk-spin-button-set-update-policy
  input parameter spin_button :: <GtkSpinButton>;
  input parameter policy :: <GtkSpinButtonUpdatePolicy>;
  c-name: "gtk_spin_button_set_update_policy";
end;

define C-function gtk-spin-button-get-update-policy
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <GtkSpinButtonUpdatePolicy>;
  c-name: "gtk_spin_button_get_update_policy";
end;

define C-function gtk-spin-button-set-numeric
  input parameter spin_button :: <GtkSpinButton>;
  input parameter numeric :: <gboolean>;
  c-name: "gtk_spin_button_set_numeric";
end;

define C-function gtk-spin-button-get-numeric
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <gboolean>;
  c-name: "gtk_spin_button_get_numeric";
end;

define C-function gtk-spin-button-spin
  input parameter spin_button :: <GtkSpinButton>;
  input parameter direction :: <GtkSpinType>;
  input parameter increment :: <gdouble>;
  c-name: "gtk_spin_button_spin";
end;

define C-function gtk-spin-button-set-wrap
  input parameter spin_button :: <GtkSpinButton>;
  input parameter wrap :: <gboolean>;
  c-name: "gtk_spin_button_set_wrap";
end;

define C-function gtk-spin-button-get-wrap
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <gboolean>;
  c-name: "gtk_spin_button_get_wrap";
end;

define C-function gtk-spin-button-set-snap-to-ticks
  input parameter spin_button :: <GtkSpinButton>;
  input parameter snap_to_ticks :: <gboolean>;
  c-name: "gtk_spin_button_set_snap_to_ticks";
end;

define C-function gtk-spin-button-get-snap-to-ticks
  input parameter spin_button :: <GtkSpinButton>;
  result res :: <gboolean>;
  c-name: "gtk_spin_button_get_snap_to_ticks";
end;

define C-function gtk-spin-button-update
  input parameter spin_button :: <GtkSpinButton>;
  c-name: "gtk_spin_button_update";
end;

define constant $GTK-INPUT-ERROR = -1;

define constant gtk-spin-button-get-value-as-float = gtk-spin-button-get-value;

define C-subtype <_GtkSocket> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkSocket> = <_GtkSocket>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7147>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7148>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7149>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7150>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7151>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7152>"*/
define C-subtype <_GtkSocketClass> (<C-void*>) end;
define constant <GtkSocketClass> = <_GtkSocketClass>;

define C-function gtk-socket-get-type
  result res :: <GType>;
  c-name: "gtk_socket_get_type";
end;

define C-function gtk-socket-new
  result res :: <GtkWidget>;
  c-name: "gtk_socket_new";
end;

define C-function gtk-socket-add-id
  input parameter socket_ :: <GtkSocket>;
  input parameter window_id :: <GdkNativeWindow>;
  c-name: "gtk_socket_add_id";
end;

define C-function gtk-socket-get-id
  input parameter socket_ :: <GtkSocket>;
  result res :: <GdkNativeWindow>;
  c-name: "gtk_socket_get_id";
end;

define C-function gtk-socket-steal
  input parameter socket_ :: <GtkSocket>;
  input parameter wid :: <GdkNativeWindow>;
  c-name: "gtk_socket_steal";
end;

define C-subtype <_GtkSizeGroup> (<GObject>) end;
define constant <GtkSizeGroup> = <_GtkSizeGroup>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7667>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7668>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7669>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7670>"*/
define C-subtype <_GtkSizeGroupClass> (<C-void*>) end;
define constant <GtkSizeGroupClass> = <_GtkSizeGroupClass>;

define constant <GtkSizeGroupMode> = limited(<integer>, min: 0, max: 3);
define constant $GTK-SIZE-GROUP-NONE :: <GtkSizeGroupMode> = 0;
define constant $GTK-SIZE-GROUP-HORIZONTAL :: <GtkSizeGroupMode> = 1;
define constant $GTK-SIZE-GROUP-VERTICAL :: <GtkSizeGroupMode> = 2;
define constant $GTK-SIZE-GROUP-BOTH :: <GtkSizeGroupMode> = 3;

define C-function gtk-size-group-get-type
  result res :: <GType>;
  c-name: "gtk_size_group_get_type";
end;

define C-function gtk-size-group-new
  input parameter mode :: <GtkSizeGroupMode>;
  result res :: <GtkSizeGroup>;
  c-name: "gtk_size_group_new";
end;

define C-function gtk-size-group-set-mode
  input parameter size_group :: <GtkSizeGroup>;
  input parameter mode :: <GtkSizeGroupMode>;
  c-name: "gtk_size_group_set_mode";
end;

define C-function gtk-size-group-get-mode
  input parameter size_group :: <GtkSizeGroup>;
  result res :: <GtkSizeGroupMode>;
  c-name: "gtk_size_group_get_mode";
end;

define C-function gtk-size-group-set-ignore-hidden
  input parameter size_group :: <GtkSizeGroup>;
  input parameter ignore_hidden :: <gboolean>;
  c-name: "gtk_size_group_set_ignore_hidden";
end;

define C-function gtk-size-group-get-ignore-hidden
  input parameter size_group :: <GtkSizeGroup>;
  result res :: <gboolean>;
  c-name: "gtk_size_group_get_ignore_hidden";
end;

define C-function gtk-size-group-add-widget
  input parameter size_group :: <GtkSizeGroup>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_size_group_add_widget";
end;

define C-function gtk-size-group-remove-widget
  input parameter size_group :: <GtkSizeGroup>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_size_group_remove_widget";
end;

define C-function gtk-size-group-get-widgets
  input parameter size_group :: <GtkSizeGroup>;
  result res :: <GSList>;
  c-name: "gtk_size_group_get_widgets";
end;

define C-function _gtk-size-group-get-child-requisition
  input parameter widget :: <GtkWidget>;
  input parameter requisition :: <GtkRequisition>;
  c-name: "_gtk_size_group_get_child_requisition";
end;

define C-function _gtk-size-group-compute-requisition
  input parameter widget :: <GtkWidget>;
  input parameter requisition :: <GtkRequisition>;
  c-name: "_gtk_size_group_compute_requisition";
end;

define C-function _gtk-size-group-queue-resize
  input parameter widget :: <GtkWidget>;
  c-name: "_gtk_size_group_queue_resize";
end;

define C-subtype <_GtkSeparatorToolItemPrivate> (<C-void*>) end;
define constant <GtkSeparatorToolItemPrivate> = <_GtkSeparatorToolItemPrivate>;

define C-subtype <_GtkSeparatorToolItem> (<C-void*>) end;
define constant <GtkSeparatorToolItem> = <_GtkSeparatorToolItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7656>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7657>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7658>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7659>"*/
define C-subtype <_GtkSeparatorToolItemClass> (<C-void*>) end;
define constant <GtkSeparatorToolItemClass> = <_GtkSeparatorToolItemClass>;

define C-function gtk-separator-tool-item-get-type
  result res :: <GType>;
  c-name: "gtk_separator_tool_item_get_type";
end;

define C-function gtk-separator-tool-item-new
  result res :: <GtkToolItem>;
  c-name: "gtk_separator_tool_item_new";
end;

define C-function gtk-separator-tool-item-get-draw
  input parameter item :: <GtkSeparatorToolItem>;
  result res :: <gboolean>;
  c-name: "gtk_separator_tool_item_get_draw";
end;

define C-function gtk-separator-tool-item-set-draw
  input parameter item :: <GtkSeparatorToolItem>;
  input parameter draw :: <gboolean>;
  c-name: "gtk_separator_tool_item_set_draw";
end;

define C-subtype <_GtkSeparatorMenuItem> (<GtkMenuItem>, <AtkImplementorIface>) end;
define constant <GtkSeparatorMenuItem> = <_GtkSeparatorMenuItem>;

define C-subtype <_GtkSeparatorMenuItemClass> (<C-void*>) end;
define constant <GtkSeparatorMenuItemClass> = <_GtkSeparatorMenuItemClass>;

define C-function gtk-separator-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_separator_menu_item_get_type";
end;

define C-function gtk-separator-menu-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_separator_menu_item_new";
end;

define C-subtype <_GtkScrolledWindow> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkScrolledWindow> = <_GtkScrolledWindow>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7631>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7632>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7633>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7634>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7635>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7636>"*/
define C-subtype <_GtkScrolledWindowClass> (<C-void*>) end;
define constant <GtkScrolledWindowClass> = <_GtkScrolledWindowClass>;

define C-function gtk-scrolled-window-get-type
  result res :: <GType>;
  c-name: "gtk_scrolled_window_get_type";
end;

define C-function gtk-scrolled-window-new
  input parameter hadjustment :: <GtkAdjustment>;
  input parameter vadjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_scrolled_window_new";
end;

define C-function gtk-scrolled-window-set-hadjustment
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter hadjustment :: <GtkAdjustment>;
  c-name: "gtk_scrolled_window_set_hadjustment";
end;

define C-function gtk-scrolled-window-set-vadjustment
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter vadjustment :: <GtkAdjustment>;
  c-name: "gtk_scrolled_window_set_vadjustment";
end;

define C-function gtk-scrolled-window-get-hadjustment
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_scrolled_window_get_hadjustment";
end;

define C-function gtk-scrolled-window-get-vadjustment
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_scrolled_window_get_vadjustment";
end;

define C-function gtk-scrolled-window-get-hscrollbar
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkWidget>;
  c-name: "gtk_scrolled_window_get_hscrollbar";
end;

define C-function gtk-scrolled-window-get-vscrollbar
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkWidget>;
  c-name: "gtk_scrolled_window_get_vscrollbar";
end;

define C-function gtk-scrolled-window-set-policy
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter hscrollbar_policy :: <GtkPolicyType>;
  input parameter vscrollbar_policy :: <GtkPolicyType>;
  c-name: "gtk_scrolled_window_set_policy";
end;

define C-pointer-type <GtkPolicyType*> => <GtkPolicyType>;
define C-function gtk-scrolled-window-get-policy
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter hscrollbar_policy :: <GtkPolicyType*>;
  input parameter vscrollbar_policy :: <GtkPolicyType*>;
  c-name: "gtk_scrolled_window_get_policy";
end;

define C-function gtk-scrolled-window-set-placement
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter window_placement :: <GtkCornerType>;
  c-name: "gtk_scrolled_window_set_placement";
end;

define C-function gtk-scrolled-window-unset-placement
  input parameter scrolled_window :: <GtkScrolledWindow>;
  c-name: "gtk_scrolled_window_unset_placement";
end;

define C-function gtk-scrolled-window-get-placement
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkCornerType>;
  c-name: "gtk_scrolled_window_get_placement";
end;

define C-function gtk-scrolled-window-set-shadow-type
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter type :: <GtkShadowType>;
  c-name: "gtk_scrolled_window_set_shadow_type";
end;

define C-function gtk-scrolled-window-get-shadow-type
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <GtkShadowType>;
  c-name: "gtk_scrolled_window_get_shadow_type";
end;

define C-function gtk-scrolled-window-add-with-viewport
  input parameter scrolled_window :: <GtkScrolledWindow>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_scrolled_window_add_with_viewport";
end;

define C-function _gtk-scrolled-window-get-scrollbar-spacing
  input parameter scrolled_window :: <GtkScrolledWindow>;
  result res :: <gint>;
  c-name: "_gtk_scrolled_window_get_scrollbar_spacing";
end;

define C-subtype <_GtkHScrollbar> (<GtkScrollbar>, <AtkImplementorIface>) end;
define constant <GtkHScrollbar> = <_GtkHScrollbar>;

define C-subtype <_GtkHScrollbarClass> (<C-void*>) end;
define constant <GtkHScrollbarClass> = <_GtkHScrollbarClass>;

define C-function gtk-hscrollbar-get-type
  result res :: <GType>;
  c-name: "gtk_hscrollbar_get_type";
end;

define C-function gtk-hscrollbar-new
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_hscrollbar_new";
end;

define C-subtype <_GtkRecentInfo> (<C-void*>) end;
define constant <GtkRecentInfo> = <_GtkRecentInfo>;

define C-subtype <_GtkRecentData> (<C-void*>) end;
define constant <GtkRecentData> = <_GtkRecentData>;

define C-subtype <_GtkRecentManagerPrivate> (<C-void*>) end;
define constant <GtkRecentManagerPrivate> = <_GtkRecentManagerPrivate>;

define C-subtype <_GtkRecentManager> (<C-void*>) end;
define constant <GtkRecentManager> = <_GtkRecentManager>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7488>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7489>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7490>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7491>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7492>"*/
define C-subtype <_GtkRecentManagerClass> (<C-void*>) end;
define constant <GtkRecentManagerClass> = <_GtkRecentManagerClass>;

define constant <GtkRecentManagerError> = limited(<integer>, min: 0, max: 6);
define constant $GTK-RECENT-MANAGER-ERROR-NOT-FOUND :: <GtkRecentManagerError> = 0;
define constant $GTK-RECENT-MANAGER-ERROR-INVALID-URI :: <GtkRecentManagerError> = 1;
define constant $GTK-RECENT-MANAGER-ERROR-INVALID-ENCODING :: <GtkRecentManagerError> = 2;
define constant $GTK-RECENT-MANAGER-ERROR-NOT-REGISTERED :: <GtkRecentManagerError> = 3;
define constant $GTK-RECENT-MANAGER-ERROR-READ :: <GtkRecentManagerError> = 4;
define constant $GTK-RECENT-MANAGER-ERROR-WRITE :: <GtkRecentManagerError> = 5;
define constant $GTK-RECENT-MANAGER-ERROR-UNKNOWN :: <GtkRecentManagerError> = 6;

define C-function gtk-recent-manager-error-quark
  result res :: <GQuark>;
  c-name: "gtk_recent_manager_error_quark";
end;

define C-function gtk-recent-manager-get-type
  result res :: <GType>;
  c-name: "gtk_recent_manager_get_type";
end;

define C-function gtk-recent-manager-new
  result res :: <GtkRecentManager>;
  c-name: "gtk_recent_manager_new";
end;

define C-function gtk-recent-manager-get-default
  result res :: <GtkRecentManager>;
  c-name: "gtk_recent_manager_get_default";
end;

define C-function gtk-recent-manager-get-for-screen
  input parameter screen :: <GdkScreen>;
  result res :: <GtkRecentManager>;
  c-name: "gtk_recent_manager_get_for_screen";
end;

define C-function gtk-recent-manager-set-screen
  input parameter manager :: <GtkRecentManager>;
  input parameter screen :: <GdkScreen>;
  c-name: "gtk_recent_manager_set_screen";
end;

define C-function gtk-recent-manager-add-item
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_recent_manager_add_item";
end;

define C-function gtk-recent-manager-add-full
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  input parameter recent_data :: <GtkRecentData>;
  result res :: <gboolean>;
  c-name: "gtk_recent_manager_add_full";
end;

define C-function gtk-recent-manager-remove-item
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_recent_manager_remove_item";
end;

define C-function gtk-recent-manager-lookup-item
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <GtkRecentInfo>;
  c-name: "gtk_recent_manager_lookup_item";
end;

define C-function gtk-recent-manager-has-item
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_recent_manager_has_item";
end;

define C-function gtk-recent-manager-move-item
  input parameter manager :: <GtkRecentManager>;
  input parameter uri :: <c-string>;
  input parameter new_uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_recent_manager_move_item";
end;

define C-function gtk-recent-manager-set-limit
  input parameter manager :: <GtkRecentManager>;
  input parameter limit :: <gint>;
  c-name: "gtk_recent_manager_set_limit";
end;

define C-function gtk-recent-manager-get-limit
  input parameter manager :: <GtkRecentManager>;
  result res :: <gint>;
  c-name: "gtk_recent_manager_get_limit";
end;

define C-function gtk-recent-manager-get-items
  input parameter manager :: <GtkRecentManager>;
  result res :: <GList>;
  c-name: "gtk_recent_manager_get_items";
end;

define C-function gtk-recent-manager-purge-items
  input parameter manager :: <GtkRecentManager>;
  input parameter error :: <GError*>;
  result res :: <gint>;
  c-name: "gtk_recent_manager_purge_items";
end;

define C-function gtk-recent-info-get-type
  result res :: <GType>;
  c-name: "gtk_recent_info_get_type";
end;

define C-function gtk-recent-info-ref
  input parameter info :: <GtkRecentInfo>;
  result res :: <GtkRecentInfo>;
  c-name: "gtk_recent_info_ref";
end;

define C-function gtk-recent-info-unref
  input parameter info :: <GtkRecentInfo>;
  c-name: "gtk_recent_info_unref";
end;

define C-function gtk-recent-info-get-uri
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_uri";
end;

define C-function gtk-recent-info-get-display-name
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_display_name";
end;

define C-function gtk-recent-info-get-description
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_description";
end;

define C-function gtk-recent-info-get-mime-type
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_mime_type";
end;

define C-function gtk-recent-info-get-added
  input parameter info :: <GtkRecentInfo>;
  result res :: <time-t>;
  c-name: "gtk_recent_info_get_added";
end;

define C-function gtk-recent-info-get-modified
  input parameter info :: <GtkRecentInfo>;
  result res :: <time-t>;
  c-name: "gtk_recent_info_get_modified";
end;

define C-function gtk-recent-info-get-visited
  input parameter info :: <GtkRecentInfo>;
  result res :: <time-t>;
  c-name: "gtk_recent_info_get_visited";
end;

define C-function gtk-recent-info-get-private-hint
  input parameter info :: <GtkRecentInfo>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_get_private_hint";
end;

define C-function gtk-recent-info-get-application-info
  input parameter info :: <GtkRecentInfo>;
  input parameter app_name :: <c-string>;
  input parameter app_exec :: <gchar**>;
  input parameter count :: <guint*>;
  input parameter time_ :: <time-t*>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_get_application_info";
end;

define C-function gtk-recent-info-get-applications
  input parameter info :: <GtkRecentInfo>;
  input parameter length :: <gsize*>;
  result res :: <gchar**>;
  c-name: "gtk_recent_info_get_applications";
end;

define C-function gtk-recent-info-last-application
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_last_application";
end;

define C-function gtk-recent-info-has-application
  input parameter info :: <GtkRecentInfo>;
  input parameter app_name :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_has_application";
end;

define C-function gtk-recent-info-get-groups
  input parameter info :: <GtkRecentInfo>;
  input parameter length :: <gsize*>;
  result res :: <gchar**>;
  c-name: "gtk_recent_info_get_groups";
end;

define C-function gtk-recent-info-has-group
  input parameter info :: <GtkRecentInfo>;
  input parameter group_name :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_has_group";
end;

define C-function gtk-recent-info-get-icon
  input parameter info :: <GtkRecentInfo>;
  input parameter size :: <gint>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_recent_info_get_icon";
end;

define C-function gtk-recent-info-get-short-name
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_short_name";
end;

define C-function gtk-recent-info-get-uri-display
  input parameter info :: <GtkRecentInfo>;
  result res :: <c-string>;
  c-name: "gtk_recent_info_get_uri_display";
end;

define C-function gtk-recent-info-get-age
  input parameter info :: <GtkRecentInfo>;
  result res :: <gint>;
  c-name: "gtk_recent_info_get_age";
end;

define C-function gtk-recent-info-is-local
  input parameter info :: <GtkRecentInfo>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_is_local";
end;

define C-function gtk-recent-info-exists
  input parameter info :: <GtkRecentInfo>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_exists";
end;

define C-function gtk-recent-info-match
  input parameter info_a :: <GtkRecentInfo>;
  input parameter info_b :: <GtkRecentInfo>;
  result res :: <gboolean>;
  c-name: "gtk_recent_info_match";
end;

define C-subtype <_GtkRecentFilter> (<C-void*>) end;
define constant <GtkRecentFilter> = <_GtkRecentFilter>;

define constant <GtkRecentFilterFlags> = limited(<integer>, min: 1, max: 32);
define constant $GTK-RECENT-FILTER-URI :: <GtkRecentFilterFlags> = 1;
define constant $GTK-RECENT-FILTER-DISPLAY-NAME :: <GtkRecentFilterFlags> = 2;
define constant $GTK-RECENT-FILTER-MIME-TYPE :: <GtkRecentFilterFlags> = 4;
define constant $GTK-RECENT-FILTER-APPLICATION :: <GtkRecentFilterFlags> = 8;
define constant $GTK-RECENT-FILTER-GROUP :: <GtkRecentFilterFlags> = 16;
define constant $GTK-RECENT-FILTER-AGE :: <GtkRecentFilterFlags> = 32;

define C-subtype <_GtkRecentFilterInfo> (<C-void*>) end;
define constant <GtkRecentFilterInfo> = <_GtkRecentFilterInfo>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7535>"*/
define constant <GtkRecentFilterFunc> = <anonymous-7535>;

define C-function gtk-recent-filter-get-type
  result res :: <GType>;
  c-name: "gtk_recent_filter_get_type";
end;

define C-function gtk-recent-filter-new
  result res :: <GtkRecentFilter>;
  c-name: "gtk_recent_filter_new";
end;

define C-function gtk-recent-filter-set-name
  input parameter filter :: <GtkRecentFilter>;
  input parameter name :: <c-string>;
  c-name: "gtk_recent_filter_set_name";
end;

define C-function gtk-recent-filter-get-name
  input parameter filter :: <GtkRecentFilter>;
  result res :: <c-string>;
  c-name: "gtk_recent_filter_get_name";
end;

define C-function gtk-recent-filter-add-mime-type
  input parameter filter :: <GtkRecentFilter>;
  input parameter mime_type :: <c-string>;
  c-name: "gtk_recent_filter_add_mime_type";
end;

define C-function gtk-recent-filter-add-pattern
  input parameter filter :: <GtkRecentFilter>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_recent_filter_add_pattern";
end;

define C-function gtk-recent-filter-add-pixbuf-formats
  input parameter filter :: <GtkRecentFilter>;
  c-name: "gtk_recent_filter_add_pixbuf_formats";
end;

define C-function gtk-recent-filter-add-application
  input parameter filter :: <GtkRecentFilter>;
  input parameter application :: <c-string>;
  c-name: "gtk_recent_filter_add_application";
end;

define C-function gtk-recent-filter-add-group
  input parameter filter :: <GtkRecentFilter>;
  input parameter group :: <c-string>;
  c-name: "gtk_recent_filter_add_group";
end;

define C-function gtk-recent-filter-add-age
  input parameter filter :: <GtkRecentFilter>;
  input parameter days :: <gint>;
  c-name: "gtk_recent_filter_add_age";
end;

define C-function gtk-recent-filter-add-custom
  input parameter filter :: <GtkRecentFilter>;
  input parameter needed :: <GtkRecentFilterFlags>;
  input parameter func :: <GtkRecentFilterFunc>;
  input parameter data :: <gpointer>;
  input parameter data_destroy :: <GDestroyNotify>;
  c-name: "gtk_recent_filter_add_custom";
end;

define C-function gtk-recent-filter-get-needed
  input parameter filter :: <GtkRecentFilter>;
  result res :: <GtkRecentFilterFlags>;
  c-name: "gtk_recent_filter_get_needed";
end;

define C-function gtk-recent-filter-filter
  input parameter filter :: <GtkRecentFilter>;
  input parameter filter_info :: <GtkRecentFilterInfo>;
  result res :: <gboolean>;
  c-name: "gtk_recent_filter_filter";
end;

define C-subtype <_GtkRecentChooserWidgetPrivate> (<C-void*>) end;
define constant <GtkRecentChooserWidgetPrivate> = <_GtkRecentChooserWidgetPrivate>;

define C-subtype <_GtkRecentChooserWidget> (<C-void*>) end;
define constant <GtkRecentChooserWidget> = <_GtkRecentChooserWidget>;

define C-subtype <_GtkRecentChooserWidgetClass> (<C-void*>) end;
define constant <GtkRecentChooserWidgetClass> = <_GtkRecentChooserWidgetClass>;

define C-function gtk-recent-chooser-widget-get-type
  result res :: <GType>;
  c-name: "gtk_recent_chooser_widget_get_type";
end;

define C-function gtk-recent-chooser-widget-new
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_widget_new";
end;

define C-function gtk-recent-chooser-widget-new-for-manager
  input parameter manager :: <GtkRecentManager>;
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_widget_new_for_manager";
end;

define constant <GtkRecentSortType> = limited(<integer>, min: 0, max: 3);
define constant $GTK-RECENT-SORT-NONE :: <GtkRecentSortType> = 0;
define constant $GTK-RECENT-SORT-MRU :: <GtkRecentSortType> = 1;
define constant $GTK-RECENT-SORT-LRU :: <GtkRecentSortType> = 2;
define constant $GTK-RECENT-SORT-CUSTOM :: <GtkRecentSortType> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7550>"*/
define constant <GtkRecentSortFunc> = <anonymous-7550>;

define C-subtype <_GtkRecentChooser> (<C-void*>) end;
define constant <GtkRecentChooser> = <_GtkRecentChooser>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7553>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7554>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7555>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7556>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7557>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7558>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7559>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7560>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7561>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7562>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7563>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7564>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7565>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7566>"*/
define C-subtype <_GtkRecentChooserIface> (<C-void*>) end;
define constant <GtkRecentChooserIface> = <_GtkRecentChooserIface>;

define constant <GtkRecentChooserError> = limited(<integer>, min: 0, max: 1);
define constant $GTK-RECENT-CHOOSER-ERROR-NOT-FOUND :: <GtkRecentChooserError> = 0;
define constant $GTK-RECENT-CHOOSER-ERROR-INVALID-URI :: <GtkRecentChooserError> = 1;

define C-function gtk-recent-chooser-error-quark
  result res :: <GQuark>;
  c-name: "gtk_recent_chooser_error_quark";
end;

define C-function gtk-recent-chooser-get-type
  result res :: <GType>;
  c-name: "gtk_recent_chooser_get_type";
end;

define C-function gtk-recent-chooser-set-show-private
  input parameter chooser :: <GtkRecentChooser>;
  input parameter show_private :: <gboolean>;
  c-name: "gtk_recent_chooser_set_show_private";
end;

define C-function gtk-recent-chooser-get-show-private
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_show_private";
end;

define C-function gtk-recent-chooser-set-show-not-found
  input parameter chooser :: <GtkRecentChooser>;
  input parameter show_not_found :: <gboolean>;
  c-name: "gtk_recent_chooser_set_show_not_found";
end;

define C-function gtk-recent-chooser-get-show-not-found
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_show_not_found";
end;

define C-function gtk-recent-chooser-set-select-multiple
  input parameter chooser :: <GtkRecentChooser>;
  input parameter select_multiple :: <gboolean>;
  c-name: "gtk_recent_chooser_set_select_multiple";
end;

define C-function gtk-recent-chooser-get-select-multiple
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_select_multiple";
end;

define C-function gtk-recent-chooser-set-limit
  input parameter chooser :: <GtkRecentChooser>;
  input parameter limit :: <gint>;
  c-name: "gtk_recent_chooser_set_limit";
end;

define C-function gtk-recent-chooser-get-limit
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gint>;
  c-name: "gtk_recent_chooser_get_limit";
end;

define C-function gtk-recent-chooser-set-local-only
  input parameter chooser :: <GtkRecentChooser>;
  input parameter local_only :: <gboolean>;
  c-name: "gtk_recent_chooser_set_local_only";
end;

define C-function gtk-recent-chooser-get-local-only
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_local_only";
end;

define C-function gtk-recent-chooser-set-show-tips
  input parameter chooser :: <GtkRecentChooser>;
  input parameter show_tips :: <gboolean>;
  c-name: "gtk_recent_chooser_set_show_tips";
end;

define C-function gtk-recent-chooser-get-show-tips
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_show_tips";
end;

define C-function gtk-recent-chooser-set-show-numbers
  input parameter chooser :: <GtkRecentChooser>;
  input parameter show_numbers :: <gboolean>;
  c-name: "gtk_recent_chooser_set_show_numbers";
end;

define C-function gtk-recent-chooser-get-show-numbers
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_show_numbers";
end;

define C-function gtk-recent-chooser-set-show-icons
  input parameter chooser :: <GtkRecentChooser>;
  input parameter show_icons :: <gboolean>;
  c-name: "gtk_recent_chooser_set_show_icons";
end;

define C-function gtk-recent-chooser-get-show-icons
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_get_show_icons";
end;

define C-function gtk-recent-chooser-set-sort-type
  input parameter chooser :: <GtkRecentChooser>;
  input parameter sort_type :: <GtkRecentSortType>;
  c-name: "gtk_recent_chooser_set_sort_type";
end;

define C-function gtk-recent-chooser-get-sort-type
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <GtkRecentSortType>;
  c-name: "gtk_recent_chooser_get_sort_type";
end;

define C-function gtk-recent-chooser-set-sort-func
  input parameter chooser :: <GtkRecentChooser>;
  input parameter sort_func :: <GtkRecentSortFunc>;
  input parameter sort_data :: <gpointer>;
  input parameter data_destroy :: <GDestroyNotify>;
  c-name: "gtk_recent_chooser_set_sort_func";
end;

define C-function gtk-recent-chooser-set-current-uri
  input parameter chooser :: <GtkRecentChooser>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_set_current_uri";
end;

define C-function gtk-recent-chooser-get-current-uri
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <c-string>;
  c-name: "gtk_recent_chooser_get_current_uri";
end;

define C-function gtk-recent-chooser-get-current-item
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <GtkRecentInfo>;
  c-name: "gtk_recent_chooser_get_current_item";
end;

define C-function gtk-recent-chooser-select-uri
  input parameter chooser :: <GtkRecentChooser>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_select_uri";
end;

define C-function gtk-recent-chooser-unselect-uri
  input parameter chooser :: <GtkRecentChooser>;
  input parameter uri :: <c-string>;
  c-name: "gtk_recent_chooser_unselect_uri";
end;

define C-function gtk-recent-chooser-select-all
  input parameter chooser :: <GtkRecentChooser>;
  c-name: "gtk_recent_chooser_select_all";
end;

define C-function gtk-recent-chooser-unselect-all
  input parameter chooser :: <GtkRecentChooser>;
  c-name: "gtk_recent_chooser_unselect_all";
end;

define C-function gtk-recent-chooser-get-items
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <GList>;
  c-name: "gtk_recent_chooser_get_items";
end;

define C-function gtk-recent-chooser-get-uris
  input parameter chooser :: <GtkRecentChooser>;
  input parameter length :: <gsize*>;
  result res :: <gchar**>;
  c-name: "gtk_recent_chooser_get_uris";
end;

define C-function gtk-recent-chooser-add-filter
  input parameter chooser :: <GtkRecentChooser>;
  input parameter filter :: <GtkRecentFilter>;
  c-name: "gtk_recent_chooser_add_filter";
end;

define C-function gtk-recent-chooser-remove-filter
  input parameter chooser :: <GtkRecentChooser>;
  input parameter filter :: <GtkRecentFilter>;
  c-name: "gtk_recent_chooser_remove_filter";
end;

define C-function gtk-recent-chooser-list-filters
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <GSList>;
  c-name: "gtk_recent_chooser_list_filters";
end;

define C-function gtk-recent-chooser-set-filter
  input parameter chooser :: <GtkRecentChooser>;
  input parameter filter :: <GtkRecentFilter>;
  c-name: "gtk_recent_chooser_set_filter";
end;

define C-function gtk-recent-chooser-get-filter
  input parameter chooser :: <GtkRecentChooser>;
  result res :: <GtkRecentFilter>;
  c-name: "gtk_recent_chooser_get_filter";
end;

define C-subtype <_GtkRecentChooserMenuPrivate> (<C-void*>) end;
define constant <GtkRecentChooserMenuPrivate> = <_GtkRecentChooserMenuPrivate>;

define C-subtype <_GtkRecentChooserMenu> (<C-void*>) end;
define constant <GtkRecentChooserMenu> = <_GtkRecentChooserMenu>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7604>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7605>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7606>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7607>"*/
define C-subtype <_GtkRecentChooserMenuClass> (<C-void*>) end;
define constant <GtkRecentChooserMenuClass> = <_GtkRecentChooserMenuClass>;

define C-function gtk-recent-chooser-menu-get-type
  result res :: <GType>;
  c-name: "gtk_recent_chooser_menu_get_type";
end;

define C-function gtk-recent-chooser-menu-new
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_menu_new";
end;

define C-function gtk-recent-chooser-menu-new-for-manager
  input parameter manager :: <GtkRecentManager>;
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_menu_new_for_manager";
end;

define C-function gtk-recent-chooser-menu-get-show-numbers
  input parameter menu :: <GtkRecentChooserMenu>;
  result res :: <gboolean>;
  c-name: "gtk_recent_chooser_menu_get_show_numbers";
end;

define C-function gtk-recent-chooser-menu-set-show-numbers
  input parameter menu :: <GtkRecentChooserMenu>;
  input parameter show_numbers :: <gboolean>;
  c-name: "gtk_recent_chooser_menu_set_show_numbers";
end;

define C-subtype <_GtkDialog> (<GtkWindow>, <AtkImplementorIface>) end;
define constant <GtkDialog> = <_GtkDialog>;

define C-subtype <_GtkRecentChooserDialogPrivate> (<C-void*>) end;
define constant <GtkRecentChooserDialogPrivate> = <_GtkRecentChooserDialogPrivate>;

define C-subtype <_GtkRecentChooserDialog> (<C-void*>) end;
define constant <GtkRecentChooserDialog> = <_GtkRecentChooserDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4053>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4054>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4055>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4056>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4057>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4058>"*/
define C-subtype <_GtkDialogClass> (<C-void*>) end;
define constant <GtkDialogClass> = <_GtkDialogClass>;

define C-subtype <_GtkRecentChooserDialogClass> (<C-void*>) end;
define constant <GtkRecentChooserDialogClass> = <_GtkRecentChooserDialogClass>;

define C-function gtk-recent-chooser-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_recent_chooser_dialog_get_type";
end;

define C-function gtk-recent-chooser-dialog-new
  input parameter title :: <c-string>;
  input parameter parent :: <GtkWindow>;
  input parameter first_button_text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_dialog_new";
end;

define C-function gtk-recent-chooser-dialog-new-for-manager
  input parameter title :: <c-string>;
  input parameter parent :: <GtkWindow>;
  input parameter manager :: <GtkRecentManager>;
  input parameter first_button_text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_recent_chooser_dialog_new_for_manager";
end;

define constant <GtkDialogFlags> = limited(<integer>, min: 1, max: 4);
define constant $GTK-DIALOG-MODAL :: <GtkDialogFlags> = 1;
define constant $GTK-DIALOG-DESTROY-WITH-PARENT :: <GtkDialogFlags> = 2;
define constant $GTK-DIALOG-NO-SEPARATOR :: <GtkDialogFlags> = 4;

define constant <GtkResponseType> = limited(<integer>, min: -11, max: -1);
define constant $GTK-RESPONSE-NONE :: <GtkResponseType> = -1;
define constant $GTK-RESPONSE-REJECT :: <GtkResponseType> = -2;
define constant $GTK-RESPONSE-ACCEPT :: <GtkResponseType> = -3;
define constant $GTK-RESPONSE-DELETE-EVENT :: <GtkResponseType> = -4;
define constant $GTK-RESPONSE-OK :: <GtkResponseType> = -5;
define constant $GTK-RESPONSE-CANCEL :: <GtkResponseType> = -6;
define constant $GTK-RESPONSE-CLOSE :: <GtkResponseType> = -7;
define constant $GTK-RESPONSE-YES :: <GtkResponseType> = -8;
define constant $GTK-RESPONSE-NO :: <GtkResponseType> = -9;
define constant $GTK-RESPONSE-APPLY :: <GtkResponseType> = -10;
define constant $GTK-RESPONSE-HELP :: <GtkResponseType> = -11;

define C-function gtk-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_dialog_get_type";
end;

define C-function gtk-dialog-new
  result res :: <GtkWidget>;
  c-name: "gtk_dialog_new";
end;

define C-function gtk-dialog-new-with-buttons
  input parameter title :: <c-string>;
  input parameter parent :: <GtkWindow>;
  input parameter flags :: <GtkDialogFlags>;
  input parameter first_button_text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_dialog_new_with_buttons";
end;

define C-function gtk-dialog-add-action-widget
  input parameter dialog :: <GtkDialog>;
  input parameter child :: <GtkWidget>;
  input parameter response_id :: <gint>;
  c-name: "gtk_dialog_add_action_widget";
end;

define C-function gtk-dialog-add-button
  input parameter dialog :: <GtkDialog>;
  input parameter button_text :: <c-string>;
  input parameter response_id :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_dialog_add_button";
end;

define C-function gtk-dialog-add-buttons
  input parameter dialog :: <GtkDialog>;
  input parameter first_button_text :: <c-string>;
  c-name: "gtk_dialog_add_buttons";
end;

define C-function gtk-dialog-set-response-sensitive
  input parameter dialog :: <GtkDialog>;
  input parameter response_id :: <gint>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_dialog_set_response_sensitive";
end;

define C-function gtk-dialog-set-default-response
  input parameter dialog :: <GtkDialog>;
  input parameter response_id :: <gint>;
  c-name: "gtk_dialog_set_default_response";
end;

define C-function gtk-dialog-get-response-for-widget
  input parameter dialog :: <GtkDialog>;
  input parameter widget :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_dialog_get_response_for_widget";
end;

define C-function gtk-dialog-set-has-separator
  input parameter dialog :: <GtkDialog>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_dialog_set_has_separator";
end;

define C-function gtk-dialog-get-has-separator
  input parameter dialog :: <GtkDialog>;
  result res :: <gboolean>;
  c-name: "gtk_dialog_get_has_separator";
end;

define C-function gtk-alternative-dialog-button-order
  input parameter screen :: <GdkScreen>;
  result res :: <gboolean>;
  c-name: "gtk_alternative_dialog_button_order";
end;

define C-function gtk-dialog-set-alternative-button-order
  input parameter dialog :: <GtkDialog>;
  input parameter first_response_id :: <gint>;
  c-name: "gtk_dialog_set_alternative_button_order";
end;

define C-function gtk-dialog-set-alternative-button-order-from-array
  input parameter dialog :: <GtkDialog>;
  input parameter n_params :: <gint>;
  input parameter new_order :: <gint*>;
  c-name: "gtk_dialog_set_alternative_button_order_from_array";
end;

define C-function gtk-dialog-response
  input parameter dialog :: <GtkDialog>;
  input parameter response_id :: <gint>;
  c-name: "gtk_dialog_response";
end;

define C-function gtk-dialog-run
  input parameter dialog :: <GtkDialog>;
  result res :: <gint>;
  c-name: "gtk_dialog_run";
end;

define C-function _gtk-dialog-set-ignore-separator
  input parameter dialog :: <GtkDialog>;
  input parameter ignore_separator :: <gboolean>;
  c-name: "_gtk_dialog_set_ignore_separator";
end;

define C-subtype <_GtkRadioToolButton> (<C-void*>) end;
define constant <GtkRadioToolButton> = <_GtkRadioToolButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7477>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7478>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7479>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7480>"*/
define C-subtype <_GtkRadioToolButtonClass> (<C-void*>) end;
define constant <GtkRadioToolButtonClass> = <_GtkRadioToolButtonClass>;

define C-function gtk-radio-tool-button-get-type
  result res :: <GType>;
  c-name: "gtk_radio_tool_button_get_type";
end;

define C-function gtk-radio-tool-button-new
  input parameter group :: <GSList>;
  result res :: <GtkToolItem>;
  c-name: "gtk_radio_tool_button_new";
end;

define C-function gtk-radio-tool-button-new-from-stock
  input parameter group :: <GSList>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_radio_tool_button_new_from_stock";
end;

define C-function gtk-radio-tool-button-new-from-widget
  input parameter group :: <GtkRadioToolButton>;
  result res :: <GtkToolItem>;
  c-name: "gtk_radio_tool_button_new_from_widget";
end;

define C-function gtk-radio-tool-button-new-with-stock-from-widget
  input parameter group :: <GtkRadioToolButton>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_radio_tool_button_new_with_stock_from_widget";
end;

define C-function gtk-radio-tool-button-get-group
  input parameter button :: <GtkRadioToolButton>;
  result res :: <GSList>;
  c-name: "gtk_radio_tool_button_get_group";
end;

define C-function gtk-radio-tool-button-set-group
  input parameter button :: <GtkRadioToolButton>;
  input parameter group :: <GSList>;
  c-name: "gtk_radio_tool_button_set_group";
end;

define C-subtype <_GtkCheckMenuItem> (<GtkMenuItem>, <AtkImplementorIface>) end;
define constant <GtkCheckMenuItem> = <_GtkCheckMenuItem>;

define C-subtype <_GtkRadioMenuItem> (<GtkCheckMenuItem>, <AtkImplementorIface>) end;
define constant <GtkRadioMenuItem> = <_GtkRadioMenuItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5341>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5342>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5343>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5344>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5345>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5346>"*/
define C-subtype <_GtkCheckMenuItemClass> (<C-void*>) end;
define constant <GtkCheckMenuItemClass> = <_GtkCheckMenuItemClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7454>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7455>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7456>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7457>"*/
define C-subtype <_GtkRadioMenuItemClass> (<C-void*>) end;
define constant <GtkRadioMenuItemClass> = <_GtkRadioMenuItemClass>;

define C-function gtk-radio-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_radio_menu_item_get_type";
end;

define C-function gtk-radio-menu-item-new
  input parameter group :: <GSList>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new";
end;

define C-function gtk-radio-menu-item-new-with-label
  input parameter group :: <GSList>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new_with_label";
end;

define C-function gtk-radio-menu-item-new-with-mnemonic
  input parameter group :: <GSList>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new_with_mnemonic";
end;

define C-function gtk-radio-menu-item-new-from-widget
  input parameter group :: <GtkRadioMenuItem>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new_from_widget";
end;

define C-function gtk-radio-menu-item-new-with-mnemonic-from-widget
  input parameter group :: <GtkRadioMenuItem>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new_with_mnemonic_from_widget";
end;

define C-function gtk-radio-menu-item-new-with-label-from-widget
  input parameter group :: <GtkRadioMenuItem>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_menu_item_new_with_label_from_widget";
end;

define C-function gtk-radio-menu-item-get-group
  input parameter radio_menu_item :: <GtkRadioMenuItem>;
  result res :: <GSList>;
  c-name: "gtk_radio_menu_item_get_group";
end;

define C-function gtk-radio-menu-item-set-group
  input parameter radio_menu_item :: <GtkRadioMenuItem>;
  input parameter group :: <GSList>;
  c-name: "gtk_radio_menu_item_set_group";
end;

define constant gtk-radio-menu-item-group = gtk-radio-menu-item-get-group;

define C-function gtk-check-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_check_menu_item_get_type";
end;

define C-function gtk-check-menu-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_check_menu_item_new";
end;

define C-function gtk-check-menu-item-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_check_menu_item_new_with_label";
end;

define C-function gtk-check-menu-item-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_check_menu_item_new_with_mnemonic";
end;

define C-function gtk-check-menu-item-set-active
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  input parameter is_active :: <gboolean>;
  c-name: "gtk_check_menu_item_set_active";
end;

define C-function gtk-check-menu-item-get-active
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  result res :: <gboolean>;
  c-name: "gtk_check_menu_item_get_active";
end;

define C-function gtk-check-menu-item-toggled
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  c-name: "gtk_check_menu_item_toggled";
end;

define C-function gtk-check-menu-item-set-inconsistent
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_check_menu_item_set_inconsistent";
end;

define C-function gtk-check-menu-item-get-inconsistent
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  result res :: <gboolean>;
  c-name: "gtk_check_menu_item_get_inconsistent";
end;

define C-function gtk-check-menu-item-set-draw-as-radio
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  input parameter draw_as_radio :: <gboolean>;
  c-name: "gtk_check_menu_item_set_draw_as_radio";
end;

define C-function gtk-check-menu-item-get-draw-as-radio
  input parameter check_menu_item :: <GtkCheckMenuItem>;
  result res :: <gboolean>;
  c-name: "gtk_check_menu_item_get_draw_as_radio";
end;

define C-function gtk-check-menu-item-set-show-toggle
  input parameter menu_item :: <GtkCheckMenuItem>;
  input parameter always :: <gboolean>;
  c-name: "gtk_check_menu_item_set_show_toggle";
end;

define constant gtk-check-menu-item-set-state = gtk-check-menu-item-set-active;

define C-subtype <_GtkCheckButton> (<GtkToggleButton>, <AtkImplementorIface>) end;
define constant <GtkCheckButton> = <_GtkCheckButton>;

define C-subtype <_GtkRadioButton> (<GtkCheckButton>, <AtkImplementorIface>) end;
define constant <GtkRadioButton> = <_GtkRadioButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5283>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5284>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5285>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5286>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5287>"*/
define C-subtype <_GtkCheckButtonClass> (<C-void*>) end;
define constant <GtkCheckButtonClass> = <_GtkCheckButtonClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7441>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7442>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7443>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7444>"*/
define C-subtype <_GtkRadioButtonClass> (<C-void*>) end;
define constant <GtkRadioButtonClass> = <_GtkRadioButtonClass>;

define C-function gtk-radio-button-get-type
  result res :: <GType>;
  c-name: "gtk_radio_button_get_type";
end;

define C-function gtk-radio-button-new
  input parameter group :: <GSList>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new";
end;

define C-function gtk-radio-button-new-from-widget
  input parameter group :: <GtkRadioButton>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new_from_widget";
end;

define C-function gtk-radio-button-new-with-label
  input parameter group :: <GSList>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new_with_label";
end;

define C-function gtk-radio-button-new-with-label-from-widget
  input parameter group :: <GtkRadioButton>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new_with_label_from_widget";
end;

define C-function gtk-radio-button-new-with-mnemonic
  input parameter group :: <GSList>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new_with_mnemonic";
end;

define C-function gtk-radio-button-new-with-mnemonic-from-widget
  input parameter group :: <GtkRadioButton>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_radio_button_new_with_mnemonic_from_widget";
end;

define C-function gtk-radio-button-get-group
  input parameter radio_button :: <GtkRadioButton>;
  result res :: <GSList>;
  c-name: "gtk_radio_button_get_group";
end;

define C-function gtk-radio-button-set-group
  input parameter radio_button :: <GtkRadioButton>;
  input parameter group :: <GSList>;
  c-name: "gtk_radio_button_set_group";
end;

define constant gtk-radio-button-group = gtk-radio-button-get-group;

define C-function gtk-check-button-get-type
  result res :: <GType>;
  c-name: "gtk_check_button_get_type";
end;

define C-function gtk-check-button-new
  result res :: <GtkWidget>;
  c-name: "gtk_check_button_new";
end;

define C-function gtk-check-button-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_check_button_new_with_label";
end;

define C-function gtk-check-button-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_check_button_new_with_mnemonic";
end;

define C-function _gtk-check-button-get-props
  input parameter check_button :: <GtkCheckButton>;
  input parameter indicator_size :: <gint*>;
  input parameter indicator_spacing :: <gint*>;
  c-name: "_gtk_check_button_get_props";
end;

define C-subtype <_GtkRadioActionPrivate> (<C-void*>) end;
define constant <GtkRadioActionPrivate> = <_GtkRadioActionPrivate>;

define C-subtype <_GtkRadioAction> (<C-void*>) end;
define constant <GtkRadioAction> = <_GtkRadioAction>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7430>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7431>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7432>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7433>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7434>"*/
define C-subtype <_GtkRadioActionClass> (<C-void*>) end;
define constant <GtkRadioActionClass> = <_GtkRadioActionClass>;

define C-function gtk-radio-action-get-type
  result res :: <GType>;
  c-name: "gtk_radio_action_get_type";
end;

define C-function gtk-radio-action-new
  input parameter name :: <c-string>;
  input parameter label :: <c-string>;
  input parameter tooltip :: <c-string>;
  input parameter stock_id :: <c-string>;
  input parameter value :: <gint>;
  result res :: <GtkRadioAction>;
  c-name: "gtk_radio_action_new";
end;

define C-function gtk-radio-action-get-group
  input parameter action :: <GtkRadioAction>;
  result res :: <GSList>;
  c-name: "gtk_radio_action_get_group";
end;

define C-function gtk-radio-action-set-group
  input parameter action :: <GtkRadioAction>;
  input parameter group :: <GSList>;
  c-name: "gtk_radio_action_set_group";
end;

define C-function gtk-radio-action-get-current-value
  input parameter action :: <GtkRadioAction>;
  result res :: <gint>;
  c-name: "gtk_radio_action_get_current_value";
end;

define C-function gtk-radio-action-set-current-value
  input parameter action :: <GtkRadioAction>;
  input parameter current_value :: <gint>;
  c-name: "gtk_radio_action_set_current_value";
end;

define C-subtype <_GtkProgress> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkProgress> = <_GtkProgress>;

define constant <GtkProgressBarStyle> = limited(<integer>, min: 0, max: 1);
define constant $GTK-PROGRESS-CONTINUOUS :: <GtkProgressBarStyle> = 0;
define constant $GTK-PROGRESS-DISCRETE :: <GtkProgressBarStyle> = 1;

define constant <GtkProgressBarOrientation> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PROGRESS-LEFT-TO-RIGHT :: <GtkProgressBarOrientation> = 0;
define constant $GTK-PROGRESS-RIGHT-TO-LEFT :: <GtkProgressBarOrientation> = 1;
define constant $GTK-PROGRESS-BOTTOM-TO-TOP :: <GtkProgressBarOrientation> = 2;
define constant $GTK-PROGRESS-TOP-TO-BOTTOM :: <GtkProgressBarOrientation> = 3;

define C-subtype <_GtkProgressBar> (<GtkProgress>, <AtkImplementorIface>) end;
define constant <GtkProgressBar> = <_GtkProgressBar>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7369>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7370>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7371>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7372>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7373>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7374>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7375>"*/
define C-subtype <_GtkProgressClass> (<C-void*>) end;
define constant <GtkProgressClass> = <_GtkProgressClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7395>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7396>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7397>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7398>"*/
define C-subtype <_GtkProgressBarClass> (<C-void*>) end;
define constant <GtkProgressBarClass> = <_GtkProgressBarClass>;

define C-function gtk-progress-bar-get-type
  result res :: <GType>;
  c-name: "gtk_progress_bar_get_type";
end;

define C-function gtk-progress-bar-new
  result res :: <GtkWidget>;
  c-name: "gtk_progress_bar_new";
end;

define C-function gtk-progress-bar-pulse
  input parameter pbar :: <GtkProgressBar>;
  c-name: "gtk_progress_bar_pulse";
end;

define C-function gtk-progress-bar-set-text
  input parameter pbar :: <GtkProgressBar>;
  input parameter text :: <c-string>;
  c-name: "gtk_progress_bar_set_text";
end;

define C-function gtk-progress-bar-set-fraction
  input parameter pbar :: <GtkProgressBar>;
  input parameter fraction :: <gdouble>;
  c-name: "gtk_progress_bar_set_fraction";
end;

define C-function gtk-progress-bar-set-pulse-step
  input parameter pbar :: <GtkProgressBar>;
  input parameter fraction :: <gdouble>;
  c-name: "gtk_progress_bar_set_pulse_step";
end;

define C-function gtk-progress-bar-set-orientation
  input parameter pbar :: <GtkProgressBar>;
  input parameter orientation :: <GtkProgressBarOrientation>;
  c-name: "gtk_progress_bar_set_orientation";
end;

define C-function gtk-progress-bar-get-text
  input parameter pbar :: <GtkProgressBar>;
  result res :: <c-string>;
  c-name: "gtk_progress_bar_get_text";
end;

define C-function gtk-progress-bar-get-fraction
  input parameter pbar :: <GtkProgressBar>;
  result res :: <gdouble>;
  c-name: "gtk_progress_bar_get_fraction";
end;

define C-function gtk-progress-bar-get-pulse-step
  input parameter pbar :: <GtkProgressBar>;
  result res :: <gdouble>;
  c-name: "gtk_progress_bar_get_pulse_step";
end;

define C-function gtk-progress-bar-get-orientation
  input parameter pbar :: <GtkProgressBar>;
  result res :: <GtkProgressBarOrientation>;
  c-name: "gtk_progress_bar_get_orientation";
end;

define C-function gtk-progress-bar-set-ellipsize
  input parameter pbar :: <GtkProgressBar>;
  input parameter mode :: <PangoEllipsizeMode>;
  c-name: "gtk_progress_bar_set_ellipsize";
end;

define C-function gtk-progress-bar-get-ellipsize
  input parameter pbar :: <GtkProgressBar>;
  result res :: <PangoEllipsizeMode>;
  c-name: "gtk_progress_bar_get_ellipsize";
end;

define C-function gtk-progress-bar-new-with-adjustment
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_progress_bar_new_with_adjustment";
end;

define C-function gtk-progress-bar-set-bar-style
  input parameter pbar :: <GtkProgressBar>;
  input parameter style :: <GtkProgressBarStyle>;
  c-name: "gtk_progress_bar_set_bar_style";
end;

define C-function gtk-progress-bar-set-discrete-blocks
  input parameter pbar :: <GtkProgressBar>;
  input parameter blocks :: <guint>;
  c-name: "gtk_progress_bar_set_discrete_blocks";
end;

define C-function gtk-progress-bar-set-activity-step
  input parameter pbar :: <GtkProgressBar>;
  input parameter step :: <guint>;
  c-name: "gtk_progress_bar_set_activity_step";
end;

define C-function gtk-progress-bar-set-activity-blocks
  input parameter pbar :: <GtkProgressBar>;
  input parameter blocks :: <guint>;
  c-name: "gtk_progress_bar_set_activity_blocks";
end;

define C-function gtk-progress-bar-update
  input parameter pbar :: <GtkProgressBar>;
  input parameter percentage :: <gdouble>;
  c-name: "gtk_progress_bar_update";
end;

define C-function gtk-progress-get-type
  result res :: <GType>;
  c-name: "gtk_progress_get_type";
end;

define C-function gtk-progress-set-show-text
  input parameter progress :: <GtkProgress>;
  input parameter show_text :: <gboolean>;
  c-name: "gtk_progress_set_show_text";
end;

define C-function gtk-progress-set-text-alignment
  input parameter progress :: <GtkProgress>;
  input parameter x_align :: <gfloat>;
  input parameter y_align :: <gfloat>;
  c-name: "gtk_progress_set_text_alignment";
end;

define C-function gtk-progress-set-format-string
  input parameter progress :: <GtkProgress>;
  input parameter format :: <c-string>;
  c-name: "gtk_progress_set_format_string";
end;

define C-function gtk-progress-set-adjustment
  input parameter progress :: <GtkProgress>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_progress_set_adjustment";
end;

define C-function gtk-progress-configure
  input parameter progress :: <GtkProgress>;
  input parameter value :: <gdouble>;
  input parameter hmin :: <gdouble>;
  input parameter max :: <gdouble>;
  c-name: "gtk_progress_configure";
end;

define C-function gtk-progress-set-percentage
  input parameter progress :: <GtkProgress>;
  input parameter percentage :: <gdouble>;
  c-name: "gtk_progress_set_percentage";
end;

define C-function gtk-progress-set-value
  input parameter progress :: <GtkProgress>;
  input parameter value :: <gdouble>;
  c-name: "gtk_progress_set_value";
end;

define C-function gtk-progress-get-value
  input parameter progress :: <GtkProgress>;
  result res :: <gdouble>;
  c-name: "gtk_progress_get_value";
end;

define C-function gtk-progress-set-activity-mode
  input parameter progress :: <GtkProgress>;
  input parameter activity_mode :: <gboolean>;
  c-name: "gtk_progress_set_activity_mode";
end;

define C-function gtk-progress-get-current-text
  input parameter progress :: <GtkProgress>;
  result res :: <c-string>;
  c-name: "gtk_progress_get_current_text";
end;

define C-function gtk-progress-get-text-from-value
  input parameter progress :: <GtkProgress>;
  input parameter value :: <gdouble>;
  result res :: <c-string>;
  c-name: "gtk_progress_get_text_from_value";
end;

define C-function gtk-progress-get-current-percentage
  input parameter progress :: <GtkProgress>;
  result res :: <gdouble>;
  c-name: "gtk_progress_get_current_percentage";
end;

define C-function gtk-progress-get-percentage-from-value
  input parameter progress :: <GtkProgress>;
  input parameter value :: <gdouble>;
  result res :: <gdouble>;
  c-name: "gtk_progress_get_percentage_from_value";
end;

define C-subtype <_GtkPrintOperationPrivate> (<C-void*>) end;
define constant <GtkPrintOperationPrivate> = <_GtkPrintOperationPrivate>;

define C-subtype <_GtkPrintOperation> (<C-void*>) end;
define constant <GtkPrintOperation> = <_GtkPrintOperation>;

define constant <GtkPrintOperationResult> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PRINT-OPERATION-RESULT-ERROR :: <GtkPrintOperationResult> = 0;
define constant $GTK-PRINT-OPERATION-RESULT-APPLY :: <GtkPrintOperationResult> = 1;
define constant $GTK-PRINT-OPERATION-RESULT-CANCEL :: <GtkPrintOperationResult> = 2;
define constant $GTK-PRINT-OPERATION-RESULT-IN-PROGRESS :: <GtkPrintOperationResult> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7322>"*/
define C-subtype <_GtkPrintContext> (<C-void*>) end;
define constant <GtkPrintContext> = <_GtkPrintContext>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7323>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7324>"*/
define C-subtype <_GtkPageSetup> (<C-void*>) end;
define constant <GtkPageSetup> = <_GtkPageSetup>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7325>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7326>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7327>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7328>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7329>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7330>"*/
define C-subtype <_GtkPrintOperationPreview> (<C-void*>) end;
define constant <GtkPrintOperationPreview> = <_GtkPrintOperationPreview>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7331>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7332>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7333>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7334>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7335>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7336>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7337>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7338>"*/
define C-subtype <_GtkPrintOperationClass> (<C-void*>) end;
define constant <GtkPrintOperationClass> = <_GtkPrintOperationClass>;

define constant <GtkPrintStatus> = limited(<integer>, min: 0, max: 8);
define constant $GTK-PRINT-STATUS-INITIAL :: <GtkPrintStatus> = 0;
define constant $GTK-PRINT-STATUS-PREPARING :: <GtkPrintStatus> = 1;
define constant $GTK-PRINT-STATUS-GENERATING-DATA :: <GtkPrintStatus> = 2;
define constant $GTK-PRINT-STATUS-SENDING-DATA :: <GtkPrintStatus> = 3;
define constant $GTK-PRINT-STATUS-PENDING :: <GtkPrintStatus> = 4;
define constant $GTK-PRINT-STATUS-PENDING-ISSUE :: <GtkPrintStatus> = 5;
define constant $GTK-PRINT-STATUS-PRINTING :: <GtkPrintStatus> = 6;
define constant $GTK-PRINT-STATUS-FINISHED :: <GtkPrintStatus> = 7;
define constant $GTK-PRINT-STATUS-FINISHED-ABORTED :: <GtkPrintStatus> = 8;

define constant <GtkPrintOperationAction> = limited(<integer>, min: 0, max: 3);
define constant $GTK-PRINT-OPERATION-ACTION-PRINT-DIALOG :: <GtkPrintOperationAction> = 0;
define constant $GTK-PRINT-OPERATION-ACTION-PRINT :: <GtkPrintOperationAction> = 1;
define constant $GTK-PRINT-OPERATION-ACTION-PREVIEW :: <GtkPrintOperationAction> = 2;
define constant $GTK-PRINT-OPERATION-ACTION-EXPORT :: <GtkPrintOperationAction> = 3;

define constant <GtkPrintError> = limited(<integer>, min: 0, max: 2);
define constant $GTK-PRINT-ERROR-GENERAL :: <GtkPrintError> = 0;
define constant $GTK-PRINT-ERROR-INTERNAL-ERROR :: <GtkPrintError> = 1;
define constant $GTK-PRINT-ERROR-NOMEM :: <GtkPrintError> = 2;

define C-function gtk-print-error-quark
  result res :: <GQuark>;
  c-name: "gtk_print_error_quark";
end;

define C-function gtk-print-operation-get-type
  result res :: <GType>;
  c-name: "gtk_print_operation_get_type";
end;

define C-function gtk-print-operation-new
  result res :: <GtkPrintOperation>;
  c-name: "gtk_print_operation_new";
end;

define C-function gtk-print-operation-set-default-page-setup
  input parameter op :: <GtkPrintOperation>;
  input parameter default_page_setup :: <GtkPageSetup>;
  c-name: "gtk_print_operation_set_default_page_setup";
end;

define C-function gtk-print-operation-get-default-page-setup
  input parameter op :: <GtkPrintOperation>;
  result res :: <GtkPageSetup>;
  c-name: "gtk_print_operation_get_default_page_setup";
end;

define C-subtype <_GtkPrintSettings> (<C-void*>) end;
define constant <GtkPrintSettings> = <_GtkPrintSettings>;

define C-function gtk-print-operation-set-print-settings
  input parameter op :: <GtkPrintOperation>;
  input parameter print_settings :: <GtkPrintSettings>;
  c-name: "gtk_print_operation_set_print_settings";
end;

define C-function gtk-print-operation-get-print-settings
  input parameter op :: <GtkPrintOperation>;
  result res :: <GtkPrintSettings>;
  c-name: "gtk_print_operation_get_print_settings";
end;

define C-function gtk-print-operation-set-job-name
  input parameter op :: <GtkPrintOperation>;
  input parameter job_name :: <c-string>;
  c-name: "gtk_print_operation_set_job_name";
end;

define C-function gtk-print-operation-set-n-pages
  input parameter op :: <GtkPrintOperation>;
  input parameter n_pages :: <gint>;
  c-name: "gtk_print_operation_set_n_pages";
end;

define C-function gtk-print-operation-set-current-page
  input parameter op :: <GtkPrintOperation>;
  input parameter current_page :: <gint>;
  c-name: "gtk_print_operation_set_current_page";
end;

define C-function gtk-print-operation-set-use-full-page
  input parameter op :: <GtkPrintOperation>;
  input parameter full_page :: <gboolean>;
  c-name: "gtk_print_operation_set_use_full_page";
end;

define C-function gtk-print-operation-set-unit
  input parameter op :: <GtkPrintOperation>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_print_operation_set_unit";
end;

define C-function gtk-print-operation-set-export-filename
  input parameter op :: <GtkPrintOperation>;
  input parameter filename :: <c-string>;
  c-name: "gtk_print_operation_set_export_filename";
end;

define C-function gtk-print-operation-set-track-print-status
  input parameter op :: <GtkPrintOperation>;
  input parameter track_status :: <gboolean>;
  c-name: "gtk_print_operation_set_track_print_status";
end;

define C-function gtk-print-operation-set-show-progress
  input parameter op :: <GtkPrintOperation>;
  input parameter show_progress :: <gboolean>;
  c-name: "gtk_print_operation_set_show_progress";
end;

define C-function gtk-print-operation-set-allow-async
  input parameter op :: <GtkPrintOperation>;
  input parameter allow_async :: <gboolean>;
  c-name: "gtk_print_operation_set_allow_async";
end;

define C-function gtk-print-operation-set-custom-tab-label
  input parameter op :: <GtkPrintOperation>;
  input parameter label :: <c-string>;
  c-name: "gtk_print_operation_set_custom_tab_label";
end;

define C-function gtk-print-operation-run
  input parameter op :: <GtkPrintOperation>;
  input parameter action :: <GtkPrintOperationAction>;
  input parameter parent :: <GtkWindow>;
  input parameter error :: <GError*>;
  result res :: <GtkPrintOperationResult>;
  c-name: "gtk_print_operation_run";
end;

define C-function gtk-print-operation-get-error
  input parameter op :: <GtkPrintOperation>;
  input parameter error :: <GError*>;
  c-name: "gtk_print_operation_get_error";
end;

define C-function gtk-print-operation-get-status
  input parameter op :: <GtkPrintOperation>;
  result res :: <GtkPrintStatus>;
  c-name: "gtk_print_operation_get_status";
end;

define C-function gtk-print-operation-get-status-string
  input parameter op :: <GtkPrintOperation>;
  result res :: <c-string>;
  c-name: "gtk_print_operation_get_status_string";
end;

define C-function gtk-print-operation-is-finished
  input parameter op :: <GtkPrintOperation>;
  result res :: <gboolean>;
  c-name: "gtk_print_operation_is_finished";
end;

define C-function gtk-print-operation-cancel
  input parameter op :: <GtkPrintOperation>;
  c-name: "gtk_print_operation_cancel";
end;

define C-function gtk-print-run-page-setup-dialog
  input parameter parent :: <GtkWindow>;
  input parameter page_setup :: <GtkPageSetup>;
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPageSetup>;
  c-name: "gtk_print_run_page_setup_dialog";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7364>"*/
define constant <GtkPageSetupDoneFunc> = <anonymous-7364>;

define C-function gtk-print-run-page-setup-dialog-async
  input parameter parent :: <GtkWindow>;
  input parameter page_setup :: <GtkPageSetup>;
  input parameter settings :: <GtkPrintSettings>;
  input parameter done_cb :: <GtkPageSetupDoneFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_print_run_page_setup_dialog_async";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7303>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7304>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7305>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7306>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7307>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7308>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7309>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7310>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7311>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7312>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7313>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7314>"*/
define C-subtype <_GtkPrintOperationPreviewIface> (<C-void*>) end;
define constant <GtkPrintOperationPreviewIface> = <_GtkPrintOperationPreviewIface>;

define C-function gtk-print-operation-preview-get-type
  result res :: <GType>;
  c-name: "gtk_print_operation_preview_get_type";
end;

define C-function gtk-print-operation-preview-render-page
  input parameter preview :: <GtkPrintOperationPreview>;
  input parameter page_nr :: <gint>;
  c-name: "gtk_print_operation_preview_render_page";
end;

define C-function gtk-print-operation-preview-end-preview
  input parameter preview :: <GtkPrintOperationPreview>;
  c-name: "gtk_print_operation_preview_end_preview";
end;

define C-function gtk-print-operation-preview-is-selected
  input parameter preview :: <GtkPrintOperationPreview>;
  input parameter page_nr :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_print_operation_preview_is_selected";
end;

define C-function gtk-print-context-get-type
  result res :: <GType>;
  c-name: "gtk_print_context_get_type";
end;

define C-function gtk-print-context-get-cairo-context
  input parameter context :: <GtkPrintContext>;
  result res :: <cairo-t>;
  c-name: "gtk_print_context_get_cairo_context";
end;

define C-function gtk-print-context-get-page-setup
  input parameter context :: <GtkPrintContext>;
  result res :: <GtkPageSetup>;
  c-name: "gtk_print_context_get_page_setup";
end;

define C-function gtk-print-context-get-width
  input parameter context :: <GtkPrintContext>;
  result res :: <gdouble>;
  c-name: "gtk_print_context_get_width";
end;

define C-function gtk-print-context-get-height
  input parameter context :: <GtkPrintContext>;
  result res :: <gdouble>;
  c-name: "gtk_print_context_get_height";
end;

define C-function gtk-print-context-get-dpi-x
  input parameter context :: <GtkPrintContext>;
  result res :: <gdouble>;
  c-name: "gtk_print_context_get_dpi_x";
end;

define C-function gtk-print-context-get-dpi-y
  input parameter context :: <GtkPrintContext>;
  result res :: <gdouble>;
  c-name: "gtk_print_context_get_dpi_y";
end;

define C-function gtk-print-context-get-pango-fontmap
  input parameter context :: <GtkPrintContext>;
  result res :: <PangoFontMap>;
  c-name: "gtk_print_context_get_pango_fontmap";
end;

define C-function gtk-print-context-create-pango-context
  input parameter context :: <GtkPrintContext>;
  result res :: <PangoContext>;
  c-name: "gtk_print_context_create_pango_context";
end;

define C-function gtk-print-context-create-pango-layout
  input parameter context :: <GtkPrintContext>;
  result res :: <PangoLayout>;
  c-name: "gtk_print_context_create_pango_layout";
end;

define C-function gtk-print-context-set-cairo-context
  input parameter context :: <GtkPrintContext>;
  input parameter cr :: <cairo-t>;
  input parameter dpi_x :: <double-float>;
  input parameter dpi_y :: <double-float>;
  c-name: "gtk_print_context_set_cairo_context";
end;

define C-function gtk-page-setup-get-type
  result res :: <GType>;
  c-name: "gtk_page_setup_get_type";
end;

define C-function gtk-page-setup-new
  result res :: <GtkPageSetup>;
  c-name: "gtk_page_setup_new";
end;

define C-function gtk-page-setup-copy
  input parameter other :: <GtkPageSetup>;
  result res :: <GtkPageSetup>;
  c-name: "gtk_page_setup_copy";
end;

define C-function gtk-page-setup-get-orientation
  input parameter setup :: <GtkPageSetup>;
  result res :: <GtkPageOrientation>;
  c-name: "gtk_page_setup_get_orientation";
end;

define C-function gtk-page-setup-set-orientation
  input parameter setup :: <GtkPageSetup>;
  input parameter orientation :: <GtkPageOrientation>;
  c-name: "gtk_page_setup_set_orientation";
end;

define C-subtype <_GtkPaperSize> (<C-void*>) end;
define constant <GtkPaperSize> = <_GtkPaperSize>;

define C-function gtk-page-setup-get-paper-size
  input parameter setup :: <GtkPageSetup>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_page_setup_get_paper_size";
end;

define C-function gtk-page-setup-set-paper-size
  input parameter setup :: <GtkPageSetup>;
  input parameter size :: <GtkPaperSize>;
  c-name: "gtk_page_setup_set_paper_size";
end;

define C-function gtk-page-setup-get-top-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_top_margin";
end;

define C-function gtk-page-setup-set-top-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter margin :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_page_setup_set_top_margin";
end;

define C-function gtk-page-setup-get-bottom-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_bottom_margin";
end;

define C-function gtk-page-setup-set-bottom-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter margin :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_page_setup_set_bottom_margin";
end;

define C-function gtk-page-setup-get-left-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_left_margin";
end;

define C-function gtk-page-setup-set-left-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter margin :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_page_setup_set_left_margin";
end;

define C-function gtk-page-setup-get-right-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_right_margin";
end;

define C-function gtk-page-setup-set-right-margin
  input parameter setup :: <GtkPageSetup>;
  input parameter margin :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_page_setup_set_right_margin";
end;

define C-function gtk-page-setup-set-paper-size-and-default-margins
  input parameter setup :: <GtkPageSetup>;
  input parameter size :: <GtkPaperSize>;
  c-name: "gtk_page_setup_set_paper_size_and_default_margins";
end;

define C-function gtk-page-setup-get-paper-width
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_paper_width";
end;

define C-function gtk-page-setup-get-paper-height
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_paper_height";
end;

define C-function gtk-page-setup-get-page-width
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_page_width";
end;

define C-function gtk-page-setup-get-page-height
  input parameter setup :: <GtkPageSetup>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_page_setup_get_page_height";
end;

define C-function gtk-paper-size-get-type
  result res :: <GType>;
  c-name: "gtk_paper_size_get_type";
end;

define C-function gtk-paper-size-new
  input parameter name :: <c-string>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_paper_size_new";
end;

define C-function gtk-paper-size-new-from-ppd
  input parameter ppd_name :: <c-string>;
  input parameter ppd_display_name :: <c-string>;
  input parameter width :: <gdouble>;
  input parameter height :: <gdouble>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_paper_size_new_from_ppd";
end;

define C-function gtk-paper-size-new-custom
  input parameter name :: <c-string>;
  input parameter display_name :: <c-string>;
  input parameter width :: <gdouble>;
  input parameter height :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_paper_size_new_custom";
end;

define C-function gtk-paper-size-copy
  input parameter other :: <GtkPaperSize>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_paper_size_copy";
end;

define C-function gtk-paper-size-free
  input parameter size :: <GtkPaperSize>;
  c-name: "gtk_paper_size_free";
end;

define C-function gtk-paper-size-is-equal
  input parameter size1 :: <GtkPaperSize>;
  input parameter size2 :: <GtkPaperSize>;
  result res :: <gboolean>;
  c-name: "gtk_paper_size_is_equal";
end;

define C-function gtk-paper-size-get-name
  input parameter size :: <GtkPaperSize>;
  result res :: <c-string>;
  c-name: "gtk_paper_size_get_name";
end;

define C-function gtk-paper-size-get-display-name
  input parameter size :: <GtkPaperSize>;
  result res :: <c-string>;
  c-name: "gtk_paper_size_get_display_name";
end;

define C-function gtk-paper-size-get-ppd-name
  input parameter size :: <GtkPaperSize>;
  result res :: <c-string>;
  c-name: "gtk_paper_size_get_ppd_name";
end;

define C-function gtk-paper-size-get-width
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_width";
end;

define C-function gtk-paper-size-get-height
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_height";
end;

define C-function gtk-paper-size-is-custom
  input parameter size :: <GtkPaperSize>;
  result res :: <gboolean>;
  c-name: "gtk_paper_size_is_custom";
end;

define C-function gtk-paper-size-set-size
  input parameter size :: <GtkPaperSize>;
  input parameter width :: <gdouble>;
  input parameter height :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_paper_size_set_size";
end;

define C-function gtk-paper-size-get-default-top-margin
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_default_top_margin";
end;

define C-function gtk-paper-size-get-default-bottom-margin
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_default_bottom_margin";
end;

define C-function gtk-paper-size-get-default-left-margin
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_default_left_margin";
end;

define C-function gtk-paper-size-get-default-right-margin
  input parameter size :: <GtkPaperSize>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_paper_size_get_default_right_margin";
end;

define C-function gtk-paper-size-get-default
  result res :: <c-string>;
  c-name: "gtk_paper_size_get_default";
end;

define constant $GTK-PAPER-NAME-A3 = "iso_a3";

define constant $GTK-PAPER-NAME-A4 = "iso_a4";

define constant $GTK-PAPER-NAME-A5 = "iso_a5";

define constant $GTK-PAPER-NAME-B5 = "iso_b5";

define constant $GTK-PAPER-NAME-LETTER = "na_letter";

define constant $GTK-PAPER-NAME-EXECUTIVE = "na_executive";

define constant $GTK-PAPER-NAME-LEGAL = "na_legal";

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7229>"*/
define constant <GtkPrintSettingsFunc> = <anonymous-7229>;

define C-subtype <_GtkPageRange> (<C-void*>) end;
define constant <GtkPageRange> = <_GtkPageRange>;

define C-function gtk-print-settings-get-type
  result res :: <GType>;
  c-name: "gtk_print_settings_get_type";
end;

define C-function gtk-print-settings-new
  result res :: <GtkPrintSettings>;
  c-name: "gtk_print_settings_new";
end;

define C-function gtk-print-settings-copy
  input parameter other :: <GtkPrintSettings>;
  result res :: <GtkPrintSettings>;
  c-name: "gtk_print_settings_copy";
end;

define C-function gtk-print-settings-has-key
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_print_settings_has_key";
end;

define C-function gtk-print-settings-get
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get";
end;

define C-function gtk-print-settings-set
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter value :: <c-string>;
  c-name: "gtk_print_settings_set";
end;

define C-function gtk-print-settings-unset
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  c-name: "gtk_print_settings_unset";
end;

define C-function gtk-print-settings-foreach
  input parameter settings :: <GtkPrintSettings>;
  input parameter func :: <GtkPrintSettingsFunc>;
  input parameter user_data :: <gpointer>;
  c-name: "gtk_print_settings_foreach";
end;

define C-function gtk-print-settings-get-bool
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_print_settings_get_bool";
end;

define C-function gtk-print-settings-set-bool
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter value :: <gboolean>;
  c-name: "gtk_print_settings_set_bool";
end;

define C-function gtk-print-settings-get-double
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_double";
end;

define C-function gtk-print-settings-get-double-with-default
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter def :: <gdouble>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_double_with_default";
end;

define C-function gtk-print-settings-set-double
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter value :: <gdouble>;
  c-name: "gtk_print_settings_set_double";
end;

define C-function gtk-print-settings-get-length
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_length";
end;

define C-function gtk-print-settings-set-length
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter value :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_print_settings_set_length";
end;

define C-function gtk-print-settings-get-int
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  result res :: <gint>;
  c-name: "gtk_print_settings_get_int";
end;

define C-function gtk-print-settings-get-int-with-default
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter def :: <gint>;
  result res :: <gint>;
  c-name: "gtk_print_settings_get_int_with_default";
end;

define C-function gtk-print-settings-set-int
  input parameter settings :: <GtkPrintSettings>;
  input parameter key :: <c-string>;
  input parameter value :: <gint>;
  c-name: "gtk_print_settings_set_int";
end;

define C-function gtk-print-settings-get-printer
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_printer";
end;

define C-function gtk-print-settings-set-printer
  input parameter settings :: <GtkPrintSettings>;
  input parameter printer :: <c-string>;
  c-name: "gtk_print_settings_set_printer";
end;

define C-function gtk-print-settings-get-orientation
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPageOrientation>;
  c-name: "gtk_print_settings_get_orientation";
end;

define C-function gtk-print-settings-set-orientation
  input parameter settings :: <GtkPrintSettings>;
  input parameter orientation :: <GtkPageOrientation>;
  c-name: "gtk_print_settings_set_orientation";
end;

define C-function gtk-print-settings-get-paper-size
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPaperSize>;
  c-name: "gtk_print_settings_get_paper_size";
end;

define C-function gtk-print-settings-set-paper-size
  input parameter settings :: <GtkPrintSettings>;
  input parameter paper_size :: <GtkPaperSize>;
  c-name: "gtk_print_settings_set_paper_size";
end;

define C-function gtk-print-settings-get-paper-width
  input parameter settings :: <GtkPrintSettings>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_paper_width";
end;

define C-function gtk-print-settings-set-paper-width
  input parameter settings :: <GtkPrintSettings>;
  input parameter width :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_print_settings_set_paper_width";
end;

define C-function gtk-print-settings-get-paper-height
  input parameter settings :: <GtkPrintSettings>;
  input parameter unit :: <GtkUnit>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_paper_height";
end;

define C-function gtk-print-settings-set-paper-height
  input parameter settings :: <GtkPrintSettings>;
  input parameter height :: <gdouble>;
  input parameter unit :: <GtkUnit>;
  c-name: "gtk_print_settings_set_paper_height";
end;

define C-function gtk-print-settings-get-use-color
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gboolean>;
  c-name: "gtk_print_settings_get_use_color";
end;

define C-function gtk-print-settings-set-use-color
  input parameter settings :: <GtkPrintSettings>;
  input parameter use_color :: <gboolean>;
  c-name: "gtk_print_settings_set_use_color";
end;

define C-function gtk-print-settings-get-collate
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gboolean>;
  c-name: "gtk_print_settings_get_collate";
end;

define C-function gtk-print-settings-set-collate
  input parameter settings :: <GtkPrintSettings>;
  input parameter collate :: <gboolean>;
  c-name: "gtk_print_settings_set_collate";
end;

define C-function gtk-print-settings-get-reverse
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gboolean>;
  c-name: "gtk_print_settings_get_reverse";
end;

define C-function gtk-print-settings-set-reverse
  input parameter settings :: <GtkPrintSettings>;
  input parameter reverse :: <gboolean>;
  c-name: "gtk_print_settings_set_reverse";
end;

define C-function gtk-print-settings-get-duplex
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPrintDuplex>;
  c-name: "gtk_print_settings_get_duplex";
end;

define C-function gtk-print-settings-set-duplex
  input parameter settings :: <GtkPrintSettings>;
  input parameter duplex :: <GtkPrintDuplex>;
  c-name: "gtk_print_settings_set_duplex";
end;

define C-function gtk-print-settings-get-quality
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPrintQuality>;
  c-name: "gtk_print_settings_get_quality";
end;

define C-function gtk-print-settings-set-quality
  input parameter settings :: <GtkPrintSettings>;
  input parameter quality :: <GtkPrintQuality>;
  c-name: "gtk_print_settings_set_quality";
end;

define C-function gtk-print-settings-get-n-copies
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gint>;
  c-name: "gtk_print_settings_get_n_copies";
end;

define C-function gtk-print-settings-set-n-copies
  input parameter settings :: <GtkPrintSettings>;
  input parameter num_copies :: <gint>;
  c-name: "gtk_print_settings_set_n_copies";
end;

define C-function gtk-print-settings-get-number-up
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gint>;
  c-name: "gtk_print_settings_get_number_up";
end;

define C-function gtk-print-settings-set-number-up
  input parameter settings :: <GtkPrintSettings>;
  input parameter number_up :: <gint>;
  c-name: "gtk_print_settings_set_number_up";
end;

define C-function gtk-print-settings-get-resolution
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gint>;
  c-name: "gtk_print_settings_get_resolution";
end;

define C-function gtk-print-settings-set-resolution
  input parameter settings :: <GtkPrintSettings>;
  input parameter resolution :: <gint>;
  c-name: "gtk_print_settings_set_resolution";
end;

define C-function gtk-print-settings-get-scale
  input parameter settings :: <GtkPrintSettings>;
  result res :: <gdouble>;
  c-name: "gtk_print_settings_get_scale";
end;

define C-function gtk-print-settings-set-scale
  input parameter settings :: <GtkPrintSettings>;
  input parameter scale :: <gdouble>;
  c-name: "gtk_print_settings_set_scale";
end;

define C-function gtk-print-settings-get-print-pages
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPrintPages>;
  c-name: "gtk_print_settings_get_print_pages";
end;

define C-function gtk-print-settings-set-print-pages
  input parameter settings :: <GtkPrintSettings>;
  input parameter pages :: <GtkPrintPages>;
  c-name: "gtk_print_settings_set_print_pages";
end;

define C-function gtk-print-settings-get-page-ranges
  input parameter settings :: <GtkPrintSettings>;
  input parameter num_ranges :: <gint*>;
  result res :: <GtkPageRange>;
  c-name: "gtk_print_settings_get_page_ranges";
end;

define C-function gtk-print-settings-set-page-ranges
  input parameter settings :: <GtkPrintSettings>;
  input parameter page_ranges :: <GtkPageRange>;
  input parameter num_ranges :: <gint>;
  c-name: "gtk_print_settings_set_page_ranges";
end;

define C-function gtk-print-settings-get-page-set
  input parameter settings :: <GtkPrintSettings>;
  result res :: <GtkPageSet>;
  c-name: "gtk_print_settings_get_page_set";
end;

define C-function gtk-print-settings-set-page-set
  input parameter settings :: <GtkPrintSettings>;
  input parameter page_set :: <GtkPageSet>;
  c-name: "gtk_print_settings_set_page_set";
end;

define C-function gtk-print-settings-get-default-source
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_default_source";
end;

define C-function gtk-print-settings-set-default-source
  input parameter settings :: <GtkPrintSettings>;
  input parameter default_source :: <c-string>;
  c-name: "gtk_print_settings_set_default_source";
end;

define C-function gtk-print-settings-get-media-type
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_media_type";
end;

define C-function gtk-print-settings-set-media-type
  input parameter settings :: <GtkPrintSettings>;
  input parameter media_type :: <c-string>;
  c-name: "gtk_print_settings_set_media_type";
end;

define C-function gtk-print-settings-get-dither
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_dither";
end;

define C-function gtk-print-settings-set-dither
  input parameter settings :: <GtkPrintSettings>;
  input parameter dither :: <c-string>;
  c-name: "gtk_print_settings_set_dither";
end;

define C-function gtk-print-settings-get-finishings
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_finishings";
end;

define C-function gtk-print-settings-set-finishings
  input parameter settings :: <GtkPrintSettings>;
  input parameter finishings :: <c-string>;
  c-name: "gtk_print_settings_set_finishings";
end;

define C-function gtk-print-settings-get-output-bin
  input parameter settings :: <GtkPrintSettings>;
  result res :: <c-string>;
  c-name: "gtk_print_settings_get_output_bin";
end;

define C-function gtk-print-settings-set-output-bin
  input parameter settings :: <GtkPrintSettings>;
  input parameter output_bin :: <c-string>;
  c-name: "gtk_print_settings_set_output_bin";
end;

define constant $GTK-PRINT-SETTINGS-PRINTER = "printer";

define constant $GTK-PRINT-SETTINGS-ORIENTATION = "orientation";

define constant $GTK-PRINT-SETTINGS-PAPER-FORMAT = "paper-format";

define constant $GTK-PRINT-SETTINGS-PAPER-WIDTH = "paper-width";

define constant $GTK-PRINT-SETTINGS-PAPER-HEIGHT = "paper-height";

define constant $GTK-PRINT-SETTINGS-N-COPIES = "n-copies";

define constant $GTK-PRINT-SETTINGS-DEFAULT-SOURCE = "default-source";

define constant $GTK-PRINT-SETTINGS-QUALITY = "quality";

define constant $GTK-PRINT-SETTINGS-RESOLUTION = "resolution";

define constant $GTK-PRINT-SETTINGS-USE-COLOR = "use-color";

define constant $GTK-PRINT-SETTINGS-DUPLEX = "duplex";

define constant $GTK-PRINT-SETTINGS-COLLATE = "collate";

define constant $GTK-PRINT-SETTINGS-REVERSE = "reverse";

define constant $GTK-PRINT-SETTINGS-MEDIA-TYPE = "media-type";

define constant $GTK-PRINT-SETTINGS-DITHER = "dither";

define constant $GTK-PRINT-SETTINGS-SCALE = "scale";

define constant $GTK-PRINT-SETTINGS-PRINT-PAGES = "print-pages";

define constant $GTK-PRINT-SETTINGS-PAGE-RANGES = "page-ranges";

define constant $GTK-PRINT-SETTINGS-PAGE-SET = "page-set";

define constant $GTK-PRINT-SETTINGS-FINISHINGS = "finishings";

define constant $GTK-PRINT-SETTINGS-NUMBER-UP = "number-up";

define constant $GTK-PRINT-SETTINGS-OUTPUT-BIN = "output-bin";

define constant $GTK-PRINT-SETTINGS-OUTPUT-FILE-FORMAT = "output-file-format";

define constant $GTK-PRINT-SETTINGS-OUTPUT-URI = "output-uri";

define constant $GTK-PRINT-SETTINGS-WIN32-DRIVER-VERSION = "win32-driver-version";

define constant $GTK-PRINT-SETTINGS-WIN32-DRIVER-EXTRA = "win32-driver-extra";

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6863>"*/
define constant <GtkKeySnoopFunc> = <anonymous-6863>;

 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-major-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-minor-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-micro-version"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-binary-age"*/
 /* Ignoring declaration for {instance of <variable-declaration>} "gtk-interface-age"*/
define C-function gtk-check-version
  input parameter required_major :: <guint>;
  input parameter required_minor :: <guint>;
  input parameter required_micro :: <guint>;
  result res :: <c-string>;
  c-name: "gtk_check_version";
end;

define C-pointer-type <char***> => <c-string-vector>;
define C-function gtk-parse-args
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  result res :: <gboolean>;
  c-name: "gtk_parse_args";
end;

define C-function %gtk-init
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  c-name: "gtk_init";
end;

define C-function gtk-init-check
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  result res :: <gboolean>;
  c-name: "gtk_init_check";
end;

define C-function gtk-init-with-args
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  input parameter parameter_string :: <c-string>;
  input parameter entries :: <GOptionEntry>;
  input parameter translation_domain :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_init_with_args";
end;

define C-function gtk-get-option-group
  input parameter open_default_display :: <gboolean>;
  result res :: <GOptionGroup>;
  c-name: "gtk_get_option_group";
end;

define C-function gtk-init-abi-check
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  input parameter num_checks :: <integer>;
  input parameter sizeof_GtkWindow :: <size-t>;
  input parameter sizeof_GtkBox :: <size-t>;
  c-name: "gtk_init_abi_check";
end;

define C-function gtk-init-check-abi-check
  input parameter argc :: <int*>;
  input parameter argv :: <char***>;
  input parameter num_checks :: <integer>;
  input parameter sizeof_GtkWindow :: <size-t>;
  input parameter sizeof_GtkBox :: <size-t>;
  result res :: <gboolean>;
  c-name: "gtk_init_check_abi_check";
end;

define C-function gtk-exit
  input parameter error_code :: <gint>;
  c-name: "gtk_exit";
end;

define C-function gtk-disable-setlocale
  c-name: "gtk_disable_setlocale";
end;

define C-function gtk-set-locale
  result res :: <c-string>;
  c-name: "gtk_set_locale";
end;

define C-function gtk-get-default-language
  result res :: <PangoLanguage>;
  c-name: "gtk_get_default_language";
end;

define C-function gtk-events-pending
  result res :: <gboolean>;
  c-name: "gtk_events_pending";
end;

define C-function gtk-main-do-event
  input parameter event :: <GdkEvent>;
  c-name: "gtk_main_do_event";
end;

define C-function gtk-main
  c-name: "gtk_main";
end;

define C-function gtk-main-level
  result res :: <guint>;
  c-name: "gtk_main_level";
end;

define C-function gtk-main-quit
  c-name: "gtk_main_quit";
end;

define C-function gtk-main-iteration
  result res :: <gboolean>;
  c-name: "gtk_main_iteration";
end;

define C-function gtk-main-iteration-do
  input parameter blocking :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_main_iteration_do";
end;

define C-function gtk-true
  result res :: <gboolean>;
  c-name: "gtk_true";
end;

define C-function gtk-false
  result res :: <gboolean>;
  c-name: "gtk_false";
end;

define C-function gtk-grab-add
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_grab_add";
end;

define C-function gtk-grab-get-current
  result res :: <GtkWidget>;
  c-name: "gtk_grab_get_current";
end;

define C-function gtk-grab-remove
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_grab_remove";
end;

define C-function gtk-init-add
  input parameter function :: <GtkFunction>;
  input parameter data :: <gpointer>;
  c-name: "gtk_init_add";
end;

define C-function gtk-quit-add-destroy
  input parameter main_level :: <guint>;
  input parameter object :: <GtkObject>;
  c-name: "gtk_quit_add_destroy";
end;

define C-function gtk-quit-add
  input parameter main_level :: <guint>;
  input parameter function :: <GtkFunction>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "gtk_quit_add";
end;

define C-function gtk-quit-add-full
  input parameter main_level :: <guint>;
  input parameter function :: <GtkFunction>;
  input parameter marshal :: <GtkCallbackMarshal>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  result res :: <guint>;
  c-name: "gtk_quit_add_full";
end;

define C-function gtk-quit-remove
  input parameter quit_handler_id :: <guint>;
  c-name: "gtk_quit_remove";
end;

define C-function gtk-quit-remove-by-data
  input parameter data :: <gpointer>;
  c-name: "gtk_quit_remove_by_data";
end;

define C-function gtk-timeout-add
  input parameter interval :: <guint32>;
  input parameter function :: <GtkFunction>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "gtk_timeout_add";
end;

define C-function gtk-timeout-add-full
  input parameter interval :: <guint32>;
  input parameter function :: <GtkFunction>;
  input parameter marshal :: <GtkCallbackMarshal>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  result res :: <guint>;
  c-name: "gtk_timeout_add_full";
end;

define C-function gtk-timeout-remove
  input parameter timeout_handler_id :: <guint>;
  c-name: "gtk_timeout_remove";
end;

define C-function gtk-idle-add
  input parameter function :: <GtkFunction>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "gtk_idle_add";
end;

define C-function gtk-idle-add-priority
  input parameter priority :: <gint>;
  input parameter function :: <GtkFunction>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "gtk_idle_add_priority";
end;

define C-function gtk-idle-add-full
  input parameter priority :: <gint>;
  input parameter function :: <GtkFunction>;
  input parameter marshal :: <GtkCallbackMarshal>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  result res :: <guint>;
  c-name: "gtk_idle_add_full";
end;

define C-function gtk-idle-remove
  input parameter idle_handler_id :: <guint>;
  c-name: "gtk_idle_remove";
end;

define C-function gtk-idle-remove-by-data
  input parameter data :: <gpointer>;
  c-name: "gtk_idle_remove_by_data";
end;

define C-function gtk-input-add-full
  input parameter source :: <gint>;
  input parameter condition :: <GdkInputCondition>;
  input parameter function :: <GdkInputFunction>;
  input parameter marshal :: <GtkCallbackMarshal>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  result res :: <guint>;
  c-name: "gtk_input_add_full";
end;

define C-function gtk-input-remove
  input parameter input_handler_id :: <guint>;
  c-name: "gtk_input_remove";
end;

define C-function gtk-key-snooper-install
  input parameter snooper :: <GtkKeySnoopFunc>;
  input parameter func_data :: <gpointer>;
  result res :: <guint>;
  c-name: "gtk_key_snooper_install";
end;

define C-function gtk-key-snooper-remove
  input parameter snooper_handler_id :: <guint>;
  c-name: "gtk_key_snooper_remove";
end;

define C-function gtk-get-current-event
  result res :: <GdkEvent>;
  c-name: "gtk_get_current_event";
end;

define C-function gtk-get-current-event-time
  result res :: <guint32>;
  c-name: "gtk_get_current_event_time";
end;

define C-function gtk-get-current-event-state
  input parameter state :: <GdkModifierType*>;
  result res :: <gboolean>;
  c-name: "gtk_get_current_event_state";
end;

define C-function gtk-get-event-widget
  input parameter event :: <GdkEvent>;
  result res :: <GtkWidget>;
  c-name: "gtk_get_event_widget";
end;

define C-function gtk-propagate-event
  input parameter widget :: <GtkWidget>;
  input parameter event :: <GdkEvent>;
  c-name: "gtk_propagate_event";
end;

define C-function _gtk-boolean-handled-accumulator
  input parameter ihint :: <GSignalInvocationHint>;
  input parameter return_accu :: <GValue>;
  input parameter handler_return :: <GValue>;
  input parameter dummy :: <gpointer>;
  result res :: <gboolean>;
  c-name: "_gtk_boolean_handled_accumulator";
end;

define C-function _gtk-get-lc-ctype
  result res :: <c-string>;
  c-name: "_gtk_get_lc_ctype";
end;

define constant $GTK-PRIORITY-RESIZE = 110;

define constant $GTK-PRIORITY-REDRAW = 120;

define constant $GTK-PRIORITY-HIGH = -100;

define constant $GTK-PRIORITY-INTERNAL = 120;

define constant $GTK-PRIORITY-DEFAULT = 200;

define constant $GTK-PRIORITY-LOW = 300;

define C-subtype <_GtkPreview> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkPreview> = <_GtkPreview>;

define C-subtype <_GtkPreviewInfo> (<C-void*>) end;
define constant <GtkPreviewInfo> = <_GtkPreviewInfo>;

define C-pointer-type <gushort*> => <gushort>;
 /* Ignoring declaration for {instance of <vector-declaration>} "<gushort<@2>>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<guchar<@4>>"*/
 /* Ignoring declaration for {instance of <union-declaration>} "<_GtkDitherInfo>"*/
define constant <GtkDitherInfo> = <_GtkDitherInfo>;

define C-subtype <_GtkPreviewClass> (<C-void*>) end;
define constant <GtkPreviewClass> = <_GtkPreviewClass>;

define C-function gtk-preview-get-type
  result res :: <GtkType>;
  c-name: "gtk_preview_get_type";
end;

define C-function gtk-preview-uninit
  c-name: "gtk_preview_uninit";
end;

define C-function gtk-preview-new
  input parameter type :: <GtkPreviewType>;
  result res :: <GtkWidget>;
  c-name: "gtk_preview_new";
end;

define C-function gtk-preview-size
  input parameter preview :: <GtkPreview>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_preview_size";
end;

define C-function gtk-preview-put
  input parameter preview :: <GtkPreview>;
  input parameter window :: <GdkWindow>;
  input parameter gc :: <GdkGC>;
  input parameter srcx :: <gint>;
  input parameter srcy :: <gint>;
  input parameter destx :: <gint>;
  input parameter desty :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_preview_put";
end;

define C-function gtk-preview-draw-row
  input parameter preview :: <GtkPreview>;
  input parameter data :: <guchar*>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter w :: <gint>;
  c-name: "gtk_preview_draw_row";
end;

define C-function gtk-preview-set-expand
  input parameter preview :: <GtkPreview>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_preview_set_expand";
end;

define C-function gtk-preview-set-gamma
  input parameter gamma_ :: <double-float>;
  c-name: "gtk_preview_set_gamma";
end;

define C-function gtk-preview-set-color-cube
  input parameter nred_shades :: <guint>;
  input parameter ngreen_shades :: <guint>;
  input parameter nblue_shades :: <guint>;
  input parameter ngray_shades :: <guint>;
  c-name: "gtk_preview_set_color_cube";
end;

define C-function gtk-preview-set-install-cmap
  input parameter install_cmap :: <gint>;
  c-name: "gtk_preview_set_install_cmap";
end;

define C-function gtk-preview-set-reserved
  input parameter nreserved :: <gint>;
  c-name: "gtk_preview_set_reserved";
end;

define C-function gtk-preview-set-dither
  input parameter preview :: <GtkPreview>;
  input parameter dither :: <GdkRgbDither>;
  c-name: "gtk_preview_set_dither";
end;

define C-function gtk-preview-get-visual
  result res :: <GdkVisual>;
  c-name: "gtk_preview_get_visual";
end;

define C-function gtk-preview-get-cmap
  result res :: <GdkColormap>;
  c-name: "gtk_preview_get_cmap";
end;

define C-function gtk-preview-get-info
  result res :: <GtkPreviewInfo>;
  c-name: "gtk_preview_get_info";
end;

define C-function gtk-preview-reset
  c-name: "gtk_preview_reset";
end;

define C-subtype <_GtkPlug> (<GtkWindow>, <AtkImplementorIface>) end;
define constant <GtkPlug> = <_GtkPlug>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7159>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7160>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7161>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7162>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7163>"*/
define C-subtype <_GtkPlugClass> (<C-void*>) end;
define constant <GtkPlugClass> = <_GtkPlugClass>;

define C-function gtk-plug-get-type
  result res :: <GType>;
  c-name: "gtk_plug_get_type";
end;

define C-function gtk-plug-construct
  input parameter plug :: <GtkPlug>;
  input parameter socket_id :: <GdkNativeWindow>;
  c-name: "gtk_plug_construct";
end;

define C-function gtk-plug-new
  input parameter socket_id :: <GdkNativeWindow>;
  result res :: <GtkWidget>;
  c-name: "gtk_plug_new";
end;

define C-function gtk-plug-construct-for-display
  input parameter plug :: <GtkPlug>;
  input parameter display :: <GdkDisplay>;
  input parameter socket_id :: <GdkNativeWindow>;
  c-name: "gtk_plug_construct_for_display";
end;

define C-function gtk-plug-new-for-display
  input parameter display :: <GdkDisplay>;
  input parameter socket_id :: <GdkNativeWindow>;
  result res :: <GtkWidget>;
  c-name: "gtk_plug_new_for_display";
end;

define C-function gtk-plug-get-id
  input parameter plug :: <GtkPlug>;
  result res :: <GdkNativeWindow>;
  c-name: "gtk_plug_get_id";
end;

define C-function _gtk-plug-add-to-socket
  input parameter plug :: <GtkPlug>;
  input parameter socket_ :: <GtkSocket>;
  c-name: "_gtk_plug_add_to_socket";
end;

define C-function _gtk-plug-remove-from-socket
  input parameter plug :: <GtkPlug>;
  input parameter socket_ :: <GtkSocket>;
  c-name: "_gtk_plug_remove_from_socket";
end;

define C-subtype <_GtkOptionMenu> (<GtkButton>, <AtkImplementorIface>) end;
define constant <GtkOptionMenu> = <_GtkOptionMenu>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7123>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7124>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7125>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7126>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7127>"*/
define C-subtype <_GtkOptionMenuClass> (<C-void*>) end;
define constant <GtkOptionMenuClass> = <_GtkOptionMenuClass>;

define C-function gtk-option-menu-get-type
  result res :: <GType>;
  c-name: "gtk_option_menu_get_type";
end;

define C-function gtk-option-menu-new
  result res :: <GtkWidget>;
  c-name: "gtk_option_menu_new";
end;

define C-function gtk-option-menu-get-menu
  input parameter option_menu :: <GtkOptionMenu>;
  result res :: <GtkWidget>;
  c-name: "gtk_option_menu_get_menu";
end;

define C-function gtk-option-menu-set-menu
  input parameter option_menu :: <GtkOptionMenu>;
  input parameter menu :: <GtkWidget>;
  c-name: "gtk_option_menu_set_menu";
end;

define C-function gtk-option-menu-remove-menu
  input parameter option_menu :: <GtkOptionMenu>;
  c-name: "gtk_option_menu_remove_menu";
end;

define C-function gtk-option-menu-get-history
  input parameter option_menu :: <GtkOptionMenu>;
  result res :: <gint>;
  c-name: "gtk_option_menu_get_history";
end;

define C-function gtk-option-menu-set-history
  input parameter option_menu :: <GtkOptionMenu>;
  input parameter index_ :: <guint>;
  c-name: "gtk_option_menu_set_history";
end;

define C-subtype <_GtkOldEditable> (<C-void*>) end;
define constant <GtkOldEditable> = <_GtkOldEditable>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7103>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7104>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7105>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7106>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7107>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7108>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7109>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7110>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7111>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7112>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7113>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7114>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7115>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7116>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7117>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7118>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7119>"*/
define C-subtype <_GtkOldEditableClass> (<C-void*>) end;
define constant <GtkOldEditableClass> = <_GtkOldEditableClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7099>"*/
define constant <GtkTextFunction> = <anonymous-7099>;

define C-function gtk-old-editable-get-type
  result res :: <GtkType>;
  c-name: "gtk_old_editable_get_type";
end;

define C-function gtk-old-editable-claim-selection
  input parameter old_editable :: <GtkOldEditable>;
  input parameter claim :: <gboolean>;
  input parameter time_ :: <guint32>;
  c-name: "gtk_old_editable_claim_selection";
end;

define C-function gtk-old-editable-changed
  input parameter old_editable :: <GtkOldEditable>;
  c-name: "gtk_old_editable_changed";
end;

define constant <GtkNotebookTab> = limited(<integer>, min: 0, max: 1);
define constant $GTK-NOTEBOOK-TAB-FIRST :: <GtkNotebookTab> = 0;
define constant $GTK-NOTEBOOK-TAB-LAST :: <GtkNotebookTab> = 1;

define C-subtype <_GtkNotebookPage> (<C-void*>) end;
define constant <GtkNotebookPage> = <_GtkNotebookPage>;

define C-subtype <_GtkNotebook> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkNotebook> = <_GtkNotebook>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7041>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7042>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7043>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7044>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7045>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7046>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7047>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7048>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7049>"*/
define C-subtype <_GtkNotebookClass> (<C-void*>) end;
define constant <GtkNotebookClass> = <_GtkNotebookClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7050>"*/
define constant <GtkNotebookWindowCreationFunc> = <anonymous-7050>;

define C-function gtk-notebook-get-type
  result res :: <GType>;
  c-name: "gtk_notebook_get_type";
end;

define C-function gtk-notebook-new
  result res :: <GtkWidget>;
  c-name: "gtk_notebook_new";
end;

define C-function gtk-notebook-append-page
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_notebook_append_page";
end;

define C-function gtk-notebook-append-page-menu
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  input parameter menu_label :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_notebook_append_page_menu";
end;

define C-function gtk-notebook-prepend-page
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_notebook_prepend_page";
end;

define C-function gtk-notebook-prepend-page-menu
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  input parameter menu_label :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_notebook_prepend_page_menu";
end;

define C-function gtk-notebook-insert-page
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  input parameter position :: <gint>;
  result res :: <gint>;
  c-name: "gtk_notebook_insert_page";
end;

define C-function gtk-notebook-insert-page-menu
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  input parameter menu_label :: <GtkWidget>;
  input parameter position :: <gint>;
  result res :: <gint>;
  c-name: "gtk_notebook_insert_page_menu";
end;

define C-function gtk-notebook-remove-page
  input parameter notebook :: <GtkNotebook>;
  input parameter page_num :: <gint>;
  c-name: "gtk_notebook_remove_page";
end;

define C-function gtk-notebook-set-window-creation-hook
  input parameter func :: <GtkNotebookWindowCreationFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_notebook_set_window_creation_hook";
end;

define C-function gtk-notebook-set-group-id
  input parameter notebook :: <GtkNotebook>;
  input parameter group_id :: <gint>;
  c-name: "gtk_notebook_set_group_id";
end;

define C-function gtk-notebook-get-group-id
  input parameter notebook :: <GtkNotebook>;
  result res :: <gint>;
  c-name: "gtk_notebook_get_group_id";
end;

define C-function gtk-notebook-get-current-page
  input parameter notebook :: <GtkNotebook>;
  result res :: <gint>;
  c-name: "gtk_notebook_get_current_page";
end;

define C-function gtk-notebook-get-nth-page
  input parameter notebook :: <GtkNotebook>;
  input parameter page_num :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_notebook_get_nth_page";
end;

define C-function gtk-notebook-get-n-pages
  input parameter notebook :: <GtkNotebook>;
  result res :: <gint>;
  c-name: "gtk_notebook_get_n_pages";
end;

define C-function gtk-notebook-page-num
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_notebook_page_num";
end;

define C-function gtk-notebook-set-current-page
  input parameter notebook :: <GtkNotebook>;
  input parameter page_num :: <gint>;
  c-name: "gtk_notebook_set_current_page";
end;

define C-function gtk-notebook-next-page
  input parameter notebook :: <GtkNotebook>;
  c-name: "gtk_notebook_next_page";
end;

define C-function gtk-notebook-prev-page
  input parameter notebook :: <GtkNotebook>;
  c-name: "gtk_notebook_prev_page";
end;

define C-function gtk-notebook-set-show-border
  input parameter notebook :: <GtkNotebook>;
  input parameter show_border :: <gboolean>;
  c-name: "gtk_notebook_set_show_border";
end;

define C-function gtk-notebook-get-show-border
  input parameter notebook :: <GtkNotebook>;
  result res :: <gboolean>;
  c-name: "gtk_notebook_get_show_border";
end;

define C-function gtk-notebook-set-show-tabs
  input parameter notebook :: <GtkNotebook>;
  input parameter show_tabs :: <gboolean>;
  c-name: "gtk_notebook_set_show_tabs";
end;

define C-function gtk-notebook-get-show-tabs
  input parameter notebook :: <GtkNotebook>;
  result res :: <gboolean>;
  c-name: "gtk_notebook_get_show_tabs";
end;

define C-function gtk-notebook-set-tab-pos
  input parameter notebook :: <GtkNotebook>;
  input parameter pos :: <GtkPositionType>;
  c-name: "gtk_notebook_set_tab_pos";
end;

define C-function gtk-notebook-get-tab-pos
  input parameter notebook :: <GtkNotebook>;
  result res :: <GtkPositionType>;
  c-name: "gtk_notebook_get_tab_pos";
end;

define C-function gtk-notebook-set-homogeneous-tabs
  input parameter notebook :: <GtkNotebook>;
  input parameter homogeneous :: <gboolean>;
  c-name: "gtk_notebook_set_homogeneous_tabs";
end;

define C-function gtk-notebook-set-tab-border
  input parameter notebook :: <GtkNotebook>;
  input parameter border_width :: <guint>;
  c-name: "gtk_notebook_set_tab_border";
end;

define C-function gtk-notebook-set-tab-hborder
  input parameter notebook :: <GtkNotebook>;
  input parameter tab_hborder :: <guint>;
  c-name: "gtk_notebook_set_tab_hborder";
end;

define C-function gtk-notebook-set-tab-vborder
  input parameter notebook :: <GtkNotebook>;
  input parameter tab_vborder :: <guint>;
  c-name: "gtk_notebook_set_tab_vborder";
end;

define C-function gtk-notebook-set-scrollable
  input parameter notebook :: <GtkNotebook>;
  input parameter scrollable :: <gboolean>;
  c-name: "gtk_notebook_set_scrollable";
end;

define C-function gtk-notebook-get-scrollable
  input parameter notebook :: <GtkNotebook>;
  result res :: <gboolean>;
  c-name: "gtk_notebook_get_scrollable";
end;

define C-function gtk-notebook-popup-enable
  input parameter notebook :: <GtkNotebook>;
  c-name: "gtk_notebook_popup_enable";
end;

define C-function gtk-notebook-popup-disable
  input parameter notebook :: <GtkNotebook>;
  c-name: "gtk_notebook_popup_disable";
end;

define C-function gtk-notebook-get-tab-label
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_notebook_get_tab_label";
end;

define C-function gtk-notebook-set-tab-label
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_label :: <GtkWidget>;
  c-name: "gtk_notebook_set_tab_label";
end;

define C-function gtk-notebook-set-tab-label-text
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter tab_text :: <c-string>;
  c-name: "gtk_notebook_set_tab_label_text";
end;

define C-function gtk-notebook-get-tab-label-text
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_notebook_get_tab_label_text";
end;

define C-function gtk-notebook-get-menu-label
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_notebook_get_menu_label";
end;

define C-function gtk-notebook-set-menu-label
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter menu_label :: <GtkWidget>;
  c-name: "gtk_notebook_set_menu_label";
end;

define C-function gtk-notebook-set-menu-label-text
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter menu_text :: <c-string>;
  c-name: "gtk_notebook_set_menu_label_text";
end;

define C-function gtk-notebook-get-menu-label-text
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_notebook_get_menu_label_text";
end;

define C-function gtk-notebook-query-tab-label-packing
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean*>;
  input parameter fill :: <gboolean*>;
  input parameter pack_type :: <GtkPackType*>;
  c-name: "gtk_notebook_query_tab_label_packing";
end;

define C-function gtk-notebook-set-tab-label-packing
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter expand :: <gboolean>;
  input parameter fill :: <gboolean>;
  input parameter pack_type :: <GtkPackType>;
  c-name: "gtk_notebook_set_tab_label_packing";
end;

define C-function gtk-notebook-reorder-child
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter position :: <gint>;
  c-name: "gtk_notebook_reorder_child";
end;

define C-function gtk-notebook-get-tab-reorderable
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_notebook_get_tab_reorderable";
end;

define C-function gtk-notebook-set-tab-reorderable
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter reorderable :: <gboolean>;
  c-name: "gtk_notebook_set_tab_reorderable";
end;

define C-function gtk-notebook-get-tab-detachable
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_notebook_get_tab_detachable";
end;

define C-function gtk-notebook-set-tab-detachable
  input parameter notebook :: <GtkNotebook>;
  input parameter child :: <GtkWidget>;
  input parameter detachable :: <gboolean>;
  c-name: "gtk_notebook_set_tab_detachable";
end;

define constant gtk-notebook-current-page = gtk-notebook-get-current-page;

define constant gtk-notebook-set-page = gtk-notebook-set-current-page;

define C-function _gtk-find-module
  input parameter name :: <c-string>;
  input parameter type :: <c-string>;
  result res :: <c-string>;
  c-name: "_gtk_find_module";
end;

define C-function _gtk-get-module-path
  input parameter type :: <c-string>;
  result res :: <gchar**>;
  c-name: "_gtk_get_module_path";
end;

define C-function _gtk-modules-init
  input parameter argc :: <gint*>;
  input parameter argv :: <gchar***>;
  input parameter gtk_modules_args :: <c-string>;
  c-name: "_gtk_modules_init";
end;

define C-function _gtk-modules-settings-changed
  input parameter settings :: <GtkSettings>;
  input parameter modules :: <c-string>;
  c-name: "_gtk_modules_settings_changed";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7022>"*/
define constant <GtkModuleInitFunc> = <anonymous-7022>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7023>"*/
define constant <GtkModuleDisplayInitFunc> = <anonymous-7023>;

define constant <GtkMessageType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-MESSAGE-INFO :: <GtkMessageType> = 0;
define constant $GTK-MESSAGE-WARNING :: <GtkMessageType> = 1;
define constant $GTK-MESSAGE-QUESTION :: <GtkMessageType> = 2;
define constant $GTK-MESSAGE-ERROR :: <GtkMessageType> = 3;
define constant $GTK-MESSAGE-OTHER :: <GtkMessageType> = 4;

define constant <GtkButtonsType> = limited(<integer>, min: 0, max: 5);
define constant $GTK-BUTTONS-NONE :: <GtkButtonsType> = 0;
define constant $GTK-BUTTONS-OK :: <GtkButtonsType> = 1;
define constant $GTK-BUTTONS-CLOSE :: <GtkButtonsType> = 2;
define constant $GTK-BUTTONS-CANCEL :: <GtkButtonsType> = 3;
define constant $GTK-BUTTONS-YES-NO :: <GtkButtonsType> = 4;
define constant $GTK-BUTTONS-OK-CANCEL :: <GtkButtonsType> = 5;

define C-subtype <_GtkMessageDialog> (<GtkDialog>, <AtkImplementorIface>) end;
define constant <GtkMessageDialog> = <_GtkMessageDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7007>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7008>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7009>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-7010>"*/
define C-subtype <_GtkMessageDialogClass> (<C-void*>) end;
define constant <GtkMessageDialogClass> = <_GtkMessageDialogClass>;

define C-function gtk-message-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_message_dialog_get_type";
end;

define C-function gtk-message-dialog-new
  input parameter parent :: <GtkWindow>;
  input parameter flags :: <GtkDialogFlags>;
  input parameter type :: <GtkMessageType>;
  input parameter buttons :: <GtkButtonsType>;
  input parameter message_format :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_message_dialog_new";
end;

define C-function gtk-message-dialog-new-with-markup
  input parameter parent :: <GtkWindow>;
  input parameter flags :: <GtkDialogFlags>;
  input parameter type :: <GtkMessageType>;
  input parameter buttons :: <GtkButtonsType>;
  input parameter message_format :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_message_dialog_new_with_markup";
end;

define C-function gtk-message-dialog-set-image
  input parameter dialog :: <GtkMessageDialog>;
  input parameter image :: <GtkWidget>;
  c-name: "gtk_message_dialog_set_image";
end;

define C-function gtk-message-dialog-set-markup
  input parameter message_dialog :: <GtkMessageDialog>;
  input parameter str :: <c-string>;
  c-name: "gtk_message_dialog_set_markup";
end;

define C-function gtk-message-dialog-format-secondary-text
  input parameter message_dialog :: <GtkMessageDialog>;
  input parameter message_format :: <c-string>;
  c-name: "gtk_message_dialog_format_secondary_text";
end;

define C-function gtk-message-dialog-format-secondary-markup
  input parameter message_dialog :: <GtkMessageDialog>;
  input parameter message_format :: <c-string>;
  c-name: "gtk_message_dialog_format_secondary_markup";
end;

define C-subtype <_GtkMenuToolButtonPrivate> (<C-void*>) end;
define constant <GtkMenuToolButtonPrivate> = <_GtkMenuToolButtonPrivate>;

define C-subtype <_GtkMenuToolButton> (<C-void*>) end;
define constant <GtkMenuToolButton> = <_GtkMenuToolButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6994>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6995>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6996>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6997>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6998>"*/
define C-subtype <_GtkMenuToolButtonClass> (<C-void*>) end;
define constant <GtkMenuToolButtonClass> = <_GtkMenuToolButtonClass>;

define C-function gtk-menu-tool-button-get-type
  result res :: <GType>;
  c-name: "gtk_menu_tool_button_get_type";
end;

define C-function gtk-menu-tool-button-new
  input parameter icon_widget :: <GtkWidget>;
  input parameter label :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_menu_tool_button_new";
end;

define C-function gtk-menu-tool-button-new-from-stock
  input parameter stock_id :: <c-string>;
  result res :: <GtkToolItem>;
  c-name: "gtk_menu_tool_button_new_from_stock";
end;

define C-function gtk-menu-tool-button-set-menu
  input parameter button :: <GtkMenuToolButton>;
  input parameter menu :: <GtkWidget>;
  c-name: "gtk_menu_tool_button_set_menu";
end;

define C-function gtk-menu-tool-button-get-menu
  input parameter button :: <GtkMenuToolButton>;
  result res :: <GtkWidget>;
  c-name: "gtk_menu_tool_button_get_menu";
end;

define C-function gtk-menu-tool-button-set-arrow-tooltip
  input parameter button :: <GtkMenuToolButton>;
  input parameter tooltips :: <GtkTooltips>;
  input parameter tip_text :: <c-string>;
  input parameter tip_private :: <c-string>;
  c-name: "gtk_menu_tool_button_set_arrow_tooltip";
end;

define C-subtype <_GtkMenuBar> (<GtkMenuShell>, <AtkImplementorIface>) end;
define constant <GtkMenuBar> = <_GtkMenuBar>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6913>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6914>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6915>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6916>"*/
define C-subtype <_GtkMenuBarClass> (<C-void*>) end;
define constant <GtkMenuBarClass> = <_GtkMenuBarClass>;

define C-function gtk-menu-bar-get-type
  result res :: <GType>;
  c-name: "gtk_menu_bar_get_type";
end;

define C-function gtk-menu-bar-new
  result res :: <GtkWidget>;
  c-name: "gtk_menu_bar_new";
end;

define C-function gtk-menu-bar-get-pack-direction
  input parameter menubar :: <GtkMenuBar>;
  result res :: <GtkPackDirection>;
  c-name: "gtk_menu_bar_get_pack_direction";
end;

define C-function gtk-menu-bar-set-pack-direction
  input parameter menubar :: <GtkMenuBar>;
  input parameter pack_dir :: <GtkPackDirection>;
  c-name: "gtk_menu_bar_set_pack_direction";
end;

define C-function gtk-menu-bar-get-child-pack-direction
  input parameter menubar :: <GtkMenuBar>;
  result res :: <GtkPackDirection>;
  c-name: "gtk_menu_bar_get_child_pack_direction";
end;

define C-function gtk-menu-bar-set-child-pack-direction
  input parameter menubar :: <GtkMenuBar>;
  input parameter child_pack_dir :: <GtkPackDirection>;
  c-name: "gtk_menu_bar_set_child_pack_direction";
end;

define C-function _gtk-menu-bar-cycle-focus
  input parameter menubar :: <GtkMenuBar>;
  input parameter dir :: <GtkDirectionType>;
  c-name: "_gtk_menu_bar_cycle_focus";
end;

define C-subtype <_GtkListItem> (<GtkItem>, <AtkImplementorIface>) end;
define constant <GtkListItem> = <_GtkListItem>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6816>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6817>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6818>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6819>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6820>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6821>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6822>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6823>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6824>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6825>"*/
define C-subtype <_GtkListItemClass> (<C-void*>) end;
define constant <GtkListItemClass> = <_GtkListItemClass>;

define C-function gtk-list-item-get-type
  result res :: <GtkType>;
  c-name: "gtk_list_item_get_type";
end;

define C-function gtk-list-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_list_item_new";
end;

define C-function gtk-list-item-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_list_item_new_with_label";
end;

define C-function gtk-list-item-select
  input parameter list_item :: <GtkListItem>;
  c-name: "gtk_list_item_select";
end;

define C-function gtk-list-item-deselect
  input parameter list_item :: <GtkListItem>;
  c-name: "gtk_list_item_deselect";
end;

define C-subtype <_GtkList> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkList> = <_GtkList>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6834>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6835>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6836>"*/
define C-subtype <_GtkListClass> (<C-void*>) end;
define constant <GtkListClass> = <_GtkListClass>;

define C-function gtk-list-get-type
  result res :: <GtkType>;
  c-name: "gtk_list_get_type";
end;

define C-function gtk-list-new
  result res :: <GtkWidget>;
  c-name: "gtk_list_new";
end;

define C-function gtk-list-insert-items
  input parameter list :: <GtkList>;
  input parameter items :: <GList>;
  input parameter position :: <gint>;
  c-name: "gtk_list_insert_items";
end;

define C-function gtk-list-append-items
  input parameter list :: <GtkList>;
  input parameter items :: <GList>;
  c-name: "gtk_list_append_items";
end;

define C-function gtk-list-prepend-items
  input parameter list :: <GtkList>;
  input parameter items :: <GList>;
  c-name: "gtk_list_prepend_items";
end;

define C-function gtk-list-remove-items
  input parameter list :: <GtkList>;
  input parameter items :: <GList>;
  c-name: "gtk_list_remove_items";
end;

define C-function gtk-list-remove-items-no-unref
  input parameter list :: <GtkList>;
  input parameter items :: <GList>;
  c-name: "gtk_list_remove_items_no_unref";
end;

define C-function gtk-list-clear-items
  input parameter list :: <GtkList>;
  input parameter start :: <gint>;
  input parameter end :: <gint>;
  c-name: "gtk_list_clear_items";
end;

define C-function gtk-list-select-item
  input parameter list :: <GtkList>;
  input parameter item :: <gint>;
  c-name: "gtk_list_select_item";
end;

define C-function gtk-list-unselect-item
  input parameter list :: <GtkList>;
  input parameter item :: <gint>;
  c-name: "gtk_list_unselect_item";
end;

define C-function gtk-list-select-child
  input parameter list :: <GtkList>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_list_select_child";
end;

define C-function gtk-list-unselect-child
  input parameter list :: <GtkList>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_list_unselect_child";
end;

define C-function gtk-list-child-position
  input parameter list :: <GtkList>;
  input parameter child :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_list_child_position";
end;

define C-function gtk-list-set-selection-mode
  input parameter list :: <GtkList>;
  input parameter mode :: <GtkSelectionMode>;
  c-name: "gtk_list_set_selection_mode";
end;

define C-function gtk-list-extend-selection
  input parameter list :: <GtkList>;
  input parameter scroll_type :: <GtkScrollType>;
  input parameter position :: <gfloat>;
  input parameter auto_start_selection :: <gboolean>;
  c-name: "gtk_list_extend_selection";
end;

define C-function gtk-list-start-selection
  input parameter list :: <GtkList>;
  c-name: "gtk_list_start_selection";
end;

define C-function gtk-list-end-selection
  input parameter list :: <GtkList>;
  c-name: "gtk_list_end_selection";
end;

define C-function gtk-list-select-all
  input parameter list :: <GtkList>;
  c-name: "gtk_list_select_all";
end;

define C-function gtk-list-unselect-all
  input parameter list :: <GtkList>;
  c-name: "gtk_list_unselect_all";
end;

define C-function gtk-list-scroll-horizontal
  input parameter list :: <GtkList>;
  input parameter scroll_type :: <GtkScrollType>;
  input parameter position :: <gfloat>;
  c-name: "gtk_list_scroll_horizontal";
end;

define C-function gtk-list-scroll-vertical
  input parameter list :: <GtkList>;
  input parameter scroll_type :: <GtkScrollType>;
  input parameter position :: <gfloat>;
  c-name: "gtk_list_scroll_vertical";
end;

define C-function gtk-list-toggle-add-mode
  input parameter list :: <GtkList>;
  c-name: "gtk_list_toggle_add_mode";
end;

define C-function gtk-list-toggle-focus-row
  input parameter list :: <GtkList>;
  c-name: "gtk_list_toggle_focus_row";
end;

define C-function gtk-list-toggle-row
  input parameter list :: <GtkList>;
  input parameter item :: <GtkWidget>;
  c-name: "gtk_list_toggle_row";
end;

define C-function gtk-list-undo-selection
  input parameter list :: <GtkList>;
  c-name: "gtk_list_undo_selection";
end;

define C-function gtk-list-end-drag-selection
  input parameter list :: <GtkList>;
  c-name: "gtk_list_end_drag_selection";
end;

define C-subtype <_GtkLinkButtonPrivate> (<C-void*>) end;
define constant <GtkLinkButtonPrivate> = <_GtkLinkButtonPrivate>;

define C-subtype <_GtkLinkButton> (<C-void*>) end;
define constant <GtkLinkButton> = <_GtkLinkButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6806>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6807>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6808>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6809>"*/
define C-subtype <_GtkLinkButtonClass> (<C-void*>) end;
define constant <GtkLinkButtonClass> = <_GtkLinkButtonClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6805>"*/
define constant <GtkLinkButtonUriFunc> = <anonymous-6805>;

define C-function gtk-link-button-get-type
  result res :: <GType>;
  c-name: "gtk_link_button_get_type";
end;

define C-function gtk-link-button-new
  input parameter uri :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_link_button_new";
end;

define C-function gtk-link-button-new-with-label
  input parameter uri :: <c-string>;
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_link_button_new_with_label";
end;

define C-function gtk-link-button-get-uri
  input parameter link_button :: <GtkLinkButton>;
  result res :: <c-string>;
  c-name: "gtk_link_button_get_uri";
end;

define C-function gtk-link-button-set-uri
  input parameter link_button :: <GtkLinkButton>;
  input parameter uri :: <c-string>;
  c-name: "gtk_link_button_set_uri";
end;

define C-function gtk-link-button-set-uri-hook
  input parameter func :: <GtkLinkButtonUriFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  result res :: <GtkLinkButtonUriFunc>;
  c-name: "gtk_link_button_set_uri_hook";
end;

define C-subtype <_GtkLayout> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkLayout> = <_GtkLayout>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6788>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6789>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6790>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6791>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6792>"*/
define C-subtype <_GtkLayoutClass> (<C-void*>) end;
define constant <GtkLayoutClass> = <_GtkLayoutClass>;

define C-function gtk-layout-get-type
  result res :: <GType>;
  c-name: "gtk_layout_get_type";
end;

define C-function gtk-layout-new
  input parameter hadjustment :: <GtkAdjustment>;
  input parameter vadjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_layout_new";
end;

define C-function gtk-layout-put
  input parameter layout :: <GtkLayout>;
  input parameter child_widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_layout_put";
end;

define C-function gtk-layout-move
  input parameter layout :: <GtkLayout>;
  input parameter child_widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_layout_move";
end;

define C-function gtk-layout-set-size
  input parameter layout :: <GtkLayout>;
  input parameter width :: <guint>;
  input parameter height :: <guint>;
  c-name: "gtk_layout_set_size";
end;

define C-function gtk-layout-get-size
  input parameter layout :: <GtkLayout>;
  input parameter width :: <guint*>;
  input parameter height :: <guint*>;
  c-name: "gtk_layout_get_size";
end;

define C-function gtk-layout-get-hadjustment
  input parameter layout :: <GtkLayout>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_layout_get_hadjustment";
end;

define C-function gtk-layout-get-vadjustment
  input parameter layout :: <GtkLayout>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_layout_get_vadjustment";
end;

define C-function gtk-layout-set-hadjustment
  input parameter layout :: <GtkLayout>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_layout_set_hadjustment";
end;

define C-function gtk-layout-set-vadjustment
  input parameter layout :: <GtkLayout>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_layout_set_vadjustment";
end;

define C-function gtk-layout-freeze
  input parameter layout :: <GtkLayout>;
  c-name: "gtk_layout_freeze";
end;

define C-function gtk-layout-thaw
  input parameter layout :: <GtkLayout>;
  c-name: "gtk_layout_thaw";
end;

define C-subtype <_GtkInvisible> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkInvisible> = <_GtkInvisible>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6779>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6780>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6781>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6782>"*/
define C-subtype <_GtkInvisibleClass> (<C-void*>) end;
define constant <GtkInvisibleClass> = <_GtkInvisibleClass>;

define C-function gtk-invisible-get-type
  result res :: <GType>;
  c-name: "gtk_invisible_get_type";
end;

define C-function gtk-invisible-new
  result res :: <GtkWidget>;
  c-name: "gtk_invisible_new";
end;

define C-function gtk-invisible-new-for-screen
  input parameter screen :: <GdkScreen>;
  result res :: <GtkWidget>;
  c-name: "gtk_invisible_new_for_screen";
end;

define C-function gtk-invisible-set-screen
  input parameter invisible :: <GtkInvisible>;
  input parameter screen :: <GdkScreen>;
  c-name: "gtk_invisible_set_screen";
end;

define C-function gtk-invisible-get-screen
  input parameter invisible :: <GtkInvisible>;
  result res :: <GdkScreen>;
  c-name: "gtk_invisible_get_screen";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<GtkWidget<@7>>"*/
define C-subtype <_GtkInputDialog> (<GtkDialog>, <AtkImplementorIface>) end;
define constant <GtkInputDialog> = <_GtkInputDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6771>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6772>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6773>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6774>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6775>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6776>"*/
define C-subtype <_GtkInputDialogClass> (<C-void*>) end;
define constant <GtkInputDialogClass> = <_GtkInputDialogClass>;

define C-function gtk-input-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_input_dialog_get_type";
end;

define C-function gtk-input-dialog-new
  result res :: <GtkWidget>;
  c-name: "gtk_input_dialog_new";
end;

define C-subtype <_GtkIMMulticontextPrivate> (<C-void*>) end;
define constant <GtkIMMulticontextPrivate> = <_GtkIMMulticontextPrivate>;

define C-subtype <_GtkIMMulticontext> (<GtkIMContext>) end;
define constant <GtkIMMulticontext> = <_GtkIMMulticontext>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6764>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6765>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6766>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6767>"*/
define C-subtype <_GtkIMMulticontextClass> (<C-void*>) end;
define constant <GtkIMMulticontextClass> = <_GtkIMMulticontextClass>;

define C-function gtk-im-multicontext-get-type
  result res :: <GType>;
  c-name: "gtk_im_multicontext_get_type";
end;

define C-function gtk-im-multicontext-new
  result res :: <GtkIMContext>;
  c-name: "gtk_im_multicontext_new";
end;

define C-function gtk-im-multicontext-append-menuitems
  input parameter context :: <GtkIMMulticontext>;
  input parameter menushell :: <GtkMenuShell>;
  c-name: "gtk_im_multicontext_append_menuitems";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<guint<@8>>"*/
define C-subtype <_GtkIMContextSimple> (<GtkIMContext>) end;
define constant <GtkIMContextSimple> = <_GtkIMContextSimple>;

define C-subtype <_GtkIMContextSimpleClass> (<C-void*>) end;
define constant <GtkIMContextSimpleClass> = <_GtkIMContextSimpleClass>;

define C-function gtk-im-context-simple-get-type
  result res :: <GType>;
  c-name: "gtk_im_context_simple_get_type";
end;

define C-function gtk-im-context-simple-new
  result res :: <GtkIMContext>;
  c-name: "gtk_im_context_simple_new";
end;

define C-function gtk-im-context-simple-add-table
  input parameter context_simple :: <GtkIMContextSimple>;
  input parameter data :: <guint16*>;
  input parameter max_seq_len :: <gint>;
  input parameter n_seqs :: <gint>;
  c-name: "gtk_im_context_simple_add_table";
end;

define constant $GTK-MAX-COMPOSE-LEN = 7;

define C-subtype <_GtkImageMenuItem> (<GtkMenuItem>, <AtkImplementorIface>) end;
define constant <GtkImageMenuItem> = <_GtkImageMenuItem>;

define C-subtype <_GtkImageMenuItemClass> (<C-void*>) end;
define constant <GtkImageMenuItemClass> = <_GtkImageMenuItemClass>;

define C-function gtk-image-menu-item-get-type
  result res :: <GType>;
  c-name: "gtk_image_menu_item_get_type";
end;

define C-function gtk-image-menu-item-new
  result res :: <GtkWidget>;
  c-name: "gtk_image_menu_item_new";
end;

define C-function gtk-image-menu-item-new-with-label
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_menu_item_new_with_label";
end;

define C-function gtk-image-menu-item-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_menu_item_new_with_mnemonic";
end;

define C-function gtk-image-menu-item-new-from-stock
  input parameter stock_id :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_menu_item_new_from_stock";
end;

define C-function gtk-image-menu-item-set-image
  input parameter image_menu_item :: <GtkImageMenuItem>;
  input parameter image :: <GtkWidget>;
  c-name: "gtk_image_menu_item_set_image";
end;

define C-function gtk-image-menu-item-get-image
  input parameter image_menu_item :: <GtkImageMenuItem>;
  result res :: <GtkWidget>;
  c-name: "gtk_image_menu_item_get_image";
end;

define C-subtype <_GtkIconViewPrivate> (<C-void*>) end;
define constant <GtkIconViewPrivate> = <_GtkIconViewPrivate>;

define C-subtype <_GtkIconView> (<C-void*>) end;
define constant <GtkIconView> = <_GtkIconView>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6692>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6693>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6694>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6695>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6696>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6697>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6698>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6699>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6700>"*/
define C-subtype <_GtkIconViewClass> (<C-void*>) end;
define constant <GtkIconViewClass> = <_GtkIconViewClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6690>"*/
define constant <GtkIconViewForeachFunc> = <anonymous-6690>;

define constant <GtkIconViewDropPosition> = limited(<integer>, min: 0, max: 5);
define constant $GTK-ICON-VIEW-NO-DROP :: <GtkIconViewDropPosition> = 0;
define constant $GTK-ICON-VIEW-DROP-INTO :: <GtkIconViewDropPosition> = 1;
define constant $GTK-ICON-VIEW-DROP-LEFT :: <GtkIconViewDropPosition> = 2;
define constant $GTK-ICON-VIEW-DROP-RIGHT :: <GtkIconViewDropPosition> = 3;
define constant $GTK-ICON-VIEW-DROP-ABOVE :: <GtkIconViewDropPosition> = 4;
define constant $GTK-ICON-VIEW-DROP-BELOW :: <GtkIconViewDropPosition> = 5;

define C-function gtk-icon-view-get-type
  result res :: <GType>;
  c-name: "gtk_icon_view_get_type";
end;

define C-function gtk-icon-view-new
  result res :: <GtkWidget>;
  c-name: "gtk_icon_view_new";
end;

define C-function gtk-icon-view-new-with-model
  input parameter model :: <GtkTreeModel>;
  result res :: <GtkWidget>;
  c-name: "gtk_icon_view_new_with_model";
end;

define C-function gtk-icon-view-set-model
  input parameter icon_view :: <GtkIconView>;
  input parameter model :: <GtkTreeModel>;
  c-name: "gtk_icon_view_set_model";
end;

define C-function gtk-icon-view-get-model
  input parameter icon_view :: <GtkIconView>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_icon_view_get_model";
end;

define C-function gtk-icon-view-set-text-column
  input parameter icon_view :: <GtkIconView>;
  input parameter column :: <gint>;
  c-name: "gtk_icon_view_set_text_column";
end;

define C-function gtk-icon-view-get-text-column
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_text_column";
end;

define C-function gtk-icon-view-set-markup-column
  input parameter icon_view :: <GtkIconView>;
  input parameter column :: <gint>;
  c-name: "gtk_icon_view_set_markup_column";
end;

define C-function gtk-icon-view-get-markup-column
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_markup_column";
end;

define C-function gtk-icon-view-set-pixbuf-column
  input parameter icon_view :: <GtkIconView>;
  input parameter column :: <gint>;
  c-name: "gtk_icon_view_set_pixbuf_column";
end;

define C-function gtk-icon-view-get-pixbuf-column
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_pixbuf_column";
end;

define C-function gtk-icon-view-set-orientation
  input parameter icon_view :: <GtkIconView>;
  input parameter orientation :: <GtkOrientation>;
  c-name: "gtk_icon_view_set_orientation";
end;

define C-function gtk-icon-view-get-orientation
  input parameter icon_view :: <GtkIconView>;
  result res :: <GtkOrientation>;
  c-name: "gtk_icon_view_get_orientation";
end;

define C-function gtk-icon-view-set-columns
  input parameter icon_view :: <GtkIconView>;
  input parameter columns :: <gint>;
  c-name: "gtk_icon_view_set_columns";
end;

define C-function gtk-icon-view-get-columns
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_columns";
end;

define C-function gtk-icon-view-set-item-width
  input parameter icon_view :: <GtkIconView>;
  input parameter item_width :: <gint>;
  c-name: "gtk_icon_view_set_item_width";
end;

define C-function gtk-icon-view-get-item-width
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_item_width";
end;

define C-function gtk-icon-view-set-spacing
  input parameter icon_view :: <GtkIconView>;
  input parameter spacing :: <gint>;
  c-name: "gtk_icon_view_set_spacing";
end;

define C-function gtk-icon-view-get-spacing
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_spacing";
end;

define C-function gtk-icon-view-set-row-spacing
  input parameter icon_view :: <GtkIconView>;
  input parameter row_spacing :: <gint>;
  c-name: "gtk_icon_view_set_row_spacing";
end;

define C-function gtk-icon-view-get-row-spacing
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_row_spacing";
end;

define C-function gtk-icon-view-set-column-spacing
  input parameter icon_view :: <GtkIconView>;
  input parameter column_spacing :: <gint>;
  c-name: "gtk_icon_view_set_column_spacing";
end;

define C-function gtk-icon-view-get-column-spacing
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_column_spacing";
end;

define C-function gtk-icon-view-set-margin
  input parameter icon_view :: <GtkIconView>;
  input parameter margin :: <gint>;
  c-name: "gtk_icon_view_set_margin";
end;

define C-function gtk-icon-view-get-margin
  input parameter icon_view :: <GtkIconView>;
  result res :: <gint>;
  c-name: "gtk_icon_view_get_margin";
end;

define C-function gtk-icon-view-get-path-at-pos
  input parameter icon_view :: <GtkIconView>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <GtkTreePath>;
  c-name: "gtk_icon_view_get_path_at_pos";
end;

define C-pointer-type <GtkCellRenderer*> => <GtkCellRenderer>;
define C-function gtk-icon-view-get-item-at-pos
  input parameter icon_view :: <GtkIconView>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter path :: <GtkTreePath*>;
  input parameter cell :: <GtkCellRenderer*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_get_item_at_pos";
end;

define C-function gtk-icon-view-get-visible-range
  input parameter icon_view :: <GtkIconView>;
  input parameter start_path :: <GtkTreePath*>;
  input parameter end_path :: <GtkTreePath*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_get_visible_range";
end;

define C-function gtk-icon-view-selected-foreach
  input parameter icon_view :: <GtkIconView>;
  input parameter func :: <GtkIconViewForeachFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_icon_view_selected_foreach";
end;

define C-function gtk-icon-view-set-selection-mode
  input parameter icon_view :: <GtkIconView>;
  input parameter mode :: <GtkSelectionMode>;
  c-name: "gtk_icon_view_set_selection_mode";
end;

define C-function gtk-icon-view-get-selection-mode
  input parameter icon_view :: <GtkIconView>;
  result res :: <GtkSelectionMode>;
  c-name: "gtk_icon_view_get_selection_mode";
end;

define C-function gtk-icon-view-select-path
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_icon_view_select_path";
end;

define C-function gtk-icon-view-unselect-path
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_icon_view_unselect_path";
end;

define C-function gtk-icon-view-path-is-selected
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_path_is_selected";
end;

define C-function gtk-icon-view-get-selected-items
  input parameter icon_view :: <GtkIconView>;
  result res :: <GList>;
  c-name: "gtk_icon_view_get_selected_items";
end;

define C-function gtk-icon-view-select-all
  input parameter icon_view :: <GtkIconView>;
  c-name: "gtk_icon_view_select_all";
end;

define C-function gtk-icon-view-unselect-all
  input parameter icon_view :: <GtkIconView>;
  c-name: "gtk_icon_view_unselect_all";
end;

define C-function gtk-icon-view-item-activated
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_icon_view_item_activated";
end;

define C-function gtk-icon-view-set-cursor
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter start_editing :: <gboolean>;
  c-name: "gtk_icon_view_set_cursor";
end;

define C-function gtk-icon-view-get-cursor
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath*>;
  input parameter cell :: <GtkCellRenderer*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_get_cursor";
end;

define C-function gtk-icon-view-scroll-to-path
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  input parameter use_align :: <gboolean>;
  input parameter row_align :: <gfloat>;
  input parameter col_align :: <gfloat>;
  c-name: "gtk_icon_view_scroll_to_path";
end;

define C-function gtk-icon-view-enable-model-drag-source
  input parameter icon_view :: <GtkIconView>;
  input parameter start_button_mask :: <GdkModifierType>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_icon_view_enable_model_drag_source";
end;

define C-function gtk-icon-view-enable-model-drag-dest
  input parameter icon_view :: <GtkIconView>;
  input parameter targets :: <GtkTargetEntry>;
  input parameter n_targets :: <gint>;
  input parameter actions :: <GdkDragAction>;
  c-name: "gtk_icon_view_enable_model_drag_dest";
end;

define C-function gtk-icon-view-unset-model-drag-source
  input parameter icon_view :: <GtkIconView>;
  c-name: "gtk_icon_view_unset_model_drag_source";
end;

define C-function gtk-icon-view-unset-model-drag-dest
  input parameter icon_view :: <GtkIconView>;
  c-name: "gtk_icon_view_unset_model_drag_dest";
end;

define C-function gtk-icon-view-set-reorderable
  input parameter icon_view :: <GtkIconView>;
  input parameter reorderable :: <gboolean>;
  c-name: "gtk_icon_view_set_reorderable";
end;

define C-function gtk-icon-view-get-reorderable
  input parameter icon_view :: <GtkIconView>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_get_reorderable";
end;

define C-function gtk-icon-view-set-drag-dest-item
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  input parameter pos :: <GtkIconViewDropPosition>;
  c-name: "gtk_icon_view_set_drag_dest_item";
end;

define C-pointer-type <GtkIconViewDropPosition*> => <GtkIconViewDropPosition>;
define C-function gtk-icon-view-get-drag-dest-item
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath*>;
  input parameter pos :: <GtkIconViewDropPosition*>;
  c-name: "gtk_icon_view_get_drag_dest_item";
end;

define C-function gtk-icon-view-get-dest-item-at-pos
  input parameter icon_view :: <GtkIconView>;
  input parameter drag_x :: <gint>;
  input parameter drag_y :: <gint>;
  input parameter path :: <GtkTreePath*>;
  input parameter pos :: <GtkIconViewDropPosition*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_view_get_dest_item_at_pos";
end;

define C-function gtk-icon-view-create-drag-icon
  input parameter icon_view :: <GtkIconView>;
  input parameter path :: <GtkTreePath>;
  result res :: <GdkPixmap>;
  c-name: "gtk_icon_view_create_drag_icon";
end;

define C-subtype <_GtkIconInfo> (<C-void*>) end;
define constant <GtkIconInfo> = <_GtkIconInfo>;

define C-subtype <_GtkIconThemePrivate> (<C-void*>) end;
define constant <GtkIconThemePrivate> = <_GtkIconThemePrivate>;

define C-subtype <_GtkIconTheme> (<C-void*>) end;
define constant <GtkIconTheme> = <_GtkIconTheme>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6655>"*/
define C-subtype <_GtkIconThemeClass> (<C-void*>) end;
define constant <GtkIconThemeClass> = <_GtkIconThemeClass>;

define constant <GtkIconLookupFlags> = limited(<integer>, min: 1, max: 4);
define constant $GTK-ICON-LOOKUP-NO-SVG :: <GtkIconLookupFlags> = 1;
define constant $GTK-ICON-LOOKUP-FORCE-SVG :: <GtkIconLookupFlags> = 2;
define constant $GTK-ICON-LOOKUP-USE-BUILTIN :: <GtkIconLookupFlags> = 4;

define constant <GtkIconThemeError> = limited(<integer>, min: 0, max: 1);
define constant $GTK-ICON-THEME-NOT-FOUND :: <GtkIconThemeError> = 0;
define constant $GTK-ICON-THEME-FAILED :: <GtkIconThemeError> = 1;

define C-function gtk-icon-theme-error-quark
  result res :: <GQuark>;
  c-name: "gtk_icon_theme_error_quark";
end;

define C-function gtk-icon-theme-get-type
  result res :: <GType>;
  c-name: "gtk_icon_theme_get_type";
end;

define C-function gtk-icon-theme-new
  result res :: <GtkIconTheme>;
  c-name: "gtk_icon_theme_new";
end;

define C-function gtk-icon-theme-get-default
  result res :: <GtkIconTheme>;
  c-name: "gtk_icon_theme_get_default";
end;

define C-function gtk-icon-theme-get-for-screen
  input parameter screen :: <GdkScreen>;
  result res :: <GtkIconTheme>;
  c-name: "gtk_icon_theme_get_for_screen";
end;

define C-function gtk-icon-theme-set-screen
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter screen :: <GdkScreen>;
  c-name: "gtk_icon_theme_set_screen";
end;

define C-function gtk-icon-theme-set-search-path-utf8
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter path :: <gchar*<@>>;
  input parameter n_elements :: <gint>;
  c-name: "gtk_icon_theme_set_search_path_utf8";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar**<@>>"*/
define C-function gtk-icon-theme-get-search-path-utf8
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter path :: <gchar**<@>>;
  input parameter n_elements :: <gint*>;
  c-name: "gtk_icon_theme_get_search_path_utf8";
end;

define C-function gtk-icon-theme-append-search-path-utf8
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter path :: <c-string>;
  c-name: "gtk_icon_theme_append_search_path_utf8";
end;

define C-function gtk-icon-theme-prepend-search-path-utf8
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter path :: <c-string>;
  c-name: "gtk_icon_theme_prepend_search_path_utf8";
end;

define C-function gtk-icon-theme-set-custom-theme
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter theme_name :: <c-string>;
  c-name: "gtk_icon_theme_set_custom_theme";
end;

define C-function gtk-icon-theme-has-icon
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter icon_name :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_icon_theme_has_icon";
end;

define C-function gtk-icon-theme-get-icon-sizes
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter icon_name :: <c-string>;
  result res :: <gint*>;
  c-name: "gtk_icon_theme_get_icon_sizes";
end;

define C-function gtk-icon-theme-lookup-icon
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter icon_name :: <c-string>;
  input parameter size :: <gint>;
  input parameter flags :: <GtkIconLookupFlags>;
  result res :: <GtkIconInfo>;
  c-name: "gtk_icon_theme_lookup_icon";
end;

define C-function gtk-icon-theme-load-icon
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter icon_name :: <c-string>;
  input parameter size :: <gint>;
  input parameter flags :: <GtkIconLookupFlags>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_icon_theme_load_icon";
end;

define C-function gtk-icon-theme-list-icons
  input parameter icon_theme :: <GtkIconTheme>;
  input parameter context :: <c-string>;
  result res :: <GList>;
  c-name: "gtk_icon_theme_list_icons";
end;

define C-function gtk-icon-theme-get-example-icon-name
  input parameter icon_theme :: <GtkIconTheme>;
  result res :: <c-string>;
  c-name: "gtk_icon_theme_get_example_icon_name";
end;

define C-function gtk-icon-theme-rescan-if-needed
  input parameter icon_theme :: <GtkIconTheme>;
  result res :: <gboolean>;
  c-name: "gtk_icon_theme_rescan_if_needed";
end;

define C-function gtk-icon-theme-add-builtin-icon
  input parameter icon_name :: <c-string>;
  input parameter size :: <gint>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_icon_theme_add_builtin_icon";
end;

define C-function gtk-icon-info-get-type
  result res :: <GType>;
  c-name: "gtk_icon_info_get_type";
end;

define C-function gtk-icon-info-copy
  input parameter icon_info :: <GtkIconInfo>;
  result res :: <GtkIconInfo>;
  c-name: "gtk_icon_info_copy";
end;

define C-function gtk-icon-info-free
  input parameter icon_info :: <GtkIconInfo>;
  c-name: "gtk_icon_info_free";
end;

define C-function gtk-icon-info-get-base-size
  input parameter icon_info :: <GtkIconInfo>;
  result res :: <gint>;
  c-name: "gtk_icon_info_get_base_size";
end;

define C-function gtk-icon-info-get-filename-utf8
  input parameter icon_info :: <GtkIconInfo>;
  result res :: <c-string>;
  c-name: "gtk_icon_info_get_filename_utf8";
end;

define C-function gtk-icon-info-get-builtin-pixbuf
  input parameter icon_info :: <GtkIconInfo>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_icon_info_get_builtin_pixbuf";
end;

define C-function gtk-icon-info-load-icon
  input parameter icon_info :: <GtkIconInfo>;
  input parameter error :: <GError*>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_icon_info_load_icon";
end;

define C-function gtk-icon-info-set-raw-coordinates
  input parameter icon_info :: <GtkIconInfo>;
  input parameter raw_coordinates :: <gboolean>;
  c-name: "gtk_icon_info_set_raw_coordinates";
end;

define C-function gtk-icon-info-get-embedded-rect
  input parameter icon_info :: <GtkIconInfo>;
  input parameter rectangle :: <GdkRectangle>;
  result res :: <gboolean>;
  c-name: "gtk_icon_info_get_embedded_rect";
end;

define C-pointer-type <GdkPoint*> => <GdkPoint>;
define C-function gtk-icon-info-get-attach-points
  input parameter icon_info :: <GtkIconInfo>;
  input parameter points :: <GdkPoint*>;
  input parameter n_points :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_info_get_attach_points";
end;

define C-function gtk-icon-info-get-display-name
  input parameter icon_info :: <GtkIconInfo>;
  result res :: <c-string>;
  c-name: "gtk_icon_info_get_display_name";
end;

define C-function _gtk-icon-theme-check-reload
  input parameter display :: <GdkDisplay>;
  c-name: "_gtk_icon_theme_check_reload";
end;

define C-function _gtk-icon-theme-ensure-builtin-cache
  c-name: "_gtk_icon_theme_ensure_builtin_cache";
end;

define constant gtk-icon-theme-set-search-path = gtk-icon-theme-set-search-path-utf8;

define constant gtk-icon-theme-get-search-path = gtk-icon-theme-get-search-path-utf8;

define constant gtk-icon-theme-append-search-path = gtk-icon-theme-append-search-path-utf8;

define constant gtk-icon-theme-prepend-search-path = gtk-icon-theme-prepend-search-path-utf8;

define constant gtk-icon-info-get-filename = gtk-icon-info-get-filename-utf8;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6604>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6605>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6606>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6607>"*/
define C-subtype <_GtkIconFactoryClass> (<C-void*>) end;
define constant <GtkIconFactoryClass> = <_GtkIconFactoryClass>;

define C-function gtk-icon-factory-get-type
  result res :: <GType>;
  c-name: "gtk_icon_factory_get_type";
end;

define C-function gtk-icon-factory-new
  result res :: <GtkIconFactory>;
  c-name: "gtk_icon_factory_new";
end;

define C-function gtk-icon-factory-add
  input parameter factory :: <GtkIconFactory>;
  input parameter stock_id :: <c-string>;
  input parameter icon_set :: <GtkIconSet>;
  c-name: "gtk_icon_factory_add";
end;

define C-function gtk-icon-factory-lookup
  input parameter factory :: <GtkIconFactory>;
  input parameter stock_id :: <c-string>;
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_factory_lookup";
end;

define C-function gtk-icon-factory-add-default
  input parameter factory :: <GtkIconFactory>;
  c-name: "gtk_icon_factory_add_default";
end;

define C-function gtk-icon-factory-remove-default
  input parameter factory :: <GtkIconFactory>;
  c-name: "gtk_icon_factory_remove_default";
end;

define C-function gtk-icon-factory-lookup-default
  input parameter stock_id :: <c-string>;
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_factory_lookup_default";
end;

define C-function gtk-icon-size-lookup
  input parameter size :: <GtkIconSize>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_size_lookup";
end;

define C-function gtk-icon-size-lookup-for-settings
  input parameter settings :: <GtkSettings>;
  input parameter size :: <GtkIconSize>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_icon_size_lookup_for_settings";
end;

define C-function gtk-icon-size-register
  input parameter name :: <c-string>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <GtkIconSize>;
  c-name: "gtk_icon_size_register";
end;

define C-function gtk-icon-size-register-alias
  input parameter alias :: <c-string>;
  input parameter target :: <GtkIconSize>;
  c-name: "gtk_icon_size_register_alias";
end;

define C-function gtk-icon-size-from-name
  input parameter name :: <c-string>;
  result res :: <GtkIconSize>;
  c-name: "gtk_icon_size_from_name";
end;

define C-function gtk-icon-size-get-name
  input parameter size :: <GtkIconSize>;
  result res :: <c-string>;
  c-name: "gtk_icon_size_get_name";
end;

define C-function gtk-icon-set-get-type
  result res :: <GType>;
  c-name: "gtk_icon_set_get_type";
end;

define C-function gtk-icon-set-new
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_set_new";
end;

define C-function gtk-icon-set-new-from-pixbuf
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_set_new_from_pixbuf";
end;

define C-function gtk-icon-set-ref
  input parameter icon_set :: <GtkIconSet>;
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_set_ref";
end;

define C-function gtk-icon-set-unref
  input parameter icon_set :: <GtkIconSet>;
  c-name: "gtk_icon_set_unref";
end;

define C-function gtk-icon-set-copy
  input parameter icon_set :: <GtkIconSet>;
  result res :: <GtkIconSet>;
  c-name: "gtk_icon_set_copy";
end;

define C-function gtk-icon-set-render-icon
  input parameter icon_set :: <GtkIconSet>;
  input parameter style :: <GtkStyle>;
  input parameter direction :: <GtkTextDirection>;
  input parameter state :: <GtkStateType>;
  input parameter size :: <GtkIconSize>;
  input parameter widget :: <GtkWidget>;
  input parameter detail :: <c-string>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_icon_set_render_icon";
end;

define C-function gtk-icon-set-add-source
  input parameter icon_set :: <GtkIconSet>;
  input parameter source :: <GtkIconSource>;
  c-name: "gtk_icon_set_add_source";
end;

define C-pointer-type <GtkIconSize**> => <GtkIconSize*>;
define C-function gtk-icon-set-get-sizes
  input parameter icon_set :: <GtkIconSet>;
  input parameter sizes :: <GtkIconSize**>;
  input parameter n_sizes :: <gint*>;
  c-name: "gtk_icon_set_get_sizes";
end;

define C-function gtk-icon-source-get-type
  result res :: <GType>;
  c-name: "gtk_icon_source_get_type";
end;

define C-function gtk-icon-source-new
  result res :: <GtkIconSource>;
  c-name: "gtk_icon_source_new";
end;

define C-function gtk-icon-source-copy
  input parameter source :: <GtkIconSource>;
  result res :: <GtkIconSource>;
  c-name: "gtk_icon_source_copy";
end;

define C-function gtk-icon-source-free
  input parameter source :: <GtkIconSource>;
  c-name: "gtk_icon_source_free";
end;

define C-function gtk-icon-source-set-filename-utf8
  input parameter source :: <GtkIconSource>;
  input parameter filename :: <c-string>;
  c-name: "gtk_icon_source_set_filename_utf8";
end;

define C-function gtk-icon-source-set-icon-name
  input parameter source :: <GtkIconSource>;
  input parameter icon_name :: <c-string>;
  c-name: "gtk_icon_source_set_icon_name";
end;

define C-function gtk-icon-source-set-pixbuf
  input parameter source :: <GtkIconSource>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_icon_source_set_pixbuf";
end;

define C-function gtk-icon-source-get-filename-utf8
  input parameter source :: <GtkIconSource>;
  result res :: <c-string>;
  c-name: "gtk_icon_source_get_filename_utf8";
end;

define C-function gtk-icon-source-get-icon-name
  input parameter source :: <GtkIconSource>;
  result res :: <c-string>;
  c-name: "gtk_icon_source_get_icon_name";
end;

define C-function gtk-icon-source-get-pixbuf
  input parameter source :: <GtkIconSource>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_icon_source_get_pixbuf";
end;

define C-function gtk-icon-source-set-direction-wildcarded
  input parameter source :: <GtkIconSource>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_icon_source_set_direction_wildcarded";
end;

define C-function gtk-icon-source-set-state-wildcarded
  input parameter source :: <GtkIconSource>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_icon_source_set_state_wildcarded";
end;

define C-function gtk-icon-source-set-size-wildcarded
  input parameter source :: <GtkIconSource>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_icon_source_set_size_wildcarded";
end;

define C-function gtk-icon-source-get-size-wildcarded
  input parameter source :: <GtkIconSource>;
  result res :: <gboolean>;
  c-name: "gtk_icon_source_get_size_wildcarded";
end;

define C-function gtk-icon-source-get-state-wildcarded
  input parameter source :: <GtkIconSource>;
  result res :: <gboolean>;
  c-name: "gtk_icon_source_get_state_wildcarded";
end;

define C-function gtk-icon-source-get-direction-wildcarded
  input parameter source :: <GtkIconSource>;
  result res :: <gboolean>;
  c-name: "gtk_icon_source_get_direction_wildcarded";
end;

define C-function gtk-icon-source-set-direction
  input parameter source :: <GtkIconSource>;
  input parameter direction :: <GtkTextDirection>;
  c-name: "gtk_icon_source_set_direction";
end;

define C-function gtk-icon-source-set-state
  input parameter source :: <GtkIconSource>;
  input parameter state :: <GtkStateType>;
  c-name: "gtk_icon_source_set_state";
end;

define C-function gtk-icon-source-set-size
  input parameter source :: <GtkIconSource>;
  input parameter size :: <GtkIconSize>;
  c-name: "gtk_icon_source_set_size";
end;

define C-function gtk-icon-source-get-direction
  input parameter source :: <GtkIconSource>;
  result res :: <GtkTextDirection>;
  c-name: "gtk_icon_source_get_direction";
end;

define C-function gtk-icon-source-get-state
  input parameter source :: <GtkIconSource>;
  result res :: <GtkStateType>;
  c-name: "gtk_icon_source_get_state";
end;

define C-function gtk-icon-source-get-size
  input parameter source :: <GtkIconSource>;
  result res :: <GtkIconSize>;
  c-name: "gtk_icon_source_get_size";
end;

define C-function _gtk-icon-set-invalidate-caches
  c-name: "_gtk_icon_set_invalidate_caches";
end;

define C-function _gtk-icon-factory-list-ids
  result res :: <GSList>;
  c-name: "_gtk_icon_factory_list_ids";
end;

define C-function _gtk-icon-factory-ensure-default-icons
  c-name: "_gtk_icon_factory_ensure_default_icons";
end;

define constant gtk-icon-source-set-filename = gtk-icon-source-set-filename-utf8;

define constant gtk-icon-source-get-filename = gtk-icon-source-get-filename-utf8;

define C-subtype <_GtkHSeparator> (<GtkSeparator>, <AtkImplementorIface>) end;
define constant <GtkHSeparator> = <_GtkHSeparator>;

define C-subtype <_GtkHSeparatorClass> (<C-void*>) end;
define constant <GtkHSeparatorClass> = <_GtkHSeparatorClass>;

define C-function gtk-hseparator-get-type
  result res :: <GType>;
  c-name: "gtk_hseparator_get_type";
end;

define C-function gtk-hseparator-new
  result res :: <GtkWidget>;
  c-name: "gtk_hseparator_new";
end;

define C-subtype <_GtkHScale> (<GtkScale>, <AtkImplementorIface>) end;
define constant <GtkHScale> = <_GtkHScale>;

define C-subtype <_GtkHScaleClass> (<C-void*>) end;
define constant <GtkHScaleClass> = <_GtkHScaleClass>;

define C-function gtk-hscale-get-type
  result res :: <GType>;
  c-name: "gtk_hscale_get_type";
end;

define C-function gtk-hscale-new
  input parameter adjustment :: <GtkAdjustment>;
  result res :: <GtkWidget>;
  c-name: "gtk_hscale_new";
end;

define C-function gtk-hscale-new-with-range
  input parameter min :: <gdouble>;
  input parameter max :: <gdouble>;
  input parameter step :: <gdouble>;
  result res :: <GtkWidget>;
  c-name: "gtk_hscale_new_with_range";
end;

define C-subtype <_GtkHRuler> (<GtkRuler>, <AtkImplementorIface>) end;
define constant <GtkHRuler> = <_GtkHRuler>;

define C-subtype <_GtkHRulerClass> (<C-void*>) end;
define constant <GtkHRulerClass> = <_GtkHRulerClass>;

define C-function gtk-hruler-get-type
  result res :: <GType>;
  c-name: "gtk_hruler_get_type";
end;

define C-function gtk-hruler-new
  result res :: <GtkWidget>;
  c-name: "gtk_hruler_new";
end;

define C-subtype <_GtkHPaned> (<GtkPaned>, <AtkImplementorIface>) end;
define constant <GtkHPaned> = <_GtkHPaned>;

define C-subtype <_GtkHPanedClass> (<C-void*>) end;
define constant <GtkHPanedClass> = <_GtkHPanedClass>;

define C-function gtk-hpaned-get-type
  result res :: <GType>;
  c-name: "gtk_hpaned_get_type";
end;

define C-function gtk-hpaned-new
  result res :: <GtkWidget>;
  c-name: "gtk_hpaned_new";
end;

define C-subtype <_GtkHButtonBox> (<GtkButtonBox>, <AtkImplementorIface>) end;
define constant <GtkHButtonBox> = <_GtkHButtonBox>;

define C-subtype <_GtkHButtonBoxClass> (<C-void*>) end;
define constant <GtkHButtonBoxClass> = <_GtkHButtonBoxClass>;

define C-function gtk-hbutton-box-get-type
  result res :: <GType>;
  c-name: "gtk_hbutton_box_get_type";
end;

define C-function gtk-hbutton-box-new
  result res :: <GtkWidget>;
  c-name: "gtk_hbutton_box_new";
end;

define C-function gtk-hbutton-box-get-spacing-default
  result res :: <gint>;
  c-name: "gtk_hbutton_box_get_spacing_default";
end;

define C-function gtk-hbutton-box-get-layout-default
  result res :: <GtkButtonBoxStyle>;
  c-name: "gtk_hbutton_box_get_layout_default";
end;

define C-function gtk-hbutton-box-set-spacing-default
  input parameter spacing :: <gint>;
  c-name: "gtk_hbutton_box_set_spacing_default";
end;

define C-function gtk-hbutton-box-set-layout-default
  input parameter layout :: <GtkButtonBoxStyle>;
  c-name: "gtk_hbutton_box_set_layout_default";
end;

define C-subtype <_GtkHandleBox> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkHandleBox> = <_GtkHandleBox>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6512>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6513>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6514>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6515>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6516>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6517>"*/
define C-subtype <_GtkHandleBoxClass> (<C-void*>) end;
define constant <GtkHandleBoxClass> = <_GtkHandleBoxClass>;

define C-function gtk-handle-box-get-type
  result res :: <GType>;
  c-name: "gtk_handle_box_get_type";
end;

define C-function gtk-handle-box-new
  result res :: <GtkWidget>;
  c-name: "gtk_handle_box_new";
end;

define C-function gtk-handle-box-set-shadow-type
  input parameter handle_box :: <GtkHandleBox>;
  input parameter type :: <GtkShadowType>;
  c-name: "gtk_handle_box_set_shadow_type";
end;

define C-function gtk-handle-box-get-shadow-type
  input parameter handle_box :: <GtkHandleBox>;
  result res :: <GtkShadowType>;
  c-name: "gtk_handle_box_get_shadow_type";
end;

define C-function gtk-handle-box-set-handle-position
  input parameter handle_box :: <GtkHandleBox>;
  input parameter position :: <GtkPositionType>;
  c-name: "gtk_handle_box_set_handle_position";
end;

define C-function gtk-handle-box-get-handle-position
  input parameter handle_box :: <GtkHandleBox>;
  result res :: <GtkPositionType>;
  c-name: "gtk_handle_box_get_handle_position";
end;

define C-function gtk-handle-box-set-snap-edge
  input parameter handle_box :: <GtkHandleBox>;
  input parameter edge :: <GtkPositionType>;
  c-name: "gtk_handle_box_set_snap_edge";
end;

define C-function gtk-handle-box-get-snap-edge
  input parameter handle_box :: <GtkHandleBox>;
  result res :: <GtkPositionType>;
  c-name: "gtk_handle_box_get_snap_edge";
end;

define C-function gtk-gc-get
  input parameter depth :: <gint>;
  input parameter colormap :: <GdkColormap>;
  input parameter values :: <GdkGCValues>;
  input parameter values_mask :: <GdkGCValuesMask>;
  result res :: <GdkGC>;
  c-name: "gtk_gc_get";
end;

define C-function gtk-gc-release
  input parameter gc :: <GdkGC>;
  c-name: "gtk_gc_release";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<GtkWidget<@5>>"*/
define C-subtype <_GtkGammaCurve> (<GtkVBox>, <AtkImplementorIface>) end;
define constant <GtkGammaCurve> = <_GtkGammaCurve>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6498>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6499>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6500>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6501>"*/
define C-subtype <_GtkGammaCurveClass> (<C-void*>) end;
define constant <GtkGammaCurveClass> = <_GtkGammaCurveClass>;

define C-function gtk-gamma-curve-get-type
  result res :: <GType>;
  c-name: "gtk_gamma_curve_get_type";
end;

define C-function gtk-gamma-curve-new
  result res :: <GtkWidget>;
  c-name: "gtk_gamma_curve_new";
end;

define C-subtype <_GtkFrame> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkFrame> = <_GtkFrame>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4744>"*/
define C-subtype <_GtkFrameClass> (<C-void*>) end;
define constant <GtkFrameClass> = <_GtkFrameClass>;

define C-function gtk-frame-get-type
  result res :: <GType>;
  c-name: "gtk_frame_get_type";
end;

define C-function gtk-frame-new
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_frame_new";
end;

define C-function gtk-frame-set-label
  input parameter frame :: <GtkFrame>;
  input parameter label :: <c-string>;
  c-name: "gtk_frame_set_label";
end;

define C-function gtk-frame-get-label
  input parameter frame :: <GtkFrame>;
  result res :: <c-string>;
  c-name: "gtk_frame_get_label";
end;

define C-function gtk-frame-set-label-widget
  input parameter frame :: <GtkFrame>;
  input parameter label_widget :: <GtkWidget>;
  c-name: "gtk_frame_set_label_widget";
end;

define C-function gtk-frame-get-label-widget
  input parameter frame :: <GtkFrame>;
  result res :: <GtkWidget>;
  c-name: "gtk_frame_get_label_widget";
end;

define C-function gtk-frame-set-label-align
  input parameter frame :: <GtkFrame>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  c-name: "gtk_frame_set_label_align";
end;

define C-function gtk-frame-get-label-align
  input parameter frame :: <GtkFrame>;
  input parameter xalign :: <gfloat*>;
  input parameter yalign :: <gfloat*>;
  c-name: "gtk_frame_get_label_align";
end;

define C-function gtk-frame-set-shadow-type
  input parameter frame :: <GtkFrame>;
  input parameter type :: <GtkShadowType>;
  c-name: "gtk_frame_set_shadow_type";
end;

define C-function gtk-frame-get-shadow-type
  input parameter frame :: <GtkFrame>;
  result res :: <GtkShadowType>;
  c-name: "gtk_frame_get_shadow_type";
end;

define C-subtype <_GtkFontSelection> (<GtkVBox>, <AtkImplementorIface>) end;
define constant <GtkFontSelection> = <_GtkFontSelection>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6476>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6477>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6478>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6479>"*/
define C-subtype <_GtkFontSelectionClass> (<C-void*>) end;
define constant <GtkFontSelectionClass> = <_GtkFontSelectionClass>;

define C-subtype <_GtkFontSelectionDialog> (<GtkDialog>, <AtkImplementorIface>) end;
define constant <GtkFontSelectionDialog> = <_GtkFontSelectionDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6480>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6481>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6482>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6483>"*/
define C-subtype <_GtkFontSelectionDialogClass> (<C-void*>) end;
define constant <GtkFontSelectionDialogClass> = <_GtkFontSelectionDialogClass>;

define C-function gtk-font-selection-get-type
  result res :: <GType>;
  c-name: "gtk_font_selection_get_type";
end;

define C-function gtk-font-selection-new
  result res :: <GtkWidget>;
  c-name: "gtk_font_selection_new";
end;

define C-function gtk-font-selection-get-font-name
  input parameter fontsel :: <GtkFontSelection>;
  result res :: <c-string>;
  c-name: "gtk_font_selection_get_font_name";
end;

define C-function gtk-font-selection-get-font
  input parameter fontsel :: <GtkFontSelection>;
  result res :: <GdkFont>;
  c-name: "gtk_font_selection_get_font";
end;

define C-function gtk-font-selection-set-font-name
  input parameter fontsel :: <GtkFontSelection>;
  input parameter fontname :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_font_selection_set_font_name";
end;

define C-function gtk-font-selection-get-preview-text
  input parameter fontsel :: <GtkFontSelection>;
  result res :: <c-string>;
  c-name: "gtk_font_selection_get_preview_text";
end;

define C-function gtk-font-selection-set-preview-text
  input parameter fontsel :: <GtkFontSelection>;
  input parameter text :: <c-string>;
  c-name: "gtk_font_selection_set_preview_text";
end;

define C-function gtk-font-selection-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_font_selection_dialog_get_type";
end;

define C-function gtk-font-selection-dialog-new
  input parameter title :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_font_selection_dialog_new";
end;

define C-function gtk-font-selection-dialog-get-font-name
  input parameter fsd :: <GtkFontSelectionDialog>;
  result res :: <c-string>;
  c-name: "gtk_font_selection_dialog_get_font_name";
end;

define C-function gtk-font-selection-dialog-get-font
  input parameter fsd :: <GtkFontSelectionDialog>;
  result res :: <GdkFont>;
  c-name: "gtk_font_selection_dialog_get_font";
end;

define C-function gtk-font-selection-dialog-set-font-name
  input parameter fsd :: <GtkFontSelectionDialog>;
  input parameter fontname :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_font_selection_dialog_set_font_name";
end;

define C-function gtk-font-selection-dialog-get-preview-text
  input parameter fsd :: <GtkFontSelectionDialog>;
  result res :: <c-string>;
  c-name: "gtk_font_selection_dialog_get_preview_text";
end;

define C-function gtk-font-selection-dialog-set-preview-text
  input parameter fsd :: <GtkFontSelectionDialog>;
  input parameter text :: <c-string>;
  c-name: "gtk_font_selection_dialog_set_preview_text";
end;

define C-subtype <_GtkFontButtonPrivate> (<C-void*>) end;
define constant <GtkFontButtonPrivate> = <_GtkFontButtonPrivate>;

define C-subtype <_GtkFontButton> (<C-void*>) end;
define constant <GtkFontButton> = <_GtkFontButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6456>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6457>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6458>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6459>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6460>"*/
define C-subtype <_GtkFontButtonClass> (<C-void*>) end;
define constant <GtkFontButtonClass> = <_GtkFontButtonClass>;

define C-function gtk-font-button-get-type
  result res :: <GType>;
  c-name: "gtk_font_button_get_type";
end;

define C-function gtk-font-button-new
  result res :: <GtkWidget>;
  c-name: "gtk_font_button_new";
end;

define C-function gtk-font-button-new-with-font
  input parameter fontname :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_font_button_new_with_font";
end;

define C-function gtk-font-button-get-title
  input parameter font_button :: <GtkFontButton>;
  result res :: <c-string>;
  c-name: "gtk_font_button_get_title";
end;

define C-function gtk-font-button-set-title
  input parameter font_button :: <GtkFontButton>;
  input parameter title :: <c-string>;
  c-name: "gtk_font_button_set_title";
end;

define C-function gtk-font-button-get-use-font
  input parameter font_button :: <GtkFontButton>;
  result res :: <gboolean>;
  c-name: "gtk_font_button_get_use_font";
end;

define C-function gtk-font-button-set-use-font
  input parameter font_button :: <GtkFontButton>;
  input parameter use_font :: <gboolean>;
  c-name: "gtk_font_button_set_use_font";
end;

define C-function gtk-font-button-get-use-size
  input parameter font_button :: <GtkFontButton>;
  result res :: <gboolean>;
  c-name: "gtk_font_button_get_use_size";
end;

define C-function gtk-font-button-set-use-size
  input parameter font_button :: <GtkFontButton>;
  input parameter use_size :: <gboolean>;
  c-name: "gtk_font_button_set_use_size";
end;

define C-function gtk-font-button-get-font-name
  input parameter font_button :: <GtkFontButton>;
  result res :: <c-string>;
  c-name: "gtk_font_button_get_font_name";
end;

define C-function gtk-font-button-set-font-name
  input parameter font_button :: <GtkFontButton>;
  input parameter fontname :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_font_button_set_font_name";
end;

define C-function gtk-font-button-get-show-style
  input parameter font_button :: <GtkFontButton>;
  result res :: <gboolean>;
  c-name: "gtk_font_button_get_show_style";
end;

define C-function gtk-font-button-set-show-style
  input parameter font_button :: <GtkFontButton>;
  input parameter show_style :: <gboolean>;
  c-name: "gtk_font_button_set_show_style";
end;

define C-function gtk-font-button-get-show-size
  input parameter font_button :: <GtkFontButton>;
  result res :: <gboolean>;
  c-name: "gtk_font_button_get_show_size";
end;

define C-function gtk-font-button-set-show-size
  input parameter font_button :: <GtkFontButton>;
  input parameter show_size :: <gboolean>;
  c-name: "gtk_font_button_set_show_size";
end;

define C-subtype <_GtkFileChooserWidgetPrivate> (<C-void*>) end;
define constant <GtkFileChooserWidgetPrivate> = <_GtkFileChooserWidgetPrivate>;

define C-subtype <_GtkFileChooserWidget> (<C-void*>) end;
define constant <GtkFileChooserWidget> = <_GtkFileChooserWidget>;

define C-subtype <_GtkFileChooserWidgetClass> (<C-void*>) end;
define constant <GtkFileChooserWidgetClass> = <_GtkFileChooserWidgetClass>;

define C-function gtk-file-chooser-widget-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_widget_get_type";
end;

define constant <GtkFileChooserAction> = limited(<integer>, min: 0, max: 3);
define constant $GTK-FILE-CHOOSER-ACTION-OPEN :: <GtkFileChooserAction> = 0;
define constant $GTK-FILE-CHOOSER-ACTION-SAVE :: <GtkFileChooserAction> = 1;
define constant $GTK-FILE-CHOOSER-ACTION-SELECT-FOLDER :: <GtkFileChooserAction> = 2;
define constant $GTK-FILE-CHOOSER-ACTION-CREATE-FOLDER :: <GtkFileChooserAction> = 3;

define C-function gtk-file-chooser-widget-new
  input parameter action :: <GtkFileChooserAction>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_widget_new";
end;

define C-function gtk-file-chooser-widget-new-with-backend
  input parameter action :: <GtkFileChooserAction>;
  input parameter backend :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_widget_new_with_backend";
end;

define C-subtype <_GtkFileChooser> (<C-void*>) end;
define constant <GtkFileChooser> = <_GtkFileChooser>;

define constant <GtkFileChooserConfirmation> = limited(<integer>, min: 0, max: 2);
define constant $GTK-FILE-CHOOSER-CONFIRMATION-CONFIRM :: <GtkFileChooserConfirmation> = 0;
define constant $GTK-FILE-CHOOSER-CONFIRMATION-ACCEPT-FILENAME :: <GtkFileChooserConfirmation> = 1;
define constant $GTK-FILE-CHOOSER-CONFIRMATION-SELECT-AGAIN :: <GtkFileChooserConfirmation> = 2;

define C-function gtk-file-chooser-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_get_type";
end;

define constant <GtkFileChooserError> = limited(<integer>, min: 0, max: 2);
define constant $GTK-FILE-CHOOSER-ERROR-NONEXISTENT :: <GtkFileChooserError> = 0;
define constant $GTK-FILE-CHOOSER-ERROR-BAD-FILENAME :: <GtkFileChooserError> = 1;
define constant $GTK-FILE-CHOOSER-ERROR-ALREADY-EXISTS :: <GtkFileChooserError> = 2;

define C-function gtk-file-chooser-error-quark
  result res :: <GQuark>;
  c-name: "gtk_file_chooser_error_quark";
end;

define C-function gtk-file-chooser-set-action
  input parameter chooser :: <GtkFileChooser>;
  input parameter action :: <GtkFileChooserAction>;
  c-name: "gtk_file_chooser_set_action";
end;

define C-function gtk-file-chooser-get-action
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GtkFileChooserAction>;
  c-name: "gtk_file_chooser_get_action";
end;

define C-function gtk-file-chooser-set-local-only
  input parameter chooser :: <GtkFileChooser>;
  input parameter local_only :: <gboolean>;
  c-name: "gtk_file_chooser_set_local_only";
end;

define C-function gtk-file-chooser-get-local-only
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_local_only";
end;

define C-function gtk-file-chooser-set-select-multiple
  input parameter chooser :: <GtkFileChooser>;
  input parameter select_multiple :: <gboolean>;
  c-name: "gtk_file_chooser_set_select_multiple";
end;

define C-function gtk-file-chooser-get-select-multiple
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_select_multiple";
end;

define C-function gtk-file-chooser-set-show-hidden
  input parameter chooser :: <GtkFileChooser>;
  input parameter show_hidden :: <gboolean>;
  c-name: "gtk_file_chooser_set_show_hidden";
end;

define C-function gtk-file-chooser-get-show-hidden
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_show_hidden";
end;

define C-function gtk-file-chooser-set-do-overwrite-confirmation
  input parameter chooser :: <GtkFileChooser>;
  input parameter do_overwrite_confirmation :: <gboolean>;
  c-name: "gtk_file_chooser_set_do_overwrite_confirmation";
end;

define C-function gtk-file-chooser-get-do-overwrite-confirmation
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_do_overwrite_confirmation";
end;

define C-function gtk-file-chooser-set-current-name
  input parameter chooser :: <GtkFileChooser>;
  input parameter name :: <c-string>;
  c-name: "gtk_file_chooser_set_current_name";
end;

define C-function gtk-file-chooser-get-filename-utf8
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_filename_utf8";
end;

define C-function gtk-file-chooser-set-filename-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter filename :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_set_filename_utf8";
end;

define C-function gtk-file-chooser-select-filename-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter filename :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_select_filename_utf8";
end;

define C-function gtk-file-chooser-unselect-filename-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter filename :: <c-string>;
  c-name: "gtk_file_chooser_unselect_filename_utf8";
end;

define C-function gtk-file-chooser-select-all
  input parameter chooser :: <GtkFileChooser>;
  c-name: "gtk_file_chooser_select_all";
end;

define C-function gtk-file-chooser-unselect-all
  input parameter chooser :: <GtkFileChooser>;
  c-name: "gtk_file_chooser_unselect_all";
end;

define C-function gtk-file-chooser-get-filenames-utf8
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GSList>;
  c-name: "gtk_file_chooser_get_filenames_utf8";
end;

define C-function gtk-file-chooser-set-current-folder-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter filename :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_set_current_folder_utf8";
end;

define C-function gtk-file-chooser-get-current-folder-utf8
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_current_folder_utf8";
end;

define C-function gtk-file-chooser-get-uri
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_uri";
end;

define C-function gtk-file-chooser-set-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_set_uri";
end;

define C-function gtk-file-chooser-select-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_select_uri";
end;

define C-function gtk-file-chooser-unselect-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  c-name: "gtk_file_chooser_unselect_uri";
end;

define C-function gtk-file-chooser-get-uris
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GSList>;
  c-name: "gtk_file_chooser_get_uris";
end;

define C-function gtk-file-chooser-set-current-folder-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_set_current_folder_uri";
end;

define C-function gtk-file-chooser-get-current-folder-uri
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_current_folder_uri";
end;

define C-function gtk-file-chooser-set-preview-widget
  input parameter chooser :: <GtkFileChooser>;
  input parameter preview_widget :: <GtkWidget>;
  c-name: "gtk_file_chooser_set_preview_widget";
end;

define C-function gtk-file-chooser-get-preview-widget
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_get_preview_widget";
end;

define C-function gtk-file-chooser-set-preview-widget-active
  input parameter chooser :: <GtkFileChooser>;
  input parameter active :: <gboolean>;
  c-name: "gtk_file_chooser_set_preview_widget_active";
end;

define C-function gtk-file-chooser-get-preview-widget-active
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_preview_widget_active";
end;

define C-function gtk-file-chooser-set-use-preview-label
  input parameter chooser :: <GtkFileChooser>;
  input parameter use_label :: <gboolean>;
  c-name: "gtk_file_chooser_set_use_preview_label";
end;

define C-function gtk-file-chooser-get-use-preview-label
  input parameter chooser :: <GtkFileChooser>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_get_use_preview_label";
end;

define C-function gtk-file-chooser-get-preview-filename-utf8
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_preview_filename_utf8";
end;

define C-function gtk-file-chooser-get-preview-uri
  input parameter chooser :: <GtkFileChooser>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_get_preview_uri";
end;

define C-function gtk-file-chooser-set-extra-widget
  input parameter chooser :: <GtkFileChooser>;
  input parameter extra_widget :: <GtkWidget>;
  c-name: "gtk_file_chooser_set_extra_widget";
end;

define C-function gtk-file-chooser-get-extra-widget
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_get_extra_widget";
end;

define C-subtype <_GtkFileFilter> (<C-void*>) end;
define constant <GtkFileFilter> = <_GtkFileFilter>;

define C-function gtk-file-chooser-add-filter
  input parameter chooser :: <GtkFileChooser>;
  input parameter filter :: <GtkFileFilter>;
  c-name: "gtk_file_chooser_add_filter";
end;

define C-function gtk-file-chooser-remove-filter
  input parameter chooser :: <GtkFileChooser>;
  input parameter filter :: <GtkFileFilter>;
  c-name: "gtk_file_chooser_remove_filter";
end;

define C-function gtk-file-chooser-list-filters
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GSList>;
  c-name: "gtk_file_chooser_list_filters";
end;

define C-function gtk-file-chooser-set-filter
  input parameter chooser :: <GtkFileChooser>;
  input parameter filter :: <GtkFileFilter>;
  c-name: "gtk_file_chooser_set_filter";
end;

define C-function gtk-file-chooser-get-filter
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GtkFileFilter>;
  c-name: "gtk_file_chooser_get_filter";
end;

define C-function gtk-file-chooser-add-shortcut-folder-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter folder :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_add_shortcut_folder_utf8";
end;

define C-function gtk-file-chooser-remove-shortcut-folder-utf8
  input parameter chooser :: <GtkFileChooser>;
  input parameter folder :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_remove_shortcut_folder_utf8";
end;

define C-function gtk-file-chooser-list-shortcut-folders-utf8
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GSList>;
  c-name: "gtk_file_chooser_list_shortcut_folders_utf8";
end;

define C-function gtk-file-chooser-add-shortcut-folder-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_add_shortcut_folder_uri";
end;

define C-function gtk-file-chooser-remove-shortcut-folder-uri
  input parameter chooser :: <GtkFileChooser>;
  input parameter uri :: <c-string>;
  input parameter error :: <GError*>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_remove_shortcut_folder_uri";
end;

define C-function gtk-file-chooser-list-shortcut-folder-uris
  input parameter chooser :: <GtkFileChooser>;
  result res :: <GSList>;
  c-name: "gtk_file_chooser_list_shortcut_folder_uris";
end;

define constant gtk-file-chooser-get-filename = gtk-file-chooser-get-filename-utf8;

define constant gtk-file-chooser-set-filename = gtk-file-chooser-set-filename-utf8;

define constant gtk-file-chooser-select-filename = gtk-file-chooser-select-filename-utf8;

define constant gtk-file-chooser-unselect-filename = gtk-file-chooser-unselect-filename-utf8;

define constant gtk-file-chooser-get-filenames = gtk-file-chooser-get-filenames-utf8;

define constant gtk-file-chooser-set-current-folder = gtk-file-chooser-set-current-folder-utf8;

define constant gtk-file-chooser-get-current-folder = gtk-file-chooser-get-current-folder-utf8;

define constant gtk-file-chooser-get-preview-filename = gtk-file-chooser-get-preview-filename-utf8;

define constant gtk-file-chooser-add-shortcut-folder = gtk-file-chooser-add-shortcut-folder-utf8;

define constant gtk-file-chooser-remove-shortcut-folder = gtk-file-chooser-remove-shortcut-folder-utf8;

define constant gtk-file-chooser-list-shortcut-folders = gtk-file-chooser-list-shortcut-folders-utf8;

define constant <GtkFileFilterFlags> = limited(<integer>, min: 1, max: 8);
define constant $GTK-FILE-FILTER-FILENAME :: <GtkFileFilterFlags> = 1;
define constant $GTK-FILE-FILTER-URI :: <GtkFileFilterFlags> = 2;
define constant $GTK-FILE-FILTER-DISPLAY-NAME :: <GtkFileFilterFlags> = 4;
define constant $GTK-FILE-FILTER-MIME-TYPE :: <GtkFileFilterFlags> = 8;

define C-subtype <_GtkFileFilterInfo> (<C-void*>) end;
define constant <GtkFileFilterInfo> = <_GtkFileFilterInfo>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6376>"*/
define constant <GtkFileFilterFunc> = <anonymous-6376>;

define C-function gtk-file-filter-get-type
  result res :: <GType>;
  c-name: "gtk_file_filter_get_type";
end;

define C-function gtk-file-filter-new
  result res :: <GtkFileFilter>;
  c-name: "gtk_file_filter_new";
end;

define C-function gtk-file-filter-set-name
  input parameter filter :: <GtkFileFilter>;
  input parameter name :: <c-string>;
  c-name: "gtk_file_filter_set_name";
end;

define C-function gtk-file-filter-get-name
  input parameter filter :: <GtkFileFilter>;
  result res :: <c-string>;
  c-name: "gtk_file_filter_get_name";
end;

define C-function gtk-file-filter-add-mime-type
  input parameter filter :: <GtkFileFilter>;
  input parameter mime_type :: <c-string>;
  c-name: "gtk_file_filter_add_mime_type";
end;

define C-function gtk-file-filter-add-pattern
  input parameter filter :: <GtkFileFilter>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_file_filter_add_pattern";
end;

define C-function gtk-file-filter-add-pixbuf-formats
  input parameter filter :: <GtkFileFilter>;
  c-name: "gtk_file_filter_add_pixbuf_formats";
end;

define C-function gtk-file-filter-add-custom
  input parameter filter :: <GtkFileFilter>;
  input parameter needed :: <GtkFileFilterFlags>;
  input parameter func :: <GtkFileFilterFunc>;
  input parameter data :: <gpointer>;
  input parameter notify :: <GDestroyNotify>;
  c-name: "gtk_file_filter_add_custom";
end;

define C-function gtk-file-filter-get-needed
  input parameter filter :: <GtkFileFilter>;
  result res :: <GtkFileFilterFlags>;
  c-name: "gtk_file_filter_get_needed";
end;

define C-function gtk-file-filter-filter
  input parameter filter :: <GtkFileFilter>;
  input parameter filter_info :: <GtkFileFilterInfo>;
  result res :: <gboolean>;
  c-name: "gtk_file_filter_filter";
end;

define C-subtype <_GtkFileChooserDialogPrivate> (<C-void*>) end;
define constant <GtkFileChooserDialogPrivate> = <_GtkFileChooserDialogPrivate>;

define C-subtype <_GtkFileChooserDialog> (<C-void*>) end;
define constant <GtkFileChooserDialog> = <_GtkFileChooserDialog>;

define C-subtype <_GtkFileChooserDialogClass> (<C-void*>) end;
define constant <GtkFileChooserDialogClass> = <_GtkFileChooserDialogClass>;

define C-function gtk-file-chooser-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_dialog_get_type";
end;

define C-function gtk-file-chooser-dialog-new
  input parameter title :: <c-string>;
  input parameter parent :: <GtkWindow>;
  input parameter action :: <GtkFileChooserAction>;
  input parameter first_button_text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_dialog_new";
end;

define C-function gtk-file-chooser-dialog-new-with-backend
  input parameter title :: <c-string>;
  input parameter parent :: <GtkWindow>;
  input parameter action :: <GtkFileChooserAction>;
  input parameter backend :: <c-string>;
  input parameter first_button_text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_dialog_new_with_backend";
end;

define C-subtype <_GtkFileChooserButtonPrivate> (<C-void*>) end;
define constant <GtkFileChooserButtonPrivate> = <_GtkFileChooserButtonPrivate>;

define C-subtype <_GtkFileChooserButton> (<C-void*>) end;
define constant <GtkFileChooserButton> = <_GtkFileChooserButton>;

define C-subtype <_GtkFileChooserButtonClass> (<C-void*>) end;
define constant <GtkFileChooserButtonClass> = <_GtkFileChooserButtonClass>;

define C-function gtk-file-chooser-button-get-type
  result res :: <GType>;
  c-name: "gtk_file_chooser_button_get_type";
end;

define C-function gtk-file-chooser-button-new
  input parameter title :: <c-string>;
  input parameter action :: <GtkFileChooserAction>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_button_new";
end;

define C-function gtk-file-chooser-button-new-with-backend
  input parameter title :: <c-string>;
  input parameter action :: <GtkFileChooserAction>;
  input parameter backend :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_button_new_with_backend";
end;

define C-function gtk-file-chooser-button-new-with-dialog
  input parameter dialog :: <GtkWidget>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_chooser_button_new_with_dialog";
end;

define C-function gtk-file-chooser-button-get-title
  input parameter button :: <GtkFileChooserButton>;
  result res :: <c-string>;
  c-name: "gtk_file_chooser_button_get_title";
end;

define C-function gtk-file-chooser-button-set-title
  input parameter button :: <GtkFileChooserButton>;
  input parameter title :: <c-string>;
  c-name: "gtk_file_chooser_button_set_title";
end;

define C-function gtk-file-chooser-button-get-width-chars
  input parameter button :: <GtkFileChooserButton>;
  result res :: <gint>;
  c-name: "gtk_file_chooser_button_get_width_chars";
end;

define C-function gtk-file-chooser-button-set-width-chars
  input parameter button :: <GtkFileChooserButton>;
  input parameter n_chars :: <gint>;
  c-name: "gtk_file_chooser_button_set_width_chars";
end;

define C-function gtk-file-chooser-button-get-focus-on-click
  input parameter button :: <GtkFileChooserButton>;
  result res :: <gboolean>;
  c-name: "gtk_file_chooser_button_get_focus_on_click";
end;

define C-function gtk-file-chooser-button-set-focus-on-click
  input parameter button :: <GtkFileChooserButton>;
  input parameter focus_on_click :: <gboolean>;
  c-name: "gtk_file_chooser_button_set_focus_on_click";
end;

define C-subtype <_GtkFixed> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkFixed> = <_GtkFixed>;

define C-subtype <_GtkFixedClass> (<C-void*>) end;
define constant <GtkFixedClass> = <_GtkFixedClass>;

define C-subtype <_GtkFixedChild> (<C-void*>) end;
define constant <GtkFixedChild> = <_GtkFixedChild>;

define C-function gtk-fixed-get-type
  result res :: <GType>;
  c-name: "gtk_fixed_get_type";
end;

define C-function gtk-fixed-new
  result res :: <GtkWidget>;
  c-name: "gtk_fixed_new";
end;

define C-function gtk-fixed-put
  input parameter fixed :: <GtkFixed>;
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_fixed_put";
end;

define C-function gtk-fixed-move
  input parameter fixed :: <GtkFixed>;
  input parameter widget :: <GtkWidget>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  c-name: "gtk_fixed_move";
end;

define C-function gtk-fixed-set-has-window
  input parameter fixed :: <GtkFixed>;
  input parameter has_window :: <gboolean>;
  c-name: "gtk_fixed_set_has_window";
end;

define C-function gtk-fixed-get-has-window
  input parameter fixed :: <GtkFixed>;
  result res :: <gboolean>;
  c-name: "gtk_fixed_get_has_window";
end;

define C-subtype <_GtkFileSelection> (<GtkDialog>, <AtkImplementorIface>) end;
define constant <GtkFileSelection> = <_GtkFileSelection>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6355>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6356>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6357>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6358>"*/
define C-subtype <_GtkFileSelectionClass> (<C-void*>) end;
define constant <GtkFileSelectionClass> = <_GtkFileSelectionClass>;

define C-function gtk-file-selection-get-type
  result res :: <GType>;
  c-name: "gtk_file_selection_get_type";
end;

define C-function gtk-file-selection-new
  input parameter title :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_file_selection_new";
end;

define C-function gtk-file-selection-set-filename-utf8
  input parameter filesel :: <GtkFileSelection>;
  input parameter filename :: <c-string>;
  c-name: "gtk_file_selection_set_filename_utf8";
end;

define C-function gtk-file-selection-get-filename-utf8
  input parameter filesel :: <GtkFileSelection>;
  result res :: <c-string>;
  c-name: "gtk_file_selection_get_filename_utf8";
end;

define C-function gtk-file-selection-complete
  input parameter filesel :: <GtkFileSelection>;
  input parameter pattern :: <c-string>;
  c-name: "gtk_file_selection_complete";
end;

define C-function gtk-file-selection-show-fileop-buttons
  input parameter filesel :: <GtkFileSelection>;
  c-name: "gtk_file_selection_show_fileop_buttons";
end;

define C-function gtk-file-selection-hide-fileop-buttons
  input parameter filesel :: <GtkFileSelection>;
  c-name: "gtk_file_selection_hide_fileop_buttons";
end;

define C-function gtk-file-selection-get-selections-utf8
  input parameter filesel :: <GtkFileSelection>;
  result res :: <gchar**>;
  c-name: "gtk_file_selection_get_selections_utf8";
end;

define C-function gtk-file-selection-set-select-multiple
  input parameter filesel :: <GtkFileSelection>;
  input parameter select_multiple :: <gboolean>;
  c-name: "gtk_file_selection_set_select_multiple";
end;

define C-function gtk-file-selection-get-select-multiple
  input parameter filesel :: <GtkFileSelection>;
  result res :: <gboolean>;
  c-name: "gtk_file_selection_get_select_multiple";
end;

define constant gtk-file-selection-get-filename = gtk-file-selection-get-filename-utf8;

define constant gtk-file-selection-set-filename = gtk-file-selection-set-filename-utf8;

define constant gtk-file-selection-get-selections = gtk-file-selection-get-selections-utf8;

define C-subtype <_GtkExpanderPrivate> (<C-void*>) end;
define constant <GtkExpanderPrivate> = <_GtkExpanderPrivate>;

define C-subtype <_GtkExpander> (<C-void*>) end;
define constant <GtkExpander> = <_GtkExpander>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6339>"*/
define C-subtype <_GtkExpanderClass> (<C-void*>) end;
define constant <GtkExpanderClass> = <_GtkExpanderClass>;

define C-function gtk-expander-get-type
  result res :: <GType>;
  c-name: "gtk_expander_get_type";
end;

define C-function gtk-expander-new
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_expander_new";
end;

define C-function gtk-expander-new-with-mnemonic
  input parameter label :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_expander_new_with_mnemonic";
end;

define C-function gtk-expander-set-expanded
  input parameter expander :: <GtkExpander>;
  input parameter expanded :: <gboolean>;
  c-name: "gtk_expander_set_expanded";
end;

define C-function gtk-expander-get-expanded
  input parameter expander :: <GtkExpander>;
  result res :: <gboolean>;
  c-name: "gtk_expander_get_expanded";
end;

define C-function gtk-expander-set-spacing
  input parameter expander :: <GtkExpander>;
  input parameter spacing :: <gint>;
  c-name: "gtk_expander_set_spacing";
end;

define C-function gtk-expander-get-spacing
  input parameter expander :: <GtkExpander>;
  result res :: <gint>;
  c-name: "gtk_expander_get_spacing";
end;

define C-function gtk-expander-set-label
  input parameter expander :: <GtkExpander>;
  input parameter label :: <c-string>;
  c-name: "gtk_expander_set_label";
end;

define C-function gtk-expander-get-label
  input parameter expander :: <GtkExpander>;
  result res :: <c-string>;
  c-name: "gtk_expander_get_label";
end;

define C-function gtk-expander-set-use-underline
  input parameter expander :: <GtkExpander>;
  input parameter use_underline :: <gboolean>;
  c-name: "gtk_expander_set_use_underline";
end;

define C-function gtk-expander-get-use-underline
  input parameter expander :: <GtkExpander>;
  result res :: <gboolean>;
  c-name: "gtk_expander_get_use_underline";
end;

define C-function gtk-expander-set-use-markup
  input parameter expander :: <GtkExpander>;
  input parameter use_markup :: <gboolean>;
  c-name: "gtk_expander_set_use_markup";
end;

define C-function gtk-expander-get-use-markup
  input parameter expander :: <GtkExpander>;
  result res :: <gboolean>;
  c-name: "gtk_expander_get_use_markup";
end;

define C-function gtk-expander-set-label-widget
  input parameter expander :: <GtkExpander>;
  input parameter label_widget :: <GtkWidget>;
  c-name: "gtk_expander_set_label_widget";
end;

define C-function gtk-expander-get-label-widget
  input parameter expander :: <GtkExpander>;
  result res :: <GtkWidget>;
  c-name: "gtk_expander_get_label_widget";
end;

define C-subtype <_GtkEventBox> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkEventBox> = <_GtkEventBox>;

define C-subtype <_GtkEventBoxClass> (<C-void*>) end;
define constant <GtkEventBoxClass> = <_GtkEventBoxClass>;

define C-function gtk-event-box-get-type
  result res :: <GType>;
  c-name: "gtk_event_box_get_type";
end;

define C-function gtk-event-box-new
  result res :: <GtkWidget>;
  c-name: "gtk_event_box_new";
end;

define C-function gtk-event-box-get-visible-window
  input parameter event_box :: <GtkEventBox>;
  result res :: <gboolean>;
  c-name: "gtk_event_box_get_visible_window";
end;

define C-function gtk-event-box-set-visible-window
  input parameter event_box :: <GtkEventBox>;
  input parameter visible_window :: <gboolean>;
  c-name: "gtk_event_box_set_visible_window";
end;

define C-function gtk-event-box-get-above-child
  input parameter event_box :: <GtkEventBox>;
  result res :: <gboolean>;
  c-name: "gtk_event_box_get_above_child";
end;

define C-function gtk-event-box-set-above-child
  input parameter event_box :: <GtkEventBox>;
  input parameter above_child :: <gboolean>;
  c-name: "gtk_event_box_set_above_child";
end;

define C-subtype <_GtkDrawingArea> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkDrawingArea> = <_GtkDrawingArea>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6313>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6314>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6315>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6316>"*/
define C-subtype <_GtkDrawingAreaClass> (<C-void*>) end;
define constant <GtkDrawingAreaClass> = <_GtkDrawingAreaClass>;

define C-function gtk-drawing-area-get-type
  result res :: <GType>;
  c-name: "gtk_drawing_area_get_type";
end;

define C-function gtk-drawing-area-new
  result res :: <GtkWidget>;
  c-name: "gtk_drawing_area_new";
end;

define C-function gtk-drawing-area-size
  input parameter darea :: <GtkDrawingArea>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  c-name: "gtk_drawing_area_size";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gfloat<@2>>"*/
define C-subtype <_GtkCurve> (<GtkDrawingArea>, <AtkImplementorIface>) end;
define constant <GtkCurve> = <_GtkCurve>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6320>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6321>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6322>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6323>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6324>"*/
define C-subtype <_GtkCurveClass> (<C-void*>) end;
define constant <GtkCurveClass> = <_GtkCurveClass>;

define C-function gtk-curve-get-type
  result res :: <GType>;
  c-name: "gtk_curve_get_type";
end;

define C-function gtk-curve-new
  result res :: <GtkWidget>;
  c-name: "gtk_curve_new";
end;

define C-function gtk-curve-reset
  input parameter curve :: <GtkCurve>;
  c-name: "gtk_curve_reset";
end;

define C-function gtk-curve-set-gamma
  input parameter curve :: <GtkCurve>;
  input parameter gamma_ :: <gfloat>;
  c-name: "gtk_curve_set_gamma";
end;

define C-function gtk-curve-set-range
  input parameter curve :: <GtkCurve>;
  input parameter min_x :: <gfloat>;
  input parameter max_x :: <gfloat>;
  input parameter min_y :: <gfloat>;
  input parameter max_y :: <gfloat>;
  c-name: "gtk_curve_set_range";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gfloat<@>>"*/
define C-function gtk-curve-get-vector
  input parameter curve :: <GtkCurve>;
  input parameter veclen :: <integer>;
  input parameter vector :: <gfloat<@>>;
  c-name: "gtk_curve_get_vector";
end;

define C-function gtk-curve-set-vector
  input parameter curve :: <GtkCurve>;
  input parameter veclen :: <integer>;
  input parameter vector :: <gfloat<@>>;
  c-name: "gtk_curve_set_vector";
end;

define C-function gtk-curve-set-curve-type
  input parameter curve :: <GtkCurve>;
  input parameter type :: <GtkCurveType>;
  c-name: "gtk_curve_set_curve_type";
end;

define constant <GtkCTreePos> = limited(<integer>, min: 0, max: 2);
define constant $GTK-CTREE-POS-BEFORE :: <GtkCTreePos> = 0;
define constant $GTK-CTREE-POS-AS-CHILD :: <GtkCTreePos> = 1;
define constant $GTK-CTREE-POS-AFTER :: <GtkCTreePos> = 2;

define constant <GtkCTreeLineStyle> = limited(<integer>, min: 0, max: 3);
define constant $GTK-CTREE-LINES-NONE :: <GtkCTreeLineStyle> = 0;
define constant $GTK-CTREE-LINES-SOLID :: <GtkCTreeLineStyle> = 1;
define constant $GTK-CTREE-LINES-DOTTED :: <GtkCTreeLineStyle> = 2;
define constant $GTK-CTREE-LINES-TABBED :: <GtkCTreeLineStyle> = 3;

define constant <GtkCTreeExpanderStyle> = limited(<integer>, min: 0, max: 3);
define constant $GTK-CTREE-EXPANDER-NONE :: <GtkCTreeExpanderStyle> = 0;
define constant $GTK-CTREE-EXPANDER-SQUARE :: <GtkCTreeExpanderStyle> = 1;
define constant $GTK-CTREE-EXPANDER-TRIANGLE :: <GtkCTreeExpanderStyle> = 2;
define constant $GTK-CTREE-EXPANDER-CIRCULAR :: <GtkCTreeExpanderStyle> = 3;

define constant <GtkCTreeExpansionType> = limited(<integer>, min: 0, max: 5);
define constant $GTK-CTREE-EXPANSION-EXPAND :: <GtkCTreeExpansionType> = 0;
define constant $GTK-CTREE-EXPANSION-EXPAND-RECURSIVE :: <GtkCTreeExpansionType> = 1;
define constant $GTK-CTREE-EXPANSION-COLLAPSE :: <GtkCTreeExpansionType> = 2;
define constant $GTK-CTREE-EXPANSION-COLLAPSE-RECURSIVE :: <GtkCTreeExpansionType> = 3;
define constant $GTK-CTREE-EXPANSION-TOGGLE :: <GtkCTreeExpansionType> = 4;
define constant $GTK-CTREE-EXPANSION-TOGGLE-RECURSIVE :: <GtkCTreeExpansionType> = 5;

define C-subtype <_GtkCListColumn> (<C-void*>) end;
define constant <GtkCListColumn> = <_GtkCListColumn>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<guint8<@5>>"*/
define C-subtype <_GtkCListCellInfo> (<C-void*>) end;
define constant <GtkCListCellInfo> = <_GtkCListCellInfo>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5644>"*/
define constant <GtkCListCompareFunc> = <anonymous-5644>;

define constant <GtkCListDragPos> = limited(<integer>, min: 0, max: 3);
define constant $GTK-CLIST-DRAG-NONE :: <GtkCListDragPos> = 0;
define constant $GTK-CLIST-DRAG-BEFORE :: <GtkCListDragPos> = 1;
define constant $GTK-CLIST-DRAG-INTO :: <GtkCListDragPos> = 2;
define constant $GTK-CLIST-DRAG-AFTER :: <GtkCListDragPos> = 3;

define C-subtype <_GtkCList> (<GtkContainer>, <AtkImplementorIface>) end;
define constant <GtkCList> = <_GtkCList>;

define constant <GtkCTree> = <_GtkCTree>;

define C-subtype <_GtkCTreeNode> (<C-void*>) end;
define constant <GtkCTreeNode> = <_GtkCTreeNode>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6233>"*/
define constant <GtkCTreeCompareDragFunc> = <anonymous-6233>;

define C-subtype <_GtkCTree> (<GtkCList>, <AtkImplementorIface>) end;
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5645>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5646>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5647>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5648>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5649>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5650>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5651>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5652>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5653>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5654>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5655>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5656>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5657>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5658>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5659>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5660>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5661>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5662>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5663>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5664>"*/
define constant <GtkCellType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-CELL-EMPTY :: <GtkCellType> = 0;
define constant $GTK-CELL-TEXT :: <GtkCellType> = 1;
define constant $GTK-CELL-PIXMAP :: <GtkCellType> = 2;
define constant $GTK-CELL-PIXTEXT :: <GtkCellType> = 3;
define constant $GTK-CELL-WIDGET :: <GtkCellType> = 4;

define C-subtype <anonymous-5682> (<C-void*>) end;
define C-subtype <anonymous-5683> (<C-void*>) end;
 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-5684>"*/
define C-subtype <_GtkCell> (<C-void*>) end;
define constant <GtkCell> = <_GtkCell>;

define C-subtype <_GtkCListRow> (<C-void*>) end;
define constant <GtkCListRow> = <_GtkCListRow>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5665>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5666>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5667>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5668>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5669>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5670>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5671>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5672>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5673>"*/
define C-subtype <_GtkCListClass> (<C-void*>) end;
define constant <GtkCListClass> = <_GtkCListClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6237>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6238>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6239>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6240>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6241>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6242>"*/
define C-subtype <_GtkCTreeClass> (<C-void*>) end;
define constant <GtkCTreeClass> = <_GtkCTreeClass>;

define C-subtype <_GtkCTreeRow> (<C-void*>) end;
define constant <GtkCTreeRow> = <_GtkCTreeRow>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6231>"*/
define constant <GtkCTreeFunc> = <anonymous-6231>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6232>"*/
define constant <GtkCTreeGNodeFunc> = <anonymous-6232>;

define C-function gtk-ctree-get-type
  result res :: <GtkType>;
  c-name: "gtk_ctree_get_type";
end;

define C-function gtk-ctree-new-with-titles
  input parameter columns :: <gint>;
  input parameter tree_column :: <gint>;
  input parameter titles :: <gchar*<@>>;
  result res :: <GtkWidget>;
  c-name: "gtk_ctree_new_with_titles";
end;

define C-function gtk-ctree-new
  input parameter columns :: <gint>;
  input parameter tree_column :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_ctree_new";
end;

define C-function gtk-ctree-insert-node
  input parameter ctree :: <GtkCTree>;
  input parameter parent :: <GtkCTreeNode>;
  input parameter sibling :: <GtkCTreeNode>;
  input parameter text :: <gchar*<@>>;
  input parameter spacing :: <guint8>;
  input parameter pixmap_closed :: <GdkPixmap>;
  input parameter mask_closed :: <GdkBitmap>;
  input parameter pixmap_opened :: <GdkPixmap>;
  input parameter mask_opened :: <GdkBitmap>;
  input parameter is_leaf :: <gboolean>;
  input parameter expanded :: <gboolean>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_insert_node";
end;

define C-function gtk-ctree-remove-node
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_remove_node";
end;

define C-function gtk-ctree-insert-gnode
  input parameter ctree :: <GtkCTree>;
  input parameter parent :: <GtkCTreeNode>;
  input parameter sibling :: <GtkCTreeNode>;
  input parameter gnode :: <GNode>;
  input parameter func :: <GtkCTreeGNodeFunc>;
  input parameter data :: <gpointer>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_insert_gnode";
end;

define C-function gtk-ctree-export-to-gnode
  input parameter ctree :: <GtkCTree>;
  input parameter parent :: <GNode>;
  input parameter sibling :: <GNode>;
  input parameter node :: <GtkCTreeNode>;
  input parameter func :: <GtkCTreeGNodeFunc>;
  input parameter data :: <gpointer>;
  result res :: <GNode>;
  c-name: "gtk_ctree_export_to_gnode";
end;

define C-function gtk-ctree-post-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter func :: <GtkCTreeFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_ctree_post_recursive";
end;

define C-function gtk-ctree-post-recursive-to-depth
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter depth :: <gint>;
  input parameter func :: <GtkCTreeFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_ctree_post_recursive_to_depth";
end;

define C-function gtk-ctree-pre-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter func :: <GtkCTreeFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_ctree_pre_recursive";
end;

define C-function gtk-ctree-pre-recursive-to-depth
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter depth :: <gint>;
  input parameter func :: <GtkCTreeFunc>;
  input parameter data :: <gpointer>;
  c-name: "gtk_ctree_pre_recursive_to_depth";
end;

define C-function gtk-ctree-is-viewable
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_is_viewable";
end;

define C-function gtk-ctree-last
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_last";
end;

define C-function gtk-ctree-find-node-ptr
  input parameter ctree :: <GtkCTree>;
  input parameter ctree_row :: <GtkCTreeRow>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_find_node_ptr";
end;

define C-function gtk-ctree-node-nth
  input parameter ctree :: <GtkCTree>;
  input parameter row :: <guint>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_node_nth";
end;

define C-function gtk-ctree-find
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter child :: <GtkCTreeNode>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_find";
end;

define C-function gtk-ctree-is-ancestor
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter child :: <GtkCTreeNode>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_is_ancestor";
end;

define C-function gtk-ctree-find-by-row-data
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_find_by_row_data";
end;

define C-function gtk-ctree-find-all-by-row-data
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  result res :: <GList>;
  c-name: "gtk_ctree_find_all_by_row_data";
end;

define C-function gtk-ctree-find-by-row-data-custom
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GtkCTreeNode>;
  c-name: "gtk_ctree_find_by_row_data_custom";
end;

define C-function gtk-ctree-find-all-by-row-data-custom
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  input parameter func :: <GCompareFunc>;
  result res :: <GList>;
  c-name: "gtk_ctree_find_all_by_row_data_custom";
end;

define C-function gtk-ctree-is-hot-spot
  input parameter ctree :: <GtkCTree>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_is_hot_spot";
end;

define C-function gtk-ctree-move
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter new_parent :: <GtkCTreeNode>;
  input parameter new_sibling :: <GtkCTreeNode>;
  c-name: "gtk_ctree_move";
end;

define C-function gtk-ctree-expand
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_expand";
end;

define C-function gtk-ctree-expand-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_expand_recursive";
end;

define C-function gtk-ctree-expand-to-depth
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter depth :: <gint>;
  c-name: "gtk_ctree_expand_to_depth";
end;

define C-function gtk-ctree-collapse
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_collapse";
end;

define C-function gtk-ctree-collapse-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_collapse_recursive";
end;

define C-function gtk-ctree-collapse-to-depth
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter depth :: <gint>;
  c-name: "gtk_ctree_collapse_to_depth";
end;

define C-function gtk-ctree-toggle-expansion
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_toggle_expansion";
end;

define C-function gtk-ctree-toggle-expansion-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_toggle_expansion_recursive";
end;

define C-function gtk-ctree-select
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_select";
end;

define C-function gtk-ctree-select-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_select_recursive";
end;

define C-function gtk-ctree-unselect
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_unselect";
end;

define C-function gtk-ctree-unselect-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_unselect_recursive";
end;

define C-function gtk-ctree-real-select-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter state :: <gint>;
  c-name: "gtk_ctree_real_select_recursive";
end;

define C-function gtk-ctree-node-set-text
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter text :: <c-string>;
  c-name: "gtk_ctree_node_set_text";
end;

define C-function gtk-ctree-node-set-pixmap
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_ctree_node_set_pixmap";
end;

define C-function gtk-ctree-node-set-pixtext
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter text :: <c-string>;
  input parameter spacing :: <guint8>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_ctree_node_set_pixtext";
end;

define C-function gtk-ctree-set-node-info
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter text :: <c-string>;
  input parameter spacing :: <guint8>;
  input parameter pixmap_closed :: <GdkPixmap>;
  input parameter mask_closed :: <GdkBitmap>;
  input parameter pixmap_opened :: <GdkPixmap>;
  input parameter mask_opened :: <GdkBitmap>;
  input parameter is_leaf :: <gboolean>;
  input parameter expanded :: <gboolean>;
  c-name: "gtk_ctree_set_node_info";
end;

define C-function gtk-ctree-node-set-shift
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter vertical :: <gint>;
  input parameter horizontal :: <gint>;
  c-name: "gtk_ctree_node_set_shift";
end;

define C-function gtk-ctree-node-set-selectable
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter selectable :: <gboolean>;
  c-name: "gtk_ctree_node_set_selectable";
end;

define C-function gtk-ctree-node-get-selectable
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_node_get_selectable";
end;

define C-function gtk-ctree-node-get-cell-type
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  result res :: <GtkCellType>;
  c-name: "gtk_ctree_node_get_cell_type";
end;

define C-function gtk-ctree-node-get-text
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter text :: <gchar**>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_node_get_text";
end;

define C-function gtk-ctree-node-get-pixmap
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter pixmap :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_node_get_pixmap";
end;

define C-function gtk-ctree-node-get-pixtext
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter text :: <gchar**>;
  input parameter spacing :: <guint8*>;
  input parameter pixmap :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_node_get_pixtext";
end;

define C-function gtk-ctree-get-node-info
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter text :: <gchar**>;
  input parameter spacing :: <guint8*>;
  input parameter pixmap_closed :: <GdkPixmap*>;
  input parameter mask_closed :: <GdkBitmap*>;
  input parameter pixmap_opened :: <GdkPixmap*>;
  input parameter mask_opened :: <GdkBitmap*>;
  input parameter is_leaf :: <gboolean*>;
  input parameter expanded :: <gboolean*>;
  result res :: <gboolean>;
  c-name: "gtk_ctree_get_node_info";
end;

define C-function gtk-ctree-node-set-row-style
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter style :: <GtkStyle>;
  c-name: "gtk_ctree_node_set_row_style";
end;

define C-function gtk-ctree-node-get-row-style
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <GtkStyle>;
  c-name: "gtk_ctree_node_get_row_style";
end;

define C-function gtk-ctree-node-set-cell-style
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter style :: <GtkStyle>;
  c-name: "gtk_ctree_node_set_cell_style";
end;

define C-function gtk-ctree-node-get-cell-style
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  result res :: <GtkStyle>;
  c-name: "gtk_ctree_node_get_cell_style";
end;

define C-function gtk-ctree-node-set-foreground
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_ctree_node_set_foreground";
end;

define C-function gtk-ctree-node-set-background
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_ctree_node_set_background";
end;

define C-function gtk-ctree-node-set-row-data
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  c-name: "gtk_ctree_node_set_row_data";
end;

define C-function gtk-ctree-node-set-row-data-full
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_ctree_node_set_row_data_full";
end;

define C-function gtk-ctree-node-get-row-data
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <gpointer>;
  c-name: "gtk_ctree_node_get_row_data";
end;

define C-function gtk-ctree-node-moveto
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  input parameter column :: <gint>;
  input parameter row_align :: <gfloat>;
  input parameter col_align :: <gfloat>;
  c-name: "gtk_ctree_node_moveto";
end;

define C-function gtk-ctree-node-is-visible
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  result res :: <GtkVisibility>;
  c-name: "gtk_ctree_node_is_visible";
end;

define C-function gtk-ctree-set-indent
  input parameter ctree :: <GtkCTree>;
  input parameter indent :: <gint>;
  c-name: "gtk_ctree_set_indent";
end;

define C-function gtk-ctree-set-spacing
  input parameter ctree :: <GtkCTree>;
  input parameter spacing :: <gint>;
  c-name: "gtk_ctree_set_spacing";
end;

define C-function gtk-ctree-set-show-stub
  input parameter ctree :: <GtkCTree>;
  input parameter show_stub :: <gboolean>;
  c-name: "gtk_ctree_set_show_stub";
end;

define C-function gtk-ctree-set-line-style
  input parameter ctree :: <GtkCTree>;
  input parameter line_style :: <GtkCTreeLineStyle>;
  c-name: "gtk_ctree_set_line_style";
end;

define C-function gtk-ctree-set-expander-style
  input parameter ctree :: <GtkCTree>;
  input parameter expander_style :: <GtkCTreeExpanderStyle>;
  c-name: "gtk_ctree_set_expander_style";
end;

define C-function gtk-ctree-set-drag-compare-func
  input parameter ctree :: <GtkCTree>;
  input parameter cmp_func :: <GtkCTreeCompareDragFunc>;
  c-name: "gtk_ctree_set_drag_compare_func";
end;

define C-function gtk-ctree-sort-node
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_sort_node";
end;

define C-function gtk-ctree-sort-recursive
  input parameter ctree :: <GtkCTree>;
  input parameter node :: <GtkCTreeNode>;
  c-name: "gtk_ctree_sort_recursive";
end;

define C-function gtk-ctree-node-get-type
  result res :: <GType>;
  c-name: "gtk_ctree_node_get_type";
end;

define constant <anonymous-5640> = limited(<integer>, min: 1, max: 1024);
define constant $GTK-CLIST-IN-DRAG :: <anonymous-5640> = 1;
define constant $GTK-CLIST-ROW-HEIGHT-SET :: <anonymous-5640> = 2;
define constant $GTK-CLIST-SHOW-TITLES :: <anonymous-5640> = 4;
define constant $GTK-CLIST-ADD-MODE :: <anonymous-5640> = 16;
define constant $GTK-CLIST-AUTO-SORT :: <anonymous-5640> = 32;
define constant $GTK-CLIST-AUTO-RESIZE-BLOCKED :: <anonymous-5640> = 64;
define constant $GTK-CLIST-REORDERABLE :: <anonymous-5640> = 128;
define constant $GTK-CLIST-USE-DRAG-ICONS :: <anonymous-5640> = 256;
define constant $GTK-CLIST-DRAW-DRAG-LINE :: <anonymous-5640> = 512;
define constant $GTK-CLIST-DRAW-DRAG-RECT :: <anonymous-5640> = 1024;

define constant <GtkButtonAction> = limited(<integer>, min: 0, max: 4);
define constant $GTK-BUTTON-IGNORED :: <GtkButtonAction> = 0;
define constant $GTK-BUTTON-SELECTS :: <GtkButtonAction> = 1;
define constant $GTK-BUTTON-DRAGS :: <GtkButtonAction> = 2;
define constant $GTK-BUTTON-EXPANDS :: <GtkButtonAction> = 4;

define C-subtype <_GtkCellText> (<C-void*>) end;
define constant <GtkCellText> = <_GtkCellText>;

define C-subtype <_GtkCellPixmap> (<C-void*>) end;
define constant <GtkCellPixmap> = <_GtkCellPixmap>;

define C-subtype <_GtkCellPixText> (<C-void*>) end;
define constant <GtkCellPixText> = <_GtkCellPixText>;

define C-subtype <_GtkCellWidget> (<C-void*>) end;
define constant <GtkCellWidget> = <_GtkCellWidget>;

define C-subtype <_GtkCListDestInfo> (<C-void*>) end;
define constant <GtkCListDestInfo> = <_GtkCListDestInfo>;

define C-function gtk-clist-get-type
  result res :: <GtkType>;
  c-name: "gtk_clist_get_type";
end;

define C-function gtk-clist-new
  input parameter columns :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_clist_new";
end;

define C-function gtk-clist-new-with-titles
  input parameter columns :: <gint>;
  input parameter titles :: <gchar*<@>>;
  result res :: <GtkWidget>;
  c-name: "gtk_clist_new_with_titles";
end;

define C-function gtk-clist-set-hadjustment
  input parameter clist :: <GtkCList>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_clist_set_hadjustment";
end;

define C-function gtk-clist-set-vadjustment
  input parameter clist :: <GtkCList>;
  input parameter adjustment :: <GtkAdjustment>;
  c-name: "gtk_clist_set_vadjustment";
end;

define C-function gtk-clist-get-hadjustment
  input parameter clist :: <GtkCList>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_clist_get_hadjustment";
end;

define C-function gtk-clist-get-vadjustment
  input parameter clist :: <GtkCList>;
  result res :: <GtkAdjustment>;
  c-name: "gtk_clist_get_vadjustment";
end;

define C-function gtk-clist-set-shadow-type
  input parameter clist :: <GtkCList>;
  input parameter type :: <GtkShadowType>;
  c-name: "gtk_clist_set_shadow_type";
end;

define C-function gtk-clist-set-selection-mode
  input parameter clist :: <GtkCList>;
  input parameter mode :: <GtkSelectionMode>;
  c-name: "gtk_clist_set_selection_mode";
end;

define C-function gtk-clist-set-reorderable
  input parameter clist :: <GtkCList>;
  input parameter reorderable :: <gboolean>;
  c-name: "gtk_clist_set_reorderable";
end;

define C-function gtk-clist-set-use-drag-icons
  input parameter clist :: <GtkCList>;
  input parameter use_icons :: <gboolean>;
  c-name: "gtk_clist_set_use_drag_icons";
end;

define C-function gtk-clist-set-button-actions
  input parameter clist :: <GtkCList>;
  input parameter button :: <guint>;
  input parameter button_actions :: <guint8>;
  c-name: "gtk_clist_set_button_actions";
end;

define C-function gtk-clist-freeze
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_freeze";
end;

define C-function gtk-clist-thaw
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_thaw";
end;

define C-function gtk-clist-column-titles-show
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_column_titles_show";
end;

define C-function gtk-clist-column-titles-hide
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_column_titles_hide";
end;

define C-function gtk-clist-column-title-active
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  c-name: "gtk_clist_column_title_active";
end;

define C-function gtk-clist-column-title-passive
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  c-name: "gtk_clist_column_title_passive";
end;

define C-function gtk-clist-column-titles-active
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_column_titles_active";
end;

define C-function gtk-clist-column-titles-passive
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_column_titles_passive";
end;

define C-function gtk-clist-set-column-title
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter title :: <c-string>;
  c-name: "gtk_clist_set_column_title";
end;

define C-function gtk-clist-get-column-title
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  result res :: <c-string>;
  c-name: "gtk_clist_get_column_title";
end;

define C-function gtk-clist-set-column-widget
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter widget :: <GtkWidget>;
  c-name: "gtk_clist_set_column_widget";
end;

define C-function gtk-clist-get-column-widget
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_clist_get_column_widget";
end;

define C-function gtk-clist-set-column-justification
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter justification :: <GtkJustification>;
  c-name: "gtk_clist_set_column_justification";
end;

define C-function gtk-clist-set-column-visibility
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter visible :: <gboolean>;
  c-name: "gtk_clist_set_column_visibility";
end;

define C-function gtk-clist-set-column-resizeable
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter resizeable :: <gboolean>;
  c-name: "gtk_clist_set_column_resizeable";
end;

define C-function gtk-clist-set-column-auto-resize
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter auto_resize :: <gboolean>;
  c-name: "gtk_clist_set_column_auto_resize";
end;

define C-function gtk-clist-columns-autosize
  input parameter clist :: <GtkCList>;
  result res :: <gint>;
  c-name: "gtk_clist_columns_autosize";
end;

define C-function gtk-clist-optimal-column-width
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  result res :: <gint>;
  c-name: "gtk_clist_optimal_column_width";
end;

define C-function gtk-clist-set-column-width
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter width :: <gint>;
  c-name: "gtk_clist_set_column_width";
end;

define C-function gtk-clist-set-column-min-width
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter min_width :: <gint>;
  c-name: "gtk_clist_set_column_min_width";
end;

define C-function gtk-clist-set-column-max-width
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  input parameter max_width :: <gint>;
  c-name: "gtk_clist_set_column_max_width";
end;

define C-function gtk-clist-set-row-height
  input parameter clist :: <GtkCList>;
  input parameter height :: <guint>;
  c-name: "gtk_clist_set_row_height";
end;

define C-function gtk-clist-moveto
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter row_align :: <gfloat>;
  input parameter col_align :: <gfloat>;
  c-name: "gtk_clist_moveto";
end;

define C-function gtk-clist-row-is-visible
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  result res :: <GtkVisibility>;
  c-name: "gtk_clist_row_is_visible";
end;

define C-function gtk-clist-get-cell-type
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <GtkCellType>;
  c-name: "gtk_clist_get_cell_type";
end;

define C-function gtk-clist-set-text
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter text :: <c-string>;
  c-name: "gtk_clist_set_text";
end;

define C-function gtk-clist-get-text
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter text :: <gchar**>;
  result res :: <gint>;
  c-name: "gtk_clist_get_text";
end;

define C-function gtk-clist-set-pixmap
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_clist_set_pixmap";
end;

define C-function gtk-clist-get-pixmap
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter pixmap :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  result res :: <gint>;
  c-name: "gtk_clist_get_pixmap";
end;

define C-function gtk-clist-set-pixtext
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter text :: <c-string>;
  input parameter spacing :: <guint8>;
  input parameter pixmap :: <GdkPixmap>;
  input parameter mask :: <GdkBitmap>;
  c-name: "gtk_clist_set_pixtext";
end;

define C-function gtk-clist-get-pixtext
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter text :: <gchar**>;
  input parameter spacing :: <guint8*>;
  input parameter pixmap :: <GdkPixmap*>;
  input parameter mask :: <GdkBitmap*>;
  result res :: <gint>;
  c-name: "gtk_clist_get_pixtext";
end;

define C-function gtk-clist-set-foreground
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_clist_set_foreground";
end;

define C-function gtk-clist-set-background
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_clist_set_background";
end;

define C-function gtk-clist-set-cell-style
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter style :: <GtkStyle>;
  c-name: "gtk_clist_set_cell_style";
end;

define C-function gtk-clist-get-cell-style
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <GtkStyle>;
  c-name: "gtk_clist_get_cell_style";
end;

define C-function gtk-clist-set-row-style
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter style :: <GtkStyle>;
  c-name: "gtk_clist_set_row_style";
end;

define C-function gtk-clist-get-row-style
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  result res :: <GtkStyle>;
  c-name: "gtk_clist_get_row_style";
end;

define C-function gtk-clist-set-shift
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  input parameter vertical :: <gint>;
  input parameter horizontal :: <gint>;
  c-name: "gtk_clist_set_shift";
end;

define C-function gtk-clist-set-selectable
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter selectable :: <gboolean>;
  c-name: "gtk_clist_set_selectable";
end;

define C-function gtk-clist-get-selectable
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  result res :: <gboolean>;
  c-name: "gtk_clist_get_selectable";
end;

define C-function gtk-clist-prepend
  input parameter clist :: <GtkCList>;
  input parameter text :: <gchar*<@>>;
  result res :: <gint>;
  c-name: "gtk_clist_prepend";
end;

define C-function gtk-clist-append
  input parameter clist :: <GtkCList>;
  input parameter text :: <gchar*<@>>;
  result res :: <gint>;
  c-name: "gtk_clist_append";
end;

define C-function gtk-clist-insert
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter text :: <gchar*<@>>;
  result res :: <gint>;
  c-name: "gtk_clist_insert";
end;

define C-function gtk-clist-remove
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  c-name: "gtk_clist_remove";
end;

define C-function gtk-clist-set-row-data
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter data :: <gpointer>;
  c-name: "gtk_clist_set_row_data";
end;

define C-function gtk-clist-set-row-data-full
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_clist_set_row_data_full";
end;

define C-function gtk-clist-get-row-data
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  result res :: <gpointer>;
  c-name: "gtk_clist_get_row_data";
end;

define C-function gtk-clist-find-row-from-data
  input parameter clist :: <GtkCList>;
  input parameter data :: <gpointer>;
  result res :: <gint>;
  c-name: "gtk_clist_find_row_from_data";
end;

define C-function gtk-clist-select-row
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  c-name: "gtk_clist_select_row";
end;

define C-function gtk-clist-unselect-row
  input parameter clist :: <GtkCList>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  c-name: "gtk_clist_unselect_row";
end;

define C-function gtk-clist-undo-selection
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_undo_selection";
end;

define C-function gtk-clist-clear
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_clear";
end;

define C-function gtk-clist-get-selection-info
  input parameter clist :: <GtkCList>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter row :: <gint*>;
  input parameter column :: <gint*>;
  result res :: <gint>;
  c-name: "gtk_clist_get_selection_info";
end;

define C-function gtk-clist-select-all
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_select_all";
end;

define C-function gtk-clist-unselect-all
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_unselect_all";
end;

define C-function gtk-clist-swap-rows
  input parameter clist :: <GtkCList>;
  input parameter row1 :: <gint>;
  input parameter row2 :: <gint>;
  c-name: "gtk_clist_swap_rows";
end;

define C-function gtk-clist-row-move
  input parameter clist :: <GtkCList>;
  input parameter source_row :: <gint>;
  input parameter dest_row :: <gint>;
  c-name: "gtk_clist_row_move";
end;

define C-function gtk-clist-set-compare-func
  input parameter clist :: <GtkCList>;
  input parameter cmp_func :: <GtkCListCompareFunc>;
  c-name: "gtk_clist_set_compare_func";
end;

define C-function gtk-clist-set-sort-column
  input parameter clist :: <GtkCList>;
  input parameter column :: <gint>;
  c-name: "gtk_clist_set_sort_column";
end;

define C-function gtk-clist-set-sort-type
  input parameter clist :: <GtkCList>;
  input parameter sort_type :: <GtkSortType>;
  c-name: "gtk_clist_set_sort_type";
end;

define C-function gtk-clist-sort
  input parameter clist :: <GtkCList>;
  c-name: "gtk_clist_sort";
end;

define C-function gtk-clist-set-auto-sort
  input parameter clist :: <GtkCList>;
  input parameter auto_sort :: <gboolean>;
  c-name: "gtk_clist_set_auto_sort";
end;

define C-function _gtk-clist-create-cell-layout
  input parameter clist :: <GtkCList>;
  input parameter clist_row :: <GtkCListRow>;
  input parameter column :: <gint>;
  result res :: <PangoLayout>;
  c-name: "_gtk_clist_create_cell_layout";
end;

define C-subtype <_GtkAlignment> (<GtkBin>, <AtkImplementorIface>) end;
define constant <GtkAlignment> = <_GtkAlignment>;

define C-subtype <_GtkAlignmentClass> (<C-void*>) end;
define constant <GtkAlignmentClass> = <_GtkAlignmentClass>;

define C-subtype <_GtkAlignmentPrivate> (<C-void*>) end;
define constant <GtkAlignmentPrivate> = <_GtkAlignmentPrivate>;

define C-function gtk-alignment-get-type
  result res :: <GType>;
  c-name: "gtk_alignment_get_type";
end;

define C-function gtk-alignment-new
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  input parameter xscale :: <gfloat>;
  input parameter yscale :: <gfloat>;
  result res :: <GtkWidget>;
  c-name: "gtk_alignment_new";
end;

define C-function gtk-alignment-set
  input parameter alignment :: <GtkAlignment>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  input parameter xscale :: <gfloat>;
  input parameter yscale :: <gfloat>;
  c-name: "gtk_alignment_set";
end;

define C-function gtk-alignment-set-padding
  input parameter alignment :: <GtkAlignment>;
  input parameter padding_top :: <guint>;
  input parameter padding_bottom :: <guint>;
  input parameter padding_left :: <guint>;
  input parameter padding_right :: <guint>;
  c-name: "gtk_alignment_set_padding";
end;

define C-function gtk-alignment-get-padding
  input parameter alignment :: <GtkAlignment>;
  input parameter padding_top :: <guint*>;
  input parameter padding_bottom :: <guint*>;
  input parameter padding_left :: <guint*>;
  input parameter padding_right :: <guint*>;
  c-name: "gtk_alignment_get_padding";
end;

define C-subtype <_GtkComboBoxPrivate> (<C-void*>) end;
define constant <GtkComboBoxPrivate> = <_GtkComboBoxPrivate>;

define C-subtype <_GtkComboBox> (<C-void*>) end;
define constant <GtkComboBox> = <_GtkComboBox>;

define C-subtype <_GtkComboBoxEntryPrivate> (<C-void*>) end;
define constant <GtkComboBoxEntryPrivate> = <_GtkComboBoxEntryPrivate>;

define C-subtype <_GtkComboBoxEntry> (<C-void*>) end;
define constant <GtkComboBoxEntry> = <_GtkComboBoxEntry>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6179>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6180>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6181>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6182>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6183>"*/
define C-subtype <_GtkComboBoxClass> (<C-void*>) end;
define constant <GtkComboBoxClass> = <_GtkComboBoxClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6217>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6218>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6219>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-6220>"*/
define C-subtype <_GtkComboBoxEntryClass> (<C-void*>) end;
define constant <GtkComboBoxEntryClass> = <_GtkComboBoxEntryClass>;

define C-function gtk-combo-box-entry-get-type
  result res :: <GType>;
  c-name: "gtk_combo_box_entry_get_type";
end;

define C-function gtk-combo-box-entry-new
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_entry_new";
end;

define C-function gtk-combo-box-entry-new-with-model
  input parameter model :: <GtkTreeModel>;
  input parameter text_column :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_entry_new_with_model";
end;

define C-function gtk-combo-box-entry-set-text-column
  input parameter entry_box :: <GtkComboBoxEntry>;
  input parameter text_column :: <gint>;
  c-name: "gtk_combo_box_entry_set_text_column";
end;

define C-function gtk-combo-box-entry-get-text-column
  input parameter entry_box :: <GtkComboBoxEntry>;
  result res :: <gint>;
  c-name: "gtk_combo_box_entry_get_text_column";
end;

define C-function gtk-combo-box-entry-new-text
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_entry_new_text";
end;

define C-function gtk-combo-box-get-type
  result res :: <GType>;
  c-name: "gtk_combo_box_get_type";
end;

define C-function gtk-combo-box-new
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_new";
end;

define C-function gtk-combo-box-new-with-model
  input parameter model :: <GtkTreeModel>;
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_new_with_model";
end;

define C-function gtk-combo-box-get-wrap-width
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gint>;
  c-name: "gtk_combo_box_get_wrap_width";
end;

define C-function gtk-combo-box-set-wrap-width
  input parameter combo_box :: <GtkComboBox>;
  input parameter width :: <gint>;
  c-name: "gtk_combo_box_set_wrap_width";
end;

define C-function gtk-combo-box-get-row-span-column
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gint>;
  c-name: "gtk_combo_box_get_row_span_column";
end;

define C-function gtk-combo-box-set-row-span-column
  input parameter combo_box :: <GtkComboBox>;
  input parameter row_span :: <gint>;
  c-name: "gtk_combo_box_set_row_span_column";
end;

define C-function gtk-combo-box-get-column-span-column
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gint>;
  c-name: "gtk_combo_box_get_column_span_column";
end;

define C-function gtk-combo-box-set-column-span-column
  input parameter combo_box :: <GtkComboBox>;
  input parameter column_span :: <gint>;
  c-name: "gtk_combo_box_set_column_span_column";
end;

define C-function gtk-combo-box-get-add-tearoffs
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gboolean>;
  c-name: "gtk_combo_box_get_add_tearoffs";
end;

define C-function gtk-combo-box-set-add-tearoffs
  input parameter combo_box :: <GtkComboBox>;
  input parameter add_tearoffs :: <gboolean>;
  c-name: "gtk_combo_box_set_add_tearoffs";
end;

define C-function gtk-combo-box-get-title
  input parameter combo_box :: <GtkComboBox>;
  result res :: <c-string>;
  c-name: "gtk_combo_box_get_title";
end;

define C-function gtk-combo-box-set-title
  input parameter combo_box :: <GtkComboBox>;
  input parameter title :: <c-string>;
  c-name: "gtk_combo_box_set_title";
end;

define C-function gtk-combo-box-get-focus-on-click
  input parameter combo :: <GtkComboBox>;
  result res :: <gboolean>;
  c-name: "gtk_combo_box_get_focus_on_click";
end;

define C-function gtk-combo-box-set-focus-on-click
  input parameter combo :: <GtkComboBox>;
  input parameter focus_on_click :: <gboolean>;
  c-name: "gtk_combo_box_set_focus_on_click";
end;

define C-function gtk-combo-box-get-active
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gint>;
  c-name: "gtk_combo_box_get_active";
end;

define C-function gtk-combo-box-set-active
  input parameter combo_box :: <GtkComboBox>;
  input parameter index_ :: <gint>;
  c-name: "gtk_combo_box_set_active";
end;

define C-function gtk-combo-box-get-active-iter
  input parameter combo_box :: <GtkComboBox>;
  input parameter iter :: <GtkTreeIter>;
  result res :: <gboolean>;
  c-name: "gtk_combo_box_get_active_iter";
end;

define C-function gtk-combo-box-set-active-iter
  input parameter combo_box :: <GtkComboBox>;
  input parameter iter :: <GtkTreeIter>;
  c-name: "gtk_combo_box_set_active_iter";
end;

define C-function gtk-combo-box-set-model
  input parameter combo_box :: <GtkComboBox>;
  input parameter model :: <GtkTreeModel>;
  c-name: "gtk_combo_box_set_model";
end;

define C-function gtk-combo-box-get-model
  input parameter combo_box :: <GtkComboBox>;
  result res :: <GtkTreeModel>;
  c-name: "gtk_combo_box_get_model";
end;

define C-function gtk-combo-box-get-row-separator-func
  input parameter combo_box :: <GtkComboBox>;
  result res :: <GtkTreeViewRowSeparatorFunc>;
  c-name: "gtk_combo_box_get_row_separator_func";
end;

define C-function gtk-combo-box-set-row-separator-func
  input parameter combo_box :: <GtkComboBox>;
  input parameter func :: <GtkTreeViewRowSeparatorFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GtkDestroyNotify>;
  c-name: "gtk_combo_box_set_row_separator_func";
end;

define C-function gtk-combo-box-new-text
  result res :: <GtkWidget>;
  c-name: "gtk_combo_box_new_text";
end;

define C-function gtk-combo-box-append-text
  input parameter combo_box :: <GtkComboBox>;
  input parameter text :: <c-string>;
  c-name: "gtk_combo_box_append_text";
end;

define C-function gtk-combo-box-insert-text
  input parameter combo_box :: <GtkComboBox>;
  input parameter position :: <gint>;
  input parameter text :: <c-string>;
  c-name: "gtk_combo_box_insert_text";
end;

define C-function gtk-combo-box-prepend-text
  input parameter combo_box :: <GtkComboBox>;
  input parameter text :: <c-string>;
  c-name: "gtk_combo_box_prepend_text";
end;

define C-function gtk-combo-box-remove-text
  input parameter combo_box :: <GtkComboBox>;
  input parameter position :: <gint>;
  c-name: "gtk_combo_box_remove_text";
end;

define C-function gtk-combo-box-get-active-text
  input parameter combo_box :: <GtkComboBox>;
  result res :: <c-string>;
  c-name: "gtk_combo_box_get_active_text";
end;

define C-function gtk-combo-box-popup
  input parameter combo_box :: <GtkComboBox>;
  c-name: "gtk_combo_box_popup";
end;

define C-function gtk-combo-box-popdown
  input parameter combo_box :: <GtkComboBox>;
  c-name: "gtk_combo_box_popdown";
end;

define C-function gtk-combo-box-get-popup-accessible
  input parameter combo_box :: <GtkComboBox>;
  result res :: <AtkObject>;
  c-name: "gtk_combo_box_get_popup_accessible";
end;

define C-function _gtk-combo-box-editing-canceled
  input parameter combo_box :: <GtkComboBox>;
  result res :: <gboolean>;
  c-name: "_gtk_combo_box_editing_canceled";
end;

define C-subtype <_GtkCombo> (<GtkHBox>, <AtkImplementorIface>) end;
define constant <GtkCombo> = <_GtkCombo>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5820>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5821>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5822>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5823>"*/
define C-subtype <_GtkComboClass> (<C-void*>) end;
define constant <GtkComboClass> = <_GtkComboClass>;

define C-function gtk-combo-get-type
  result res :: <GType>;
  c-name: "gtk_combo_get_type";
end;

define C-function gtk-combo-new
  result res :: <GtkWidget>;
  c-name: "gtk_combo_new";
end;

define C-function gtk-combo-set-value-in-list
  input parameter combo :: <GtkCombo>;
  input parameter val :: <gboolean>;
  input parameter ok_if_empty :: <gboolean>;
  c-name: "gtk_combo_set_value_in_list";
end;

define C-function gtk-combo-set-use-arrows
  input parameter combo :: <GtkCombo>;
  input parameter val :: <gboolean>;
  c-name: "gtk_combo_set_use_arrows";
end;

define C-function gtk-combo-set-use-arrows-always
  input parameter combo :: <GtkCombo>;
  input parameter val :: <gboolean>;
  c-name: "gtk_combo_set_use_arrows_always";
end;

define C-function gtk-combo-set-case-sensitive
  input parameter combo :: <GtkCombo>;
  input parameter val :: <gboolean>;
  c-name: "gtk_combo_set_case_sensitive";
end;

define C-function gtk-combo-set-item-string
  input parameter combo :: <GtkCombo>;
  input parameter item :: <GtkItem>;
  input parameter item_value :: <c-string>;
  c-name: "gtk_combo_set_item_string";
end;

define C-function gtk-combo-set-popdown-strings
  input parameter combo :: <GtkCombo>;
  input parameter strings :: <GList>;
  c-name: "gtk_combo_set_popdown_strings";
end;

define C-function gtk-combo-disable-activate
  input parameter combo :: <GtkCombo>;
  c-name: "gtk_combo_disable_activate";
end;

define C-subtype <_GtkColorSelectionDialog> (<GtkDialog>, <AtkImplementorIface>) end;
define constant <GtkColorSelectionDialog> = <_GtkColorSelectionDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5807>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5808>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5809>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5810>"*/
define C-subtype <_GtkColorSelectionDialogClass> (<C-void*>) end;
define constant <GtkColorSelectionDialogClass> = <_GtkColorSelectionDialogClass>;

define C-function gtk-color-selection-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_color_selection_dialog_get_type";
end;

define C-function gtk-color-selection-dialog-new
  input parameter title :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_color_selection_dialog_new";
end;

define C-subtype <_GtkColorSelection> (<GtkVBox>, <AtkImplementorIface>) end;
define constant <GtkColorSelection> = <_GtkColorSelection>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5780>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5781>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5782>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5783>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5784>"*/
define C-subtype <_GtkColorSelectionClass> (<C-void*>) end;
define constant <GtkColorSelectionClass> = <_GtkColorSelectionClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5778>"*/
define constant <GtkColorSelectionChangePaletteFunc> = <anonymous-5778>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5779>"*/
define constant <GtkColorSelectionChangePaletteWithScreenFunc> = <anonymous-5779>;

define C-function gtk-color-selection-get-type
  result res :: <GType>;
  c-name: "gtk_color_selection_get_type";
end;

define C-function gtk-color-selection-new
  result res :: <GtkWidget>;
  c-name: "gtk_color_selection_new";
end;

define C-function gtk-color-selection-get-has-opacity-control
  input parameter colorsel :: <GtkColorSelection>;
  result res :: <gboolean>;
  c-name: "gtk_color_selection_get_has_opacity_control";
end;

define C-function gtk-color-selection-set-has-opacity-control
  input parameter colorsel :: <GtkColorSelection>;
  input parameter has_opacity :: <gboolean>;
  c-name: "gtk_color_selection_set_has_opacity_control";
end;

define C-function gtk-color-selection-get-has-palette
  input parameter colorsel :: <GtkColorSelection>;
  result res :: <gboolean>;
  c-name: "gtk_color_selection_get_has_palette";
end;

define C-function gtk-color-selection-set-has-palette
  input parameter colorsel :: <GtkColorSelection>;
  input parameter has_palette :: <gboolean>;
  c-name: "gtk_color_selection_set_has_palette";
end;

define C-function gtk-color-selection-set-current-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_selection_set_current_color";
end;

define C-function gtk-color-selection-set-current-alpha
  input parameter colorsel :: <GtkColorSelection>;
  input parameter alpha :: <guint16>;
  c-name: "gtk_color_selection_set_current_alpha";
end;

define C-function gtk-color-selection-get-current-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_selection_get_current_color";
end;

define C-function gtk-color-selection-get-current-alpha
  input parameter colorsel :: <GtkColorSelection>;
  result res :: <guint16>;
  c-name: "gtk_color_selection_get_current_alpha";
end;

define C-function gtk-color-selection-set-previous-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_selection_set_previous_color";
end;

define C-function gtk-color-selection-set-previous-alpha
  input parameter colorsel :: <GtkColorSelection>;
  input parameter alpha :: <guint16>;
  c-name: "gtk_color_selection_set_previous_alpha";
end;

define C-function gtk-color-selection-get-previous-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_selection_get_previous_color";
end;

define C-function gtk-color-selection-get-previous-alpha
  input parameter colorsel :: <GtkColorSelection>;
  result res :: <guint16>;
  c-name: "gtk_color_selection_get_previous_alpha";
end;

define C-function gtk-color-selection-is-adjusting
  input parameter colorsel :: <GtkColorSelection>;
  result res :: <gboolean>;
  c-name: "gtk_color_selection_is_adjusting";
end;

define C-pointer-type <GdkColor*> => <GdkColor>;
define C-function gtk-color-selection-palette-from-string
  input parameter str :: <c-string>;
  input parameter colors :: <GdkColor*>;
  input parameter n_colors :: <gint*>;
  result res :: <gboolean>;
  c-name: "gtk_color_selection_palette_from_string";
end;

define C-function gtk-color-selection-palette-to-string
  input parameter colors :: <GdkColor>;
  input parameter n_colors :: <gint>;
  result res :: <c-string>;
  c-name: "gtk_color_selection_palette_to_string";
end;

define C-function gtk-color-selection-set-change-palette-hook
  input parameter func :: <GtkColorSelectionChangePaletteFunc>;
  result res :: <GtkColorSelectionChangePaletteFunc>;
  c-name: "gtk_color_selection_set_change_palette_hook";
end;

define C-function gtk-color-selection-set-change-palette-with-screen-hook
  input parameter func :: <GtkColorSelectionChangePaletteWithScreenFunc>;
  result res :: <GtkColorSelectionChangePaletteWithScreenFunc>;
  c-name: "gtk_color_selection_set_change_palette_with_screen_hook";
end;

define C-function gtk-color-selection-set-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <gdouble*>;
  c-name: "gtk_color_selection_set_color";
end;

define C-function gtk-color-selection-get-color
  input parameter colorsel :: <GtkColorSelection>;
  input parameter color :: <gdouble*>;
  c-name: "gtk_color_selection_get_color";
end;

define C-function gtk-color-selection-set-update-policy
  input parameter colorsel :: <GtkColorSelection>;
  input parameter policy :: <GtkUpdateType>;
  c-name: "gtk_color_selection_set_update_policy";
end;

define C-subtype <_GtkColorButtonPrivate> (<C-void*>) end;
define constant <GtkColorButtonPrivate> = <_GtkColorButtonPrivate>;

define C-subtype <_GtkColorButton> (<C-void*>) end;
define constant <GtkColorButton> = <_GtkColorButton>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5760>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5761>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5762>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5763>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5764>"*/
define C-subtype <_GtkColorButtonClass> (<C-void*>) end;
define constant <GtkColorButtonClass> = <_GtkColorButtonClass>;

define C-function gtk-color-button-get-type
  result res :: <GType>;
  c-name: "gtk_color_button_get_type";
end;

define C-function gtk-color-button-new
  result res :: <GtkWidget>;
  c-name: "gtk_color_button_new";
end;

define C-function gtk-color-button-new-with-color
  input parameter color :: <GdkColor>;
  result res :: <GtkWidget>;
  c-name: "gtk_color_button_new_with_color";
end;

define C-function gtk-color-button-set-color
  input parameter color_button :: <GtkColorButton>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_button_set_color";
end;

define C-function gtk-color-button-set-alpha
  input parameter color_button :: <GtkColorButton>;
  input parameter alpha :: <guint16>;
  c-name: "gtk_color_button_set_alpha";
end;

define C-function gtk-color-button-get-color
  input parameter color_button :: <GtkColorButton>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_color_button_get_color";
end;

define C-function gtk-color-button-get-alpha
  input parameter color_button :: <GtkColorButton>;
  result res :: <guint16>;
  c-name: "gtk_color_button_get_alpha";
end;

define C-function gtk-color-button-set-use-alpha
  input parameter color_button :: <GtkColorButton>;
  input parameter use_alpha :: <gboolean>;
  c-name: "gtk_color_button_set_use_alpha";
end;

define C-function gtk-color-button-get-use-alpha
  input parameter color_button :: <GtkColorButton>;
  result res :: <gboolean>;
  c-name: "gtk_color_button_get_use_alpha";
end;

define C-function gtk-color-button-set-title
  input parameter color_button :: <GtkColorButton>;
  input parameter title :: <c-string>;
  c-name: "gtk_color_button_set_title";
end;

define C-function gtk-color-button-get-title
  input parameter color_button :: <GtkColorButton>;
  result res :: <c-string>;
  c-name: "gtk_color_button_get_title";
end;

define C-subtype <_GtkCellViewPrivate> (<C-void*>) end;
define constant <GtkCellViewPrivate> = <_GtkCellViewPrivate>;

define C-subtype <_GtkCellView> (<C-void*>) end;
define constant <GtkCellView> = <_GtkCellView>;

define C-subtype <_GtkCellViewClass> (<C-void*>) end;
define constant <GtkCellViewClass> = <_GtkCellViewClass>;

define C-function gtk-cell-view-get-type
  result res :: <GType>;
  c-name: "gtk_cell_view_get_type";
end;

define C-function gtk-cell-view-new
  result res :: <GtkWidget>;
  c-name: "gtk_cell_view_new";
end;

define C-function gtk-cell-view-new-with-text
  input parameter text :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_cell_view_new_with_text";
end;

define C-function gtk-cell-view-new-with-markup
  input parameter markup :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_cell_view_new_with_markup";
end;

define C-function gtk-cell-view-new-with-pixbuf
  input parameter pixbuf :: <GdkPixbuf>;
  result res :: <GtkWidget>;
  c-name: "gtk_cell_view_new_with_pixbuf";
end;

define C-function gtk-cell-view-set-model
  input parameter cell_view :: <GtkCellView>;
  input parameter model :: <GtkTreeModel>;
  c-name: "gtk_cell_view_set_model";
end;

define C-function gtk-cell-view-set-displayed-row
  input parameter cell_view :: <GtkCellView>;
  input parameter path :: <GtkTreePath>;
  c-name: "gtk_cell_view_set_displayed_row";
end;

define C-function gtk-cell-view-get-displayed-row
  input parameter cell_view :: <GtkCellView>;
  result res :: <GtkTreePath>;
  c-name: "gtk_cell_view_get_displayed_row";
end;

define C-function gtk-cell-view-get-size-of-row
  input parameter cell_view :: <GtkCellView>;
  input parameter path :: <GtkTreePath>;
  input parameter requisition :: <GtkRequisition>;
  result res :: <gboolean>;
  c-name: "gtk_cell_view_get_size_of_row";
end;

define C-function gtk-cell-view-set-background-color
  input parameter cell_view :: <GtkCellView>;
  input parameter color :: <GdkColor>;
  c-name: "gtk_cell_view_set_background_color";
end;

define C-function gtk-cell-view-get-cell-renderers
  input parameter cell_view :: <GtkCellView>;
  result res :: <GList>;
  c-name: "gtk_cell_view_get_cell_renderers";
end;

define C-subtype <_GtkCellRendererToggle> (<GtkCellRenderer>) end;
define constant <GtkCellRendererToggle> = <_GtkCellRendererToggle>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5242>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5243>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5244>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5245>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5246>"*/
define C-subtype <_GtkCellRendererToggleClass> (<C-void*>) end;
define constant <GtkCellRendererToggleClass> = <_GtkCellRendererToggleClass>;

define C-function gtk-cell-renderer-toggle-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_toggle_get_type";
end;

define C-function gtk-cell-renderer-toggle-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_toggle_new";
end;

define C-function gtk-cell-renderer-toggle-get-radio
  input parameter toggle :: <GtkCellRendererToggle>;
  result res :: <gboolean>;
  c-name: "gtk_cell_renderer_toggle_get_radio";
end;

define C-function gtk-cell-renderer-toggle-set-radio
  input parameter toggle :: <GtkCellRendererToggle>;
  input parameter radio :: <gboolean>;
  c-name: "gtk_cell_renderer_toggle_set_radio";
end;

define C-function gtk-cell-renderer-toggle-get-active
  input parameter toggle :: <GtkCellRendererToggle>;
  result res :: <gboolean>;
  c-name: "gtk_cell_renderer_toggle_get_active";
end;

define C-function gtk-cell-renderer-toggle-set-active
  input parameter toggle :: <GtkCellRendererToggle>;
  input parameter setting :: <gboolean>;
  c-name: "gtk_cell_renderer_toggle_set_active";
end;

define C-subtype <_GtkCellRendererText> (<GtkCellRenderer>) end;
define constant <GtkCellRendererText> = <_GtkCellRendererText>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5205>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5206>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5207>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5208>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5209>"*/
define C-subtype <_GtkCellRendererTextClass> (<C-void*>) end;
define constant <GtkCellRendererTextClass> = <_GtkCellRendererTextClass>;

define C-function gtk-cell-renderer-text-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_text_get_type";
end;

define C-function gtk-cell-renderer-text-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_text_new";
end;

define C-function gtk-cell-renderer-text-set-fixed-height-from-font
  input parameter renderer :: <GtkCellRendererText>;
  input parameter number_of_rows :: <gint>;
  c-name: "gtk_cell_renderer_text_set_fixed_height_from_font";
end;

define C-subtype <_GtkCellRendererSpin> (<C-void*>) end;
define constant <GtkCellRendererSpin> = <_GtkCellRendererSpin>;

define C-subtype <_GtkCellRendererSpinClass> (<C-void*>) end;
define constant <GtkCellRendererSpinClass> = <_GtkCellRendererSpinClass>;

define C-subtype <_GtkCellRendererSpinPrivate> (<C-void*>) end;
define constant <GtkCellRendererSpinPrivate> = <_GtkCellRendererSpinPrivate>;

define C-function gtk-cell-renderer-spin-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_spin_get_type";
end;

define C-function gtk-cell-renderer-spin-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_spin_new";
end;

define C-subtype <_GtkCellRendererProgressPrivate> (<C-void*>) end;
define constant <GtkCellRendererProgressPrivate> = <_GtkCellRendererProgressPrivate>;

define C-subtype <_GtkCellRendererProgress> (<C-void*>) end;
define constant <GtkCellRendererProgress> = <_GtkCellRendererProgress>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5231>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5232>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5233>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5234>"*/
define C-subtype <_GtkCellRendererProgressClass> (<C-void*>) end;
define constant <GtkCellRendererProgressClass> = <_GtkCellRendererProgressClass>;

define C-function gtk-cell-renderer-progress-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_progress_get_type";
end;

define C-function gtk-cell-renderer-progress-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_progress_new";
end;

define C-subtype <_GtkCellRendererPixbuf> (<GtkCellRenderer>) end;
define constant <GtkCellRendererPixbuf> = <_GtkCellRendererPixbuf>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5225>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5226>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5227>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5228>"*/
define C-subtype <_GtkCellRendererPixbufClass> (<C-void*>) end;
define constant <GtkCellRendererPixbufClass> = <_GtkCellRendererPixbufClass>;

define C-function gtk-cell-renderer-pixbuf-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_pixbuf_get_type";
end;

define C-function gtk-cell-renderer-pixbuf-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_pixbuf_new";
end;

define C-subtype <_GtkCellRendererCombo> (<C-void*>) end;
define constant <GtkCellRendererCombo> = <_GtkCellRendererCombo>;

define C-subtype <_GtkCellRendererComboClass> (<C-void*>) end;
define constant <GtkCellRendererComboClass> = <_GtkCellRendererComboClass>;

define C-function gtk-cell-renderer-combo-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_combo_get_type";
end;

define C-function gtk-cell-renderer-combo-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_combo_new";
end;

define constant <GtkCellRendererAccelMode> = limited(<integer>, min: 0, max: 1);
define constant $GTK-CELL-RENDERER-ACCEL-MODE-GTK :: <GtkCellRendererAccelMode> = 0;
define constant $GTK-CELL-RENDERER-ACCEL-MODE-OTHER :: <GtkCellRendererAccelMode> = 1;

define C-subtype <_GtkCellRendererAccel> (<C-void*>) end;
define constant <GtkCellRendererAccel> = <_GtkCellRendererAccel>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5214>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5215>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5216>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5217>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5218>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5219>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5220>"*/
define C-subtype <_GtkCellRendererAccelClass> (<C-void*>) end;
define constant <GtkCellRendererAccelClass> = <_GtkCellRendererAccelClass>;

define C-function gtk-cell-renderer-accel-get-type
  result res :: <GType>;
  c-name: "gtk_cell_renderer_accel_get_type";
end;

define C-function gtk-cell-renderer-accel-new
  result res :: <GtkCellRenderer>;
  c-name: "gtk_cell_renderer_accel_new";
end;

define C-subtype <_GtkCellLayout> (<C-void*>) end;
define constant <GtkCellLayout> = <_GtkCellLayout>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5179>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5180>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5181>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5182>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5178>"*/
define constant <GtkCellLayoutDataFunc> = <anonymous-5178>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5183>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5184>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-5185>"*/
define C-subtype <_GtkCellLayoutIface> (<C-void*>) end;
define constant <GtkCellLayoutIface> = <_GtkCellLayoutIface>;

define C-function gtk-cell-layout-get-type
  result res :: <GType>;
  c-name: "gtk_cell_layout_get_type";
end;

define C-function gtk-cell-layout-pack-start
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_cell_layout_pack_start";
end;

define C-function gtk-cell-layout-pack-end
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter expand :: <gboolean>;
  c-name: "gtk_cell_layout_pack_end";
end;

define C-function gtk-cell-layout-clear
  input parameter cell_layout :: <GtkCellLayout>;
  c-name: "gtk_cell_layout_clear";
end;

define C-function gtk-cell-layout-set-attributes
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  c-name: "gtk_cell_layout_set_attributes";
end;

define C-function gtk-cell-layout-add-attribute
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter attribute :: <c-string>;
  input parameter column :: <gint>;
  c-name: "gtk_cell_layout_add_attribute";
end;

define C-function gtk-cell-layout-set-cell-data-func
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter func :: <GtkCellLayoutDataFunc>;
  input parameter func_data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_cell_layout_set_cell_data_func";
end;

define C-function gtk-cell-layout-clear-attributes
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  c-name: "gtk_cell_layout_clear_attributes";
end;

define C-function gtk-cell-layout-reorder
  input parameter cell_layout :: <GtkCellLayout>;
  input parameter cell :: <GtkCellRenderer>;
  input parameter position :: <gint>;
  c-name: "gtk_cell_layout_reorder";
end;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@7>>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@7><@6>>"*/
 /* Ignoring declaration for {instance of <vector-declaration>} "<gint<@31>>"*/
define constant <GtkCalendarDisplayOptions> = limited(<integer>, min: 1, max: 16);
define constant $GTK-CALENDAR-SHOW-HEADING :: <GtkCalendarDisplayOptions> = 1;
define constant $GTK-CALENDAR-SHOW-DAY-NAMES :: <GtkCalendarDisplayOptions> = 2;
define constant $GTK-CALENDAR-NO-MONTH-CHANGE :: <GtkCalendarDisplayOptions> = 4;
define constant $GTK-CALENDAR-SHOW-WEEK-NUMBERS :: <GtkCalendarDisplayOptions> = 8;
define constant $GTK-CALENDAR-WEEK-START-MONDAY :: <GtkCalendarDisplayOptions> = 16;

 /* Ignoring declaration for {instance of <vector-declaration>} "<GdkColor<@31>>"*/
define C-subtype <_GtkCalendarPrivate> (<C-void*>) end;
define constant <GtkCalendarPrivate> = <_GtkCalendarPrivate>;

 /* Ignoring declaration for {instance of <vector-declaration>} "<gchar<@32>>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4959>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4960>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4961>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4962>"*/
define C-subtype <_GtkCalendar> (<GtkWidget>, <AtkImplementorIface>) end;
define constant <GtkCalendar> = <_GtkCalendar>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4963>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4964>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4965>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4966>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4967>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4968>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4969>"*/
define C-subtype <_GtkCalendarClass> (<C-void*>) end;
define constant <GtkCalendarClass> = <_GtkCalendarClass>;

define C-function gtk-calendar-get-type
  result res :: <GType>;
  c-name: "gtk_calendar_get_type";
end;

define C-function gtk-calendar-new
  result res :: <GtkWidget>;
  c-name: "gtk_calendar_new";
end;

define C-function gtk-calendar-select-month
  input parameter calendar :: <GtkCalendar>;
  input parameter month :: <guint>;
  input parameter year :: <guint>;
  result res :: <gboolean>;
  c-name: "gtk_calendar_select_month";
end;

define C-function gtk-calendar-select-day
  input parameter calendar :: <GtkCalendar>;
  input parameter day :: <guint>;
  c-name: "gtk_calendar_select_day";
end;

define C-function gtk-calendar-mark-day
  input parameter calendar :: <GtkCalendar>;
  input parameter day :: <guint>;
  result res :: <gboolean>;
  c-name: "gtk_calendar_mark_day";
end;

define C-function gtk-calendar-unmark-day
  input parameter calendar :: <GtkCalendar>;
  input parameter day :: <guint>;
  result res :: <gboolean>;
  c-name: "gtk_calendar_unmark_day";
end;

define C-function gtk-calendar-clear-marks
  input parameter calendar :: <GtkCalendar>;
  c-name: "gtk_calendar_clear_marks";
end;

define C-function gtk-calendar-set-display-options
  input parameter calendar :: <GtkCalendar>;
  input parameter flags :: <GtkCalendarDisplayOptions>;
  c-name: "gtk_calendar_set_display_options";
end;

define C-function gtk-calendar-get-display-options
  input parameter calendar :: <GtkCalendar>;
  result res :: <GtkCalendarDisplayOptions>;
  c-name: "gtk_calendar_get_display_options";
end;

define C-function gtk-calendar-display-options
  input parameter calendar :: <GtkCalendar>;
  input parameter flags :: <GtkCalendarDisplayOptions>;
  c-name: "gtk_calendar_display_options";
end;

define C-function gtk-calendar-get-date
  input parameter calendar :: <GtkCalendar>;
  input parameter year :: <guint*>;
  input parameter month :: <guint*>;
  input parameter day :: <guint*>;
  c-name: "gtk_calendar_get_date";
end;

define C-function gtk-calendar-freeze
  input parameter calendar :: <GtkCalendar>;
  c-name: "gtk_calendar_freeze";
end;

define C-function gtk-calendar-thaw
  input parameter calendar :: <GtkCalendar>;
  c-name: "gtk_calendar_thaw";
end;

define constant <GtkBindingSet> = <_GtkBindingSet>;

 /* Ignoring declaration for {instance of <union-declaration>} "<anonymous-4822>"*/
define C-subtype <_GtkBindingArg> (<C-void*>) end;
define constant <GtkBindingArg> = <_GtkBindingArg>;

define C-subtype <_GtkBindingSignal> (<C-void*>) end;
define constant <GtkBindingSignal> = <_GtkBindingSignal>;

define C-subtype <_GtkBindingEntry> (<C-void*>) end;
define constant <GtkBindingEntry> = <_GtkBindingEntry>;

define C-subtype <_GtkBindingSet> (<C-void*>) end;
define C-function gtk-binding-set-new
  input parameter set_name :: <c-string>;
  result res :: <GtkBindingSet>;
  c-name: "gtk_binding_set_new";
end;

define C-function gtk-binding-set-by-class
  input parameter object_class :: <gpointer>;
  result res :: <GtkBindingSet>;
  c-name: "gtk_binding_set_by_class";
end;

define C-function gtk-binding-set-find
  input parameter set_name :: <c-string>;
  result res :: <GtkBindingSet>;
  c-name: "gtk_binding_set_find";
end;

define C-function gtk-bindings-activate
  input parameter object :: <GtkObject>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  result res :: <gboolean>;
  c-name: "gtk_bindings_activate";
end;

define C-function gtk-bindings-activate-event
  input parameter object :: <GtkObject>;
  input parameter event :: <GdkEventKey>;
  result res :: <gboolean>;
  c-name: "gtk_bindings_activate_event";
end;

define C-function gtk-binding-set-activate
  input parameter binding_set :: <GtkBindingSet>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  input parameter object :: <GtkObject>;
  result res :: <gboolean>;
  c-name: "gtk_binding_set_activate";
end;

define C-function gtk-binding-entry-clear
  input parameter binding_set :: <GtkBindingSet>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  c-name: "gtk_binding_entry_clear";
end;

define C-function gtk-binding-entry-add-signal
  input parameter binding_set :: <GtkBindingSet>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  input parameter signal_name :: <c-string>;
  input parameter n_args :: <guint>;
  c-name: "gtk_binding_entry_add_signal";
end;

define C-function gtk-binding-set-add-path
  input parameter binding_set :: <GtkBindingSet>;
  input parameter path_type :: <GtkPathType>;
  input parameter path_pattern :: <c-string>;
  input parameter priority :: <GtkPathPriorityType>;
  c-name: "gtk_binding_set_add_path";
end;

define C-function gtk-binding-entry-remove
  input parameter binding_set :: <GtkBindingSet>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  c-name: "gtk_binding_entry_remove";
end;

define C-function gtk-binding-entry-add-signall
  input parameter binding_set :: <GtkBindingSet>;
  input parameter keyval :: <guint>;
  input parameter modifiers :: <GdkModifierType>;
  input parameter signal_name :: <c-string>;
  input parameter binding_args :: <GSList>;
  c-name: "gtk_binding_entry_add_signall";
end;

define C-function gtk-binding-parse-binding
  input parameter scanner :: <GScanner>;
  result res :: <guint>;
  c-name: "gtk_binding_parse_binding";
end;

define C-function _gtk-binding-reset-parsed
  c-name: "_gtk_binding_reset_parsed";
end;

define C-function _gtk-binding-signal-new
  input parameter signal_name :: <c-string>;
  input parameter itype :: <GType>;
  input parameter signal_flags :: <GSignalFlags>;
  input parameter handler :: <GCallback>;
  input parameter accumulator :: <GSignalAccumulator>;
  input parameter accu_data :: <gpointer>;
  input parameter c_marshaller :: <GSignalCMarshaller>;
  input parameter return_type :: <GType>;
  input parameter n_params :: <guint>;
  result res :: <guint>;
  c-name: "_gtk_binding_signal_new";
end;

define constant gtk-binding-entry-add = gtk-binding-entry-clear;

define constant <GtkAssistantPageType> = limited(<integer>, min: 0, max: 4);
define constant $GTK-ASSISTANT-PAGE-CONTENT :: <GtkAssistantPageType> = 0;
define constant $GTK-ASSISTANT-PAGE-INTRO :: <GtkAssistantPageType> = 1;
define constant $GTK-ASSISTANT-PAGE-CONFIRM :: <GtkAssistantPageType> = 2;
define constant $GTK-ASSISTANT-PAGE-SUMMARY :: <GtkAssistantPageType> = 3;
define constant $GTK-ASSISTANT-PAGE-PROGRESS :: <GtkAssistantPageType> = 4;

define C-subtype <_GtkAssistantPrivate> (<C-void*>) end;
define constant <GtkAssistantPrivate> = <_GtkAssistantPrivate>;

define C-subtype <_GtkAssistant> (<C-void*>) end;
define constant <GtkAssistant> = <_GtkAssistant>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4759>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4760>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4761>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4762>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4763>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4764>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4765>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4766>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4767>"*/
define C-subtype <_GtkAssistantClass> (<C-void*>) end;
define constant <GtkAssistantClass> = <_GtkAssistantClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4768>"*/
define constant <GtkAssistantPageFunc> = <anonymous-4768>;

define C-function gtk-assistant-get-type
  result res :: <GType>;
  c-name: "gtk_assistant_get_type";
end;

define C-function gtk-assistant-new
  result res :: <GtkWidget>;
  c-name: "gtk_assistant_new";
end;

define C-function gtk-assistant-get-current-page
  input parameter assistant :: <GtkAssistant>;
  result res :: <gint>;
  c-name: "gtk_assistant_get_current_page";
end;

define C-function gtk-assistant-set-current-page
  input parameter assistant :: <GtkAssistant>;
  input parameter page_num :: <gint>;
  c-name: "gtk_assistant_set_current_page";
end;

define C-function gtk-assistant-get-n-pages
  input parameter assistant :: <GtkAssistant>;
  result res :: <gint>;
  c-name: "gtk_assistant_get_n_pages";
end;

define C-function gtk-assistant-get-nth-page
  input parameter assistant :: <GtkAssistant>;
  input parameter page_num :: <gint>;
  result res :: <GtkWidget>;
  c-name: "gtk_assistant_get_nth_page";
end;

define C-function gtk-assistant-prepend-page
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_assistant_prepend_page";
end;

define C-function gtk-assistant-append-page
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <gint>;
  c-name: "gtk_assistant_append_page";
end;

define C-function gtk-assistant-insert-page
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter position :: <gint>;
  result res :: <gint>;
  c-name: "gtk_assistant_insert_page";
end;

define C-function gtk-assistant-set-forward-page-func
  input parameter assistant :: <GtkAssistant>;
  input parameter page_func :: <GtkAssistantPageFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  c-name: "gtk_assistant_set_forward_page_func";
end;

define C-function gtk-assistant-set-page-type
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter type :: <GtkAssistantPageType>;
  c-name: "gtk_assistant_set_page_type";
end;

define C-function gtk-assistant-get-page-type
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <GtkAssistantPageType>;
  c-name: "gtk_assistant_get_page_type";
end;

define C-function gtk-assistant-set-page-title
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter title :: <c-string>;
  c-name: "gtk_assistant_set_page_title";
end;

define C-function gtk-assistant-get-page-title
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <c-string>;
  c-name: "gtk_assistant_get_page_title";
end;

define C-function gtk-assistant-set-page-header-image
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_assistant_set_page_header_image";
end;

define C-function gtk-assistant-get-page-header-image
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_assistant_get_page_header_image";
end;

define C-function gtk-assistant-set-page-side-image
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter pixbuf :: <GdkPixbuf>;
  c-name: "gtk_assistant_set_page_side_image";
end;

define C-function gtk-assistant-get-page-side-image
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_assistant_get_page_side_image";
end;

define C-function gtk-assistant-set-page-complete
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  input parameter complete :: <gboolean>;
  c-name: "gtk_assistant_set_page_complete";
end;

define C-function gtk-assistant-get-page-complete
  input parameter assistant :: <GtkAssistant>;
  input parameter page :: <GtkWidget>;
  result res :: <gboolean>;
  c-name: "gtk_assistant_get_page_complete";
end;

define C-function gtk-assistant-add-action-widget
  input parameter assistant :: <GtkAssistant>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_assistant_add_action_widget";
end;

define C-function gtk-assistant-remove-action-widget
  input parameter assistant :: <GtkAssistant>;
  input parameter child :: <GtkWidget>;
  c-name: "gtk_assistant_remove_action_widget";
end;

define C-function gtk-assistant-update-buttons-state
  input parameter assistant :: <GtkAssistant>;
  c-name: "gtk_assistant_update_buttons_state";
end;

define C-subtype <_GtkAspectFrame> (<GtkFrame>, <AtkImplementorIface>) end;
define constant <GtkAspectFrame> = <_GtkAspectFrame>;

define C-subtype <_GtkAspectFrameClass> (<C-void*>) end;
define constant <GtkAspectFrameClass> = <_GtkAspectFrameClass>;

define C-function gtk-aspect-frame-get-type
  result res :: <GType>;
  c-name: "gtk_aspect_frame_get_type";
end;

define C-function gtk-aspect-frame-new
  input parameter label :: <c-string>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  input parameter ratio :: <gfloat>;
  input parameter obey_child :: <gboolean>;
  result res :: <GtkWidget>;
  c-name: "gtk_aspect_frame_new";
end;

define C-function gtk-aspect-frame-set
  input parameter aspect_frame :: <GtkAspectFrame>;
  input parameter xalign :: <gfloat>;
  input parameter yalign :: <gfloat>;
  input parameter ratio :: <gfloat>;
  input parameter obey_child :: <gboolean>;
  c-name: "gtk_aspect_frame_set";
end;

define C-subtype <_GtkArrow> (<GtkMisc>, <AtkImplementorIface>) end;
define constant <GtkArrow> = <_GtkArrow>;

define C-subtype <_GtkArrowClass> (<C-void*>) end;
define constant <GtkArrowClass> = <_GtkArrowClass>;

define C-function gtk-arrow-get-type
  result res :: <GType>;
  c-name: "gtk_arrow_get_type";
end;

define C-function gtk-arrow-new
  input parameter arrow_type :: <GtkArrowType>;
  input parameter shadow_type :: <GtkShadowType>;
  result res :: <GtkWidget>;
  c-name: "gtk_arrow_new";
end;

define C-function gtk-arrow-set
  input parameter arrow :: <GtkArrow>;
  input parameter arrow_type :: <GtkArrowType>;
  input parameter shadow_type :: <GtkShadowType>;
  c-name: "gtk_arrow_set";
end;

define C-subtype <_GtkAccessible> (<AtkObject>) end;
define constant <GtkAccessible> = <_GtkAccessible>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4626>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4627>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4628>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4629>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4630>"*/
define C-subtype <_GtkAccessibleClass> (<C-void*>) end;
define constant <GtkAccessibleClass> = <_GtkAccessibleClass>;

define C-function gtk-accessible-get-type
  result res :: <GType>;
  c-name: "gtk_accessible_get_type";
end;

define C-function gtk-accessible-connect-widget-destroyed
  input parameter accessible :: <GtkAccessible>;
  c-name: "gtk_accessible_connect_widget_destroyed";
end;

define C-subtype <_AtkValue> (<C-void*>) end;
define constant <AtkValue> = <_AtkValue>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4615>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4616>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4617>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4618>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4619>"*/
define C-subtype <_AtkValueIface> (<C-void*>) end;
define constant <AtkValueIface> = <_AtkValueIface>;

define C-function atk-value-get-type
  result res :: <GType>;
  c-name: "atk_value_get_type";
end;

define C-function atk-value-get-current-value
  input parameter obj :: <AtkValue>;
  input parameter value :: <GValue>;
  c-name: "atk_value_get_current_value";
end;

define C-function atk-value-get-maximum-value
  input parameter obj :: <AtkValue>;
  input parameter value :: <GValue>;
  c-name: "atk_value_get_maximum_value";
end;

define C-function atk-value-get-minimum-value
  input parameter obj :: <AtkValue>;
  input parameter value :: <GValue>;
  c-name: "atk_value_get_minimum_value";
end;

define C-function atk-value-set-current-value
  input parameter obj :: <AtkValue>;
  input parameter value :: <GValue>;
  result res :: <gboolean>;
  c-name: "atk_value_set_current_value";
end;

define C-function atk-value-get-minimum-increment
  input parameter obj :: <AtkValue>;
  input parameter value :: <GValue>;
  c-name: "atk_value_get_minimum_increment";
end;

define C-subtype <_AtkUtil> (<C-void*>) end;
define constant <AtkUtil> = <_AtkUtil>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4302>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4303>"*/
define C-subtype <_AtkKeyEventStruct> (<C-void*>) end;
define constant <AtkKeyEventStruct> = <_AtkKeyEventStruct>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4300>"*/
define constant <AtkKeySnoopFunc> = <anonymous-4300>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4304>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4305>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4306>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4307>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4308>"*/
define C-subtype <_AtkUtilClass> (<C-void*>) end;
define constant <AtkUtilClass> = <_AtkUtilClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4298>"*/
define constant <AtkEventListener> = <anonymous-4298>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4299>"*/
define constant <AtkEventListenerInit> = <anonymous-4299>;

define constant <AtkKeyEventType> = limited(<integer>, min: 0, max: 2);
define constant $ATK-KEY-EVENT-PRESS :: <AtkKeyEventType> = 0;
define constant $ATK-KEY-EVENT-RELEASE :: <AtkKeyEventType> = 1;
define constant $ATK-KEY-EVENT-LAST-DEFINED :: <AtkKeyEventType> = 2;

define C-function atk-util-get-type
  result res :: <GType>;
  c-name: "atk_util_get_type";
end;

define constant <AtkCoordType> = limited(<integer>, min: 0, max: 1);
define constant $ATK-XY-SCREEN :: <AtkCoordType> = 0;
define constant $ATK-XY-WINDOW :: <AtkCoordType> = 1;

define C-function atk-add-focus-tracker
  input parameter focus_tracker :: <AtkEventListener>;
  result res :: <guint>;
  c-name: "atk_add_focus_tracker";
end;

define C-function atk-remove-focus-tracker
  input parameter tracker_id :: <guint>;
  c-name: "atk_remove_focus_tracker";
end;

define C-function atk-focus-tracker-init
  input parameter init :: <AtkEventListenerInit>;
  c-name: "atk_focus_tracker_init";
end;

define C-function atk-focus-tracker-notify
  input parameter object :: <AtkObject>;
  c-name: "atk_focus_tracker_notify";
end;

define C-function atk-add-global-event-listener
  input parameter listener :: <GSignalEmissionHook>;
  input parameter event_type :: <c-string>;
  result res :: <guint>;
  c-name: "atk_add_global_event_listener";
end;

define C-function atk-remove-global-event-listener
  input parameter listener_id :: <guint>;
  c-name: "atk_remove_global_event_listener";
end;

define C-function atk-add-key-event-listener
  input parameter listener :: <AtkKeySnoopFunc>;
  input parameter data :: <gpointer>;
  result res :: <guint>;
  c-name: "atk_add_key_event_listener";
end;

define C-function atk-remove-key-event-listener
  input parameter listener_id :: <guint>;
  c-name: "atk_remove_key_event_listener";
end;

define C-function atk-get-root
  result res :: <AtkObject>;
  c-name: "atk_get_root";
end;

define C-function atk-get-focus-object
  result res :: <AtkObject>;
  c-name: "atk_get_focus_object";
end;

define C-function atk-get-toolkit-name
  result res :: <c-string>;
  c-name: "atk_get_toolkit_name";
end;

define C-function atk-get-toolkit-version
  result res :: <c-string>;
  c-name: "atk_get_toolkit_version";
end;

define constant <AtkTextAttribute> = limited(<integer>, min: 0, max: 28);
define constant $ATK-TEXT-ATTR-INVALID :: <AtkTextAttribute> = 0;
define constant $ATK-TEXT-ATTR-LEFT-MARGIN :: <AtkTextAttribute> = 1;
define constant $ATK-TEXT-ATTR-RIGHT-MARGIN :: <AtkTextAttribute> = 2;
define constant $ATK-TEXT-ATTR-INDENT :: <AtkTextAttribute> = 3;
define constant $ATK-TEXT-ATTR-INVISIBLE :: <AtkTextAttribute> = 4;
define constant $ATK-TEXT-ATTR-EDITABLE :: <AtkTextAttribute> = 5;
define constant $ATK-TEXT-ATTR-PIXELS-ABOVE-LINES :: <AtkTextAttribute> = 6;
define constant $ATK-TEXT-ATTR-PIXELS-BELOW-LINES :: <AtkTextAttribute> = 7;
define constant $ATK-TEXT-ATTR-PIXELS-INSIDE-WRAP :: <AtkTextAttribute> = 8;
define constant $ATK-TEXT-ATTR-BG-FULL-HEIGHT :: <AtkTextAttribute> = 9;
define constant $ATK-TEXT-ATTR-RISE :: <AtkTextAttribute> = 10;
define constant $ATK-TEXT-ATTR-UNDERLINE :: <AtkTextAttribute> = 11;
define constant $ATK-TEXT-ATTR-STRIKETHROUGH :: <AtkTextAttribute> = 12;
define constant $ATK-TEXT-ATTR-SIZE :: <AtkTextAttribute> = 13;
define constant $ATK-TEXT-ATTR-SCALE :: <AtkTextAttribute> = 14;
define constant $ATK-TEXT-ATTR-WEIGHT :: <AtkTextAttribute> = 15;
define constant $ATK-TEXT-ATTR-LANGUAGE :: <AtkTextAttribute> = 16;
define constant $ATK-TEXT-ATTR-FAMILY-NAME :: <AtkTextAttribute> = 17;
define constant $ATK-TEXT-ATTR-BG-COLOR :: <AtkTextAttribute> = 18;
define constant $ATK-TEXT-ATTR-FG-COLOR :: <AtkTextAttribute> = 19;
define constant $ATK-TEXT-ATTR-BG-STIPPLE :: <AtkTextAttribute> = 20;
define constant $ATK-TEXT-ATTR-FG-STIPPLE :: <AtkTextAttribute> = 21;
define constant $ATK-TEXT-ATTR-WRAP-MODE :: <AtkTextAttribute> = 22;
define constant $ATK-TEXT-ATTR-DIRECTION :: <AtkTextAttribute> = 23;
define constant $ATK-TEXT-ATTR-JUSTIFICATION :: <AtkTextAttribute> = 24;
define constant $ATK-TEXT-ATTR-STRETCH :: <AtkTextAttribute> = 25;
define constant $ATK-TEXT-ATTR-VARIANT :: <AtkTextAttribute> = 26;
define constant $ATK-TEXT-ATTR-STYLE :: <AtkTextAttribute> = 27;
define constant $ATK-TEXT-ATTR-LAST-DEFINED :: <AtkTextAttribute> = 28;

define C-function atk-text-attribute-register
  input parameter name :: <c-string>;
  result res :: <AtkTextAttribute>;
  c-name: "atk_text_attribute_register";
end;

define C-subtype <_AtkText> (<C-void*>) end;
define constant <AtkText> = <_AtkText>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4372>"*/
define constant <AtkTextBoundary> = limited(<integer>, min: 0, max: 6);
define constant $ATK-TEXT-BOUNDARY-CHAR :: <AtkTextBoundary> = 0;
define constant $ATK-TEXT-BOUNDARY-WORD-START :: <AtkTextBoundary> = 1;
define constant $ATK-TEXT-BOUNDARY-WORD-END :: <AtkTextBoundary> = 2;
define constant $ATK-TEXT-BOUNDARY-SENTENCE-START :: <AtkTextBoundary> = 3;
define constant $ATK-TEXT-BOUNDARY-SENTENCE-END :: <AtkTextBoundary> = 4;
define constant $ATK-TEXT-BOUNDARY-LINE-START :: <AtkTextBoundary> = 5;
define constant $ATK-TEXT-BOUNDARY-LINE-END :: <AtkTextBoundary> = 6;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4373>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4374>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4375>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4376>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4377>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4378>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4379>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4380>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4381>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4382>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4383>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4384>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4385>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4386>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4387>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4388>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4389>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4390>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4391>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4392>"*/
define C-subtype <_AtkTextRectangle> (<C-void*>) end;
define constant <AtkTextRectangle> = <_AtkTextRectangle>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4393>"*/
define C-subtype <_AtkTextRange> (<C-void*>) end;
define constant <AtkTextRange> = <_AtkTextRange>;

define C-pointer-type <AtkTextRange*> => <AtkTextRange>;
define constant <AtkTextClipType> = limited(<integer>, min: 0, max: 3);
define constant $ATK-TEXT-CLIP-NONE :: <AtkTextClipType> = 0;
define constant $ATK-TEXT-CLIP-MIN :: <AtkTextClipType> = 1;
define constant $ATK-TEXT-CLIP-MAX :: <AtkTextClipType> = 2;
define constant $ATK-TEXT-CLIP-BOTH :: <AtkTextClipType> = 3;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4394>"*/
define C-subtype <_AtkTextIface> (<C-void*>) end;
define constant <AtkTextIface> = <_AtkTextIface>;

define C-function atk-text-get-type
  result res :: <GType>;
  c-name: "atk_text_get_type";
end;

define C-function atk-text-get-text
  input parameter text :: <AtkText>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  result res :: <c-string>;
  c-name: "atk_text_get_text";
end;

define C-function atk-text-get-character-at-offset
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  result res :: <gunichar>;
  c-name: "atk_text_get_character_at_offset";
end;

define C-function atk-text-get-text-after-offset
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  input parameter boundary_type :: <AtkTextBoundary>;
  input parameter start_offset :: <gint*>;
  input parameter end_offset :: <gint*>;
  result res :: <c-string>;
  c-name: "atk_text_get_text_after_offset";
end;

define C-function atk-text-get-text-at-offset
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  input parameter boundary_type :: <AtkTextBoundary>;
  input parameter start_offset :: <gint*>;
  input parameter end_offset :: <gint*>;
  result res :: <c-string>;
  c-name: "atk_text_get_text_at_offset";
end;

define C-function atk-text-get-text-before-offset
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  input parameter boundary_type :: <AtkTextBoundary>;
  input parameter start_offset :: <gint*>;
  input parameter end_offset :: <gint*>;
  result res :: <c-string>;
  c-name: "atk_text_get_text_before_offset";
end;

define C-function atk-text-get-caret-offset
  input parameter text :: <AtkText>;
  result res :: <gint>;
  c-name: "atk_text_get_caret_offset";
end;

define C-function atk-text-get-character-extents
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  input parameter coords :: <AtkCoordType>;
  c-name: "atk_text_get_character_extents";
end;

define C-function atk-text-get-run-attributes
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  input parameter start_offset :: <gint*>;
  input parameter end_offset :: <gint*>;
  result res :: <AtkAttributeSet>;
  c-name: "atk_text_get_run_attributes";
end;

define C-function atk-text-get-default-attributes
  input parameter text :: <AtkText>;
  result res :: <AtkAttributeSet>;
  c-name: "atk_text_get_default_attributes";
end;

define C-function atk-text-get-character-count
  input parameter text :: <AtkText>;
  result res :: <gint>;
  c-name: "atk_text_get_character_count";
end;

define C-function atk-text-get-offset-at-point
  input parameter text :: <AtkText>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter coords :: <AtkCoordType>;
  result res :: <gint>;
  c-name: "atk_text_get_offset_at_point";
end;

define C-function atk-text-get-n-selections
  input parameter text :: <AtkText>;
  result res :: <gint>;
  c-name: "atk_text_get_n_selections";
end;

define C-function atk-text-get-selection
  input parameter text :: <AtkText>;
  input parameter selection_num :: <gint>;
  input parameter start_offset :: <gint*>;
  input parameter end_offset :: <gint*>;
  result res :: <c-string>;
  c-name: "atk_text_get_selection";
end;

define C-function atk-text-add-selection
  input parameter text :: <AtkText>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_text_add_selection";
end;

define C-function atk-text-remove-selection
  input parameter text :: <AtkText>;
  input parameter selection_num :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_text_remove_selection";
end;

define C-function atk-text-set-selection
  input parameter text :: <AtkText>;
  input parameter selection_num :: <gint>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_text_set_selection";
end;

define C-function atk-text-set-caret-offset
  input parameter text :: <AtkText>;
  input parameter offset :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_text_set_caret_offset";
end;

define C-function atk-text-get-range-extents
  input parameter text :: <AtkText>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  input parameter coord_type :: <AtkCoordType>;
  input parameter rect :: <AtkTextRectangle>;
  c-name: "atk_text_get_range_extents";
end;

define C-function atk-text-get-bounded-ranges
  input parameter text :: <AtkText>;
  input parameter rect :: <AtkTextRectangle>;
  input parameter coord_type :: <AtkCoordType>;
  input parameter x_clip_type :: <AtkTextClipType>;
  input parameter y_clip_type :: <AtkTextClipType>;
  result res :: <AtkTextRange*>;
  c-name: "atk_text_get_bounded_ranges";
end;

define C-function atk-text-free-ranges
  input parameter ranges :: <AtkTextRange*>;
  c-name: "atk_text_free_ranges";
end;

define C-function atk-attribute-set-free
  input parameter attrib_set :: <AtkAttributeSet>;
  c-name: "atk_attribute_set_free";
end;

define C-function atk-text-attribute-get-name
  input parameter attr :: <AtkTextAttribute>;
  result res :: <c-string>;
  c-name: "atk_text_attribute_get_name";
end;

define C-function atk-text-attribute-for-name
  input parameter name :: <c-string>;
  result res :: <AtkTextAttribute>;
  c-name: "atk_text_attribute_for_name";
end;

define C-function atk-text-attribute-get-value
  input parameter attr :: <AtkTextAttribute>;
  input parameter index_ :: <gint>;
  result res :: <c-string>;
  c-name: "atk_text_attribute_get_value";
end;

define C-subtype <_AtkTable> (<C-void*>) end;
define constant <AtkTable> = <_AtkTable>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4549>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4550>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4551>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4552>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4553>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4554>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4555>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4556>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4557>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4558>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4559>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4560>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4561>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4562>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4563>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4564>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4565>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4566>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4567>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4568>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4569>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4570>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4571>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4572>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4573>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4574>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4575>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4576>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4577>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4578>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4579>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4580>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4581>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4582>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4583>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4584>"*/
define C-subtype <_AtkTableIface> (<C-void*>) end;
define constant <AtkTableIface> = <_AtkTableIface>;

define C-function atk-table-get-type
  result res :: <GType>;
  c-name: "atk_table_get_type";
end;

define C-function atk-table-ref-at
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_table_ref_at";
end;

define C-function atk-table-get-index-at
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <gint>;
  c-name: "atk_table_get_index_at";
end;

define C-function atk-table-get-column-at-index
  input parameter table :: <AtkTable>;
  input parameter index_ :: <gint>;
  result res :: <gint>;
  c-name: "atk_table_get_column_at_index";
end;

define C-function atk-table-get-row-at-index
  input parameter table :: <AtkTable>;
  input parameter index_ :: <gint>;
  result res :: <gint>;
  c-name: "atk_table_get_row_at_index";
end;

define C-function atk-table-get-n-columns
  input parameter table :: <AtkTable>;
  result res :: <gint>;
  c-name: "atk_table_get_n_columns";
end;

define C-function atk-table-get-n-rows
  input parameter table :: <AtkTable>;
  result res :: <gint>;
  c-name: "atk_table_get_n_rows";
end;

define C-function atk-table-get-column-extent-at
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <gint>;
  c-name: "atk_table_get_column_extent_at";
end;

define C-function atk-table-get-row-extent-at
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <gint>;
  c-name: "atk_table_get_row_extent_at";
end;

define C-function atk-table-get-caption
  input parameter table :: <AtkTable>;
  result res :: <AtkObject>;
  c-name: "atk_table_get_caption";
end;

define C-function atk-table-get-column-description
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  result res :: <c-string>;
  c-name: "atk_table_get_column_description";
end;

define C-function atk-table-get-column-header
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_table_get_column_header";
end;

define C-function atk-table-get-row-description
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  result res :: <c-string>;
  c-name: "atk_table_get_row_description";
end;

define C-function atk-table-get-row-header
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_table_get_row_header";
end;

define C-function atk-table-get-summary
  input parameter table :: <AtkTable>;
  result res :: <AtkObject>;
  c-name: "atk_table_get_summary";
end;

define C-function atk-table-set-caption
  input parameter table :: <AtkTable>;
  input parameter caption :: <AtkObject>;
  c-name: "atk_table_set_caption";
end;

define C-function atk-table-set-column-description
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  input parameter description :: <c-string>;
  c-name: "atk_table_set_column_description";
end;

define C-function atk-table-set-column-header
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  input parameter header :: <AtkObject>;
  c-name: "atk_table_set_column_header";
end;

define C-function atk-table-set-row-description
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter description :: <c-string>;
  c-name: "atk_table_set_row_description";
end;

define C-function atk-table-set-row-header
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter header :: <AtkObject>;
  c-name: "atk_table_set_row_header";
end;

define C-function atk-table-set-summary
  input parameter table :: <AtkTable>;
  input parameter accessible :: <AtkObject>;
  c-name: "atk_table_set_summary";
end;

define C-function atk-table-get-selected-columns
  input parameter table :: <AtkTable>;
  input parameter selected :: <gint**>;
  result res :: <gint>;
  c-name: "atk_table_get_selected_columns";
end;

define C-function atk-table-get-selected-rows
  input parameter table :: <AtkTable>;
  input parameter selected :: <gint**>;
  result res :: <gint>;
  c-name: "atk_table_get_selected_rows";
end;

define C-function atk-table-is-column-selected
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_is_column_selected";
end;

define C-function atk-table-is-row-selected
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_is_row_selected";
end;

define C-function atk-table-is-selected
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  input parameter column :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_is_selected";
end;

define C-function atk-table-add-row-selection
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_add_row_selection";
end;

define C-function atk-table-remove-row-selection
  input parameter table :: <AtkTable>;
  input parameter row :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_remove_row_selection";
end;

define C-function atk-table-add-column-selection
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_add_column_selection";
end;

define C-function atk-table-remove-column-selection
  input parameter table :: <AtkTable>;
  input parameter column :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_table_remove_column_selection";
end;

define C-subtype <_AtkStreamableContent> (<C-void*>) end;
define constant <AtkStreamableContent> = <_AtkStreamableContent>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4540>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4541>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4542>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4543>"*/
define C-subtype <_AtkStreamableContentIface> (<C-void*>) end;
define constant <AtkStreamableContentIface> = <_AtkStreamableContentIface>;

define C-function atk-streamable-content-get-type
  result res :: <GType>;
  c-name: "atk_streamable_content_get_type";
end;

define C-function atk-streamable-content-get-n-mime-types
  input parameter streamable :: <AtkStreamableContent>;
  result res :: <gint>;
  c-name: "atk_streamable_content_get_n_mime_types";
end;

define C-function atk-streamable-content-get-mime-type
  input parameter streamable :: <AtkStreamableContent>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_streamable_content_get_mime_type";
end;

define C-function atk-streamable-content-get-stream
  input parameter streamable :: <AtkStreamableContent>;
  input parameter mime_type :: <c-string>;
  result res :: <GIOChannel>;
  c-name: "atk_streamable_content_get_stream";
end;

define C-function atk-streamable-content-get-uri
  input parameter streamable :: <AtkStreamableContent>;
  input parameter mime_type :: <c-string>;
  result res :: <c-string>;
  c-name: "atk_streamable_content_get_uri";
end;

define C-subtype <_AtkStateSetClass> (<C-void*>) end;
define constant <AtkStateSetClass> = <_AtkStateSetClass>;

define C-function atk-state-set-get-type
  result res :: <GType>;
  c-name: "atk_state_set_get_type";
end;

define C-function atk-state-set-new
  result res :: <AtkStateSet>;
  c-name: "atk_state_set_new";
end;

define C-function atk-state-set-is-empty
  input parameter set :: <AtkStateSet>;
  result res :: <gboolean>;
  c-name: "atk_state_set_is_empty";
end;

define C-function atk-state-set-add-state
  input parameter set :: <AtkStateSet>;
  input parameter type :: <AtkStateType>;
  result res :: <gboolean>;
  c-name: "atk_state_set_add_state";
end;

define C-pointer-type <AtkStateType*> => <AtkStateType>;
define C-function atk-state-set-add-states
  input parameter set :: <AtkStateSet>;
  input parameter types :: <AtkStateType*>;
  input parameter n_types :: <gint>;
  c-name: "atk_state_set_add_states";
end;

define C-function atk-state-set-clear-states
  input parameter set :: <AtkStateSet>;
  c-name: "atk_state_set_clear_states";
end;

define C-function atk-state-set-contains-state
  input parameter set :: <AtkStateSet>;
  input parameter type :: <AtkStateType>;
  result res :: <gboolean>;
  c-name: "atk_state_set_contains_state";
end;

define C-function atk-state-set-contains-states
  input parameter set :: <AtkStateSet>;
  input parameter types :: <AtkStateType*>;
  input parameter n_types :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_state_set_contains_states";
end;

define C-function atk-state-set-remove-state
  input parameter set :: <AtkStateSet>;
  input parameter type :: <AtkStateType>;
  result res :: <gboolean>;
  c-name: "atk_state_set_remove_state";
end;

define C-function atk-state-set-and-sets
  input parameter set :: <AtkStateSet>;
  input parameter compare_set :: <AtkStateSet>;
  result res :: <AtkStateSet>;
  c-name: "atk_state_set_and_sets";
end;

define C-function atk-state-set-or-sets
  input parameter set :: <AtkStateSet>;
  input parameter compare_set :: <AtkStateSet>;
  result res :: <AtkStateSet>;
  c-name: "atk_state_set_or_sets";
end;

define C-function atk-state-set-xor-sets
  input parameter set :: <AtkStateSet>;
  input parameter compare_set :: <AtkStateSet>;
  result res :: <AtkStateSet>;
  c-name: "atk_state_set_xor_sets";
end;

define C-subtype <_AtkSelection> (<C-void*>) end;
define constant <AtkSelection> = <_AtkSelection>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4512>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4513>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4514>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4515>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4516>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4517>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4518>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4519>"*/
define C-subtype <_AtkSelectionIface> (<C-void*>) end;
define constant <AtkSelectionIface> = <_AtkSelectionIface>;

define C-function atk-selection-get-type
  result res :: <GType>;
  c-name: "atk_selection_get_type";
end;

define C-function atk-selection-add-selection
  input parameter selection :: <AtkSelection>;
  input parameter i :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_selection_add_selection";
end;

define C-function atk-selection-clear-selection
  input parameter selection :: <AtkSelection>;
  result res :: <gboolean>;
  c-name: "atk_selection_clear_selection";
end;

define C-function atk-selection-ref-selection
  input parameter selection :: <AtkSelection>;
  input parameter i :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_selection_ref_selection";
end;

define C-function atk-selection-get-selection-count
  input parameter selection :: <AtkSelection>;
  result res :: <gint>;
  c-name: "atk_selection_get_selection_count";
end;

define C-function atk-selection-is-child-selected
  input parameter selection :: <AtkSelection>;
  input parameter i :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_selection_is_child_selected";
end;

define C-function atk-selection-remove-selection
  input parameter selection :: <AtkSelection>;
  input parameter i :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_selection_remove_selection";
end;

define C-function atk-selection-select-all-selection
  input parameter selection :: <AtkSelection>;
  result res :: <gboolean>;
  c-name: "atk_selection_select_all_selection";
end;

define C-subtype <_AtkRelationSetClass> (<C-void*>) end;
define constant <AtkRelationSetClass> = <_AtkRelationSetClass>;

define C-function atk-relation-set-get-type
  result res :: <GType>;
  c-name: "atk_relation_set_get_type";
end;

define C-function atk-relation-set-new
  result res :: <AtkRelationSet>;
  c-name: "atk_relation_set_new";
end;

define C-function atk-relation-set-contains
  input parameter set :: <AtkRelationSet>;
  input parameter relationship :: <AtkRelationType>;
  result res :: <gboolean>;
  c-name: "atk_relation_set_contains";
end;

define C-subtype <_AtkRelation> (<C-void*>) end;
define constant <AtkRelation> = <_AtkRelation>;

define C-function atk-relation-set-remove
  input parameter set :: <AtkRelationSet>;
  input parameter relation :: <AtkRelation>;
  c-name: "atk_relation_set_remove";
end;

define C-function atk-relation-set-add
  input parameter set :: <AtkRelationSet>;
  input parameter relation :: <AtkRelation>;
  c-name: "atk_relation_set_add";
end;

define C-function atk-relation-set-get-n-relations
  input parameter set :: <AtkRelationSet>;
  result res :: <gint>;
  c-name: "atk_relation_set_get_n_relations";
end;

define C-function atk-relation-set-get-relation
  input parameter set :: <AtkRelationSet>;
  input parameter i :: <gint>;
  result res :: <AtkRelation>;
  c-name: "atk_relation_set_get_relation";
end;

define C-function atk-relation-set-get-relation-by-type
  input parameter set :: <AtkRelationSet>;
  input parameter relationship :: <AtkRelationType>;
  result res :: <AtkRelation>;
  c-name: "atk_relation_set_get_relation_by_type";
end;

define C-function atk-relation-set-add-relation-by-type
  input parameter set :: <AtkRelationSet>;
  input parameter relationship :: <AtkRelationType>;
  input parameter target :: <AtkObject>;
  c-name: "atk_relation_set_add_relation_by_type";
end;

define C-subtype <_AtkRelationClass> (<C-void*>) end;
define constant <AtkRelationClass> = <_AtkRelationClass>;

define C-function atk-relation-get-type
  result res :: <GType>;
  c-name: "atk_relation_get_type";
end;

define C-function atk-relation-type-register
  input parameter name :: <c-string>;
  result res :: <AtkRelationType>;
  c-name: "atk_relation_type_register";
end;

define C-function atk-relation-type-get-name
  input parameter type :: <AtkRelationType>;
  result res :: <c-string>;
  c-name: "atk_relation_type_get_name";
end;

define C-function atk-relation-type-for-name
  input parameter name :: <c-string>;
  result res :: <AtkRelationType>;
  c-name: "atk_relation_type_for_name";
end;

define C-pointer-type <AtkObject*> => <AtkObject>;
define C-function atk-relation-new
  input parameter targets :: <AtkObject*>;
  input parameter n_targets :: <gint>;
  input parameter relationship :: <AtkRelationType>;
  result res :: <AtkRelation>;
  c-name: "atk_relation_new";
end;

define C-function atk-relation-get-relation-type
  input parameter relation :: <AtkRelation>;
  result res :: <AtkRelationType>;
  c-name: "atk_relation_get_relation_type";
end;

define C-function atk-relation-get-target
  input parameter relation :: <AtkRelation>;
  result res :: <GPtrArray>;
  c-name: "atk_relation_get_target";
end;

define C-function atk-relation-add-target
  input parameter relation :: <AtkRelation>;
  input parameter target :: <AtkObject>;
  c-name: "atk_relation_add_target";
end;

define C-subtype <_AtkRegistry> (<C-void*>) end;
define C-subtype <_AtkRegistryClass> (<C-void*>) end;
define constant <AtkRegistry> = <_AtkRegistry>;

define constant <AtkRegistryClass> = <_AtkRegistryClass>;

define C-function atk-registry-get-type
  result res :: <GType>;
  c-name: "atk_registry_get_type";
end;

define C-function atk-registry-set-factory-type
  input parameter registry :: <AtkRegistry>;
  input parameter type :: <GType>;
  input parameter factory_type :: <GType>;
  c-name: "atk_registry_set_factory_type";
end;

define C-function atk-registry-get-factory-type
  input parameter registry :: <AtkRegistry>;
  input parameter type :: <GType>;
  result res :: <GType>;
  c-name: "atk_registry_get_factory_type";
end;

define C-subtype <_AtkObjectFactory> (<C-void*>) end;
define constant <AtkObjectFactory> = <_AtkObjectFactory>;

define C-function atk-registry-get-factory
  input parameter registry :: <AtkRegistry>;
  input parameter type :: <GType>;
  result res :: <AtkObjectFactory>;
  c-name: "atk_registry_get_factory";
end;

define C-function atk-get-default-registry
  result res :: <AtkRegistry>;
  c-name: "atk_get_default_registry";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4481>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4482>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4483>"*/
define C-subtype <_AtkObjectFactoryClass> (<C-void*>) end;
define constant <AtkObjectFactoryClass> = <_AtkObjectFactoryClass>;

define C-function atk-object-factory-get-type
  result res :: <GType>;
  c-name: "atk_object_factory_get_type";
end;

define C-function atk-object-factory-create-accessible
  input parameter factory :: <AtkObjectFactory>;
  input parameter obj :: <GObject>;
  result res :: <AtkObject>;
  c-name: "atk_object_factory_create_accessible";
end;

define C-function atk-object-factory-invalidate
  input parameter factory :: <AtkObjectFactory>;
  c-name: "atk_object_factory_invalidate";
end;

define C-function atk-object-factory-get-accessible-type
  input parameter factory :: <AtkObjectFactory>;
  result res :: <GType>;
  c-name: "atk_object_factory_get_accessible_type";
end;

define C-subtype <_AtkNoOpObjectFactory> (<C-void*>) end;
define constant <AtkNoOpObjectFactory> = <_AtkNoOpObjectFactory>;

define C-subtype <_AtkNoOpObjectFactoryClass> (<C-void*>) end;
define constant <AtkNoOpObjectFactoryClass> = <_AtkNoOpObjectFactoryClass>;

define C-function atk-no-op-object-factory-get-type
  result res :: <GType>;
  c-name: "atk_no_op_object_factory_get_type";
end;

define C-function atk-no-op-object-factory-new
  result res :: <AtkObjectFactory>;
  c-name: "atk_no_op_object_factory_new";
end;

define C-subtype <_AtkNoOpObject> (<C-void*>) end;
define constant <AtkNoOpObject> = <_AtkNoOpObject>;

define C-subtype <_AtkNoOpObjectClass> (<C-void*>) end;
define constant <AtkNoOpObjectClass> = <_AtkNoOpObjectClass>;

define C-function atk-no-op-object-get-type
  result res :: <GType>;
  c-name: "atk_no_op_object_get_type";
end;

define C-function atk-no-op-object-new
  input parameter obj :: <GObject>;
  result res :: <AtkObject>;
  c-name: "atk_no_op_object_new";
end;

define C-subtype <_AtkImage> (<C-void*>) end;
define constant <AtkImage> = <_AtkImage>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4468>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4469>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4470>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4471>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4472>"*/
define C-subtype <_AtkImageIface> (<C-void*>) end;
define constant <AtkImageIface> = <_AtkImageIface>;

define C-function atk-image-get-type
  result res :: <GType>;
  c-name: "atk_image_get_type";
end;

define C-function atk-image-get-image-description
  input parameter image :: <AtkImage>;
  result res :: <c-string>;
  c-name: "atk_image_get_image_description";
end;

define C-function atk-image-get-image-size
  input parameter image :: <AtkImage>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "atk_image_get_image_size";
end;

define C-function atk-image-set-image-description
  input parameter image :: <AtkImage>;
  input parameter description :: <c-string>;
  result res :: <gboolean>;
  c-name: "atk_image_set_image_description";
end;

define C-function atk-image-get-image-position
  input parameter image :: <AtkImage>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter coord_type :: <AtkCoordType>;
  c-name: "atk_image_get_image_position";
end;

define C-function atk-image-get-image-locale
  input parameter image :: <AtkImage>;
  result res :: <c-string>;
  c-name: "atk_image_get_image_locale";
end;

define C-subtype <_AtkHypertext> (<C-void*>) end;
define constant <AtkHypertext> = <_AtkHypertext>;

define C-subtype <_AtkHyperlink> (<C-void*>) end;
define constant <AtkHyperlink> = <_AtkHyperlink>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4460>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4461>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4462>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4463>"*/
define C-subtype <_AtkHypertextIface> (<C-void*>) end;
define constant <AtkHypertextIface> = <_AtkHypertextIface>;

define C-function atk-hypertext-get-type
  result res :: <GType>;
  c-name: "atk_hypertext_get_type";
end;

define C-function atk-hypertext-get-link
  input parameter hypertext :: <AtkHypertext>;
  input parameter link_index :: <gint>;
  result res :: <AtkHyperlink>;
  c-name: "atk_hypertext_get_link";
end;

define C-function atk-hypertext-get-n-links
  input parameter hypertext :: <AtkHypertext>;
  result res :: <gint>;
  c-name: "atk_hypertext_get_n_links";
end;

define C-function atk-hypertext-get-link-index
  input parameter hypertext :: <AtkHypertext>;
  input parameter char_index :: <gint>;
  result res :: <gint>;
  c-name: "atk_hypertext_get_link_index";
end;

define constant <AtkHyperlinkStateFlags> = limited(<integer>, min: 1, max: 1);
define constant $ATK-HYPERLINK-IS-INLINE :: <AtkHyperlinkStateFlags> = 1;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4439>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4440>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4441>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4442>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4443>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4444>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4445>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4446>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4447>"*/
define C-subtype <_AtkHyperlinkClass> (<C-void*>) end;
define constant <AtkHyperlinkClass> = <_AtkHyperlinkClass>;

define C-function atk-hyperlink-get-type
  result res :: <GType>;
  c-name: "atk_hyperlink_get_type";
end;

define C-function atk-hyperlink-get-uri
  input parameter link_ :: <AtkHyperlink>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_hyperlink_get_uri";
end;

define C-function atk-hyperlink-get-object
  input parameter link_ :: <AtkHyperlink>;
  input parameter i :: <gint>;
  result res :: <AtkObject>;
  c-name: "atk_hyperlink_get_object";
end;

define C-function atk-hyperlink-get-end-index
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gint>;
  c-name: "atk_hyperlink_get_end_index";
end;

define C-function atk-hyperlink-get-start-index
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gint>;
  c-name: "atk_hyperlink_get_start_index";
end;

define C-function atk-hyperlink-is-valid
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gboolean>;
  c-name: "atk_hyperlink_is_valid";
end;

define C-function atk-hyperlink-is-inline
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gboolean>;
  c-name: "atk_hyperlink_is_inline";
end;

define C-function atk-hyperlink-get-n-anchors
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gint>;
  c-name: "atk_hyperlink_get_n_anchors";
end;

define C-function atk-hyperlink-is-selected-link
  input parameter link_ :: <AtkHyperlink>;
  result res :: <gboolean>;
  c-name: "atk_hyperlink_is_selected_link";
end;

define C-subtype <_AtkAction> (<C-void*>) end;
define constant <AtkAction> = <_AtkAction>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4283>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4284>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4285>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4286>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4287>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4288>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4289>"*/
define C-subtype <_AtkActionIface> (<C-void*>) end;
define constant <AtkActionIface> = <_AtkActionIface>;

define C-function atk-action-get-type
  result res :: <GType>;
  c-name: "atk_action_get_type";
end;

define C-function atk-action-do-action
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_action_do_action";
end;

define C-function atk-action-get-n-actions
  input parameter action :: <AtkAction>;
  result res :: <gint>;
  c-name: "atk_action_get_n_actions";
end;

define C-function atk-action-get-description
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_action_get_description";
end;

define C-function atk-action-get-name
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_action_get_name";
end;

define C-function atk-action-get-keybinding
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_action_get_keybinding";
end;

define C-function atk-action-set-description
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  input parameter desc :: <c-string>;
  result res :: <gboolean>;
  c-name: "atk_action_set_description";
end;

define C-function atk-action-get-localized-name
  input parameter action :: <AtkAction>;
  input parameter i :: <gint>;
  result res :: <c-string>;
  c-name: "atk_action_get_localized_name";
end;

define C-subtype <_AtkHyperlinkImpl> (<C-void*>) end;
define constant <AtkHyperlinkImpl> = <_AtkHyperlinkImpl>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4457>"*/
define C-subtype <_AtkHyperlinkImplIface> (<C-void*>) end;
define constant <AtkHyperlinkImplIface> = <_AtkHyperlinkImplIface>;

define C-function atk-hyperlink-impl-get-type
  result res :: <GType>;
  c-name: "atk_hyperlink_impl_get_type";
end;

define C-function atk-hyperlink-impl-get-hyperlink
  input parameter obj :: <AtkHyperlinkImpl>;
  result res :: <AtkHyperlink>;
  c-name: "atk_hyperlink_impl_get_hyperlink";
end;

define C-subtype <_AtkGObjectAccessible> (<C-void*>) end;
define constant <AtkGObjectAccessible> = <_AtkGObjectAccessible>;

define C-subtype <_AtkGObjectAccessibleClass> (<C-void*>) end;
define constant <AtkGObjectAccessibleClass> = <_AtkGObjectAccessibleClass>;

define C-function atk-gobject-accessible-get-type
  result res :: <GType>;
  c-name: "atk_gobject_accessible_get_type";
end;

define C-function atk-gobject-accessible-for-object
  input parameter obj :: <GObject>;
  result res :: <AtkObject>;
  c-name: "atk_gobject_accessible_for_object";
end;

define C-function atk-gobject-accessible-get-object
  input parameter obj :: <AtkGObjectAccessible>;
  result res :: <GObject>;
  c-name: "atk_gobject_accessible_get_object";
end;

define C-subtype <_AtkEditableText> (<C-void*>) end;
define constant <AtkEditableText> = <_AtkEditableText>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4420>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4421>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4422>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4423>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4424>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4425>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4426>"*/
define C-subtype <_AtkEditableTextIface> (<C-void*>) end;
define constant <AtkEditableTextIface> = <_AtkEditableTextIface>;

define C-function atk-editable-text-get-type
  result res :: <GType>;
  c-name: "atk_editable_text_get_type";
end;

define C-function atk-editable-text-set-run-attributes
  input parameter text :: <AtkEditableText>;
  input parameter attrib_set :: <AtkAttributeSet>;
  input parameter start_offset :: <gint>;
  input parameter end_offset :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_editable_text_set_run_attributes";
end;

define C-function atk-editable-text-set-text-contents
  input parameter text :: <AtkEditableText>;
  input parameter string :: <c-string>;
  c-name: "atk_editable_text_set_text_contents";
end;

define C-function atk-editable-text-insert-text
  input parameter text :: <AtkEditableText>;
  input parameter string :: <c-string>;
  input parameter length :: <gint>;
  input parameter position :: <gint*>;
  c-name: "atk_editable_text_insert_text";
end;

define C-function atk-editable-text-copy-text
  input parameter text :: <AtkEditableText>;
  input parameter start_pos :: <gint>;
  input parameter end_pos :: <gint>;
  c-name: "atk_editable_text_copy_text";
end;

define C-function atk-editable-text-cut-text
  input parameter text :: <AtkEditableText>;
  input parameter start_pos :: <gint>;
  input parameter end_pos :: <gint>;
  c-name: "atk_editable_text_cut_text";
end;

define C-function atk-editable-text-delete-text
  input parameter text :: <AtkEditableText>;
  input parameter start_pos :: <gint>;
  input parameter end_pos :: <gint>;
  c-name: "atk_editable_text_delete_text";
end;

define C-function atk-editable-text-paste-text
  input parameter text :: <AtkEditableText>;
  input parameter position :: <gint>;
  c-name: "atk_editable_text_paste_text";
end;

define C-subtype <_AtkDocument> (<C-void*>) end;
define constant <AtkDocument> = <_AtkDocument>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4355>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4356>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4357>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4358>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4359>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4360>"*/
define C-subtype <_AtkDocumentIface> (<C-void*>) end;
define constant <AtkDocumentIface> = <_AtkDocumentIface>;

define C-function atk-document-get-type
  result res :: <GType>;
  c-name: "atk_document_get_type";
end;

define C-function atk-document-get-document-type
  input parameter document :: <AtkDocument>;
  result res :: <c-string>;
  c-name: "atk_document_get_document_type";
end;

define C-function atk-document-get-document
  input parameter document :: <AtkDocument>;
  result res :: <gpointer>;
  c-name: "atk_document_get_document";
end;

define C-function atk-document-get-locale
  input parameter document :: <AtkDocument>;
  result res :: <c-string>;
  c-name: "atk_document_get_locale";
end;

define C-function atk-document-get-attributes
  input parameter document :: <AtkDocument>;
  result res :: <AtkAttributeSet>;
  c-name: "atk_document_get_attributes";
end;

define C-function atk-document-get-attribute-value
  input parameter document :: <AtkDocument>;
  input parameter attribute_name :: <c-string>;
  result res :: <c-string>;
  c-name: "atk_document_get_attribute_value";
end;

define C-function atk-document-set-attribute-value
  input parameter document :: <AtkDocument>;
  input parameter attribute_name :: <c-string>;
  input parameter attribute_value :: <c-string>;
  result res :: <gboolean>;
  c-name: "atk_document_set_attribute_value";
end;

define C-subtype <_AtkComponent> (<C-void*>) end;
define constant <AtkComponent> = <_AtkComponent>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4323>"*/
define constant <AtkFocusHandler> = <anonymous-4323>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4325>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4326>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4327>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4328>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4329>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4330>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4331>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4332>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4333>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4334>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4335>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4336>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4337>"*/
define C-subtype <_AtkRectangle> (<C-void*>) end;
define constant <AtkRectangle> = <_AtkRectangle>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4338>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4339>"*/
define C-subtype <_AtkComponentIface> (<C-void*>) end;
define constant <AtkComponentIface> = <_AtkComponentIface>;

define C-function atk-rectangle-get-type
  result res :: <GType>;
  c-name: "atk_rectangle_get_type";
end;

define C-function atk-component-get-type
  result res :: <GType>;
  c-name: "atk_component_get_type";
end;

define C-function atk-component-add-focus-handler
  input parameter component :: <AtkComponent>;
  input parameter handler :: <AtkFocusHandler>;
  result res :: <guint>;
  c-name: "atk_component_add_focus_handler";
end;

define C-function atk-component-contains
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter coord_type :: <AtkCoordType>;
  result res :: <gboolean>;
  c-name: "atk_component_contains";
end;

define C-function atk-component-ref-accessible-at-point
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter coord_type :: <AtkCoordType>;
  result res :: <AtkObject>;
  c-name: "atk_component_ref_accessible_at_point";
end;

define C-function atk-component-get-extents
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  input parameter coord_type :: <AtkCoordType>;
  c-name: "atk_component_get_extents";
end;

define C-function atk-component-get-position
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint*>;
  input parameter y :: <gint*>;
  input parameter coord_type :: <AtkCoordType>;
  c-name: "atk_component_get_position";
end;

define C-function atk-component-get-size
  input parameter component :: <AtkComponent>;
  input parameter width :: <gint*>;
  input parameter height :: <gint*>;
  c-name: "atk_component_get_size";
end;

define C-function atk-component-get-layer
  input parameter component :: <AtkComponent>;
  result res :: <AtkLayer>;
  c-name: "atk_component_get_layer";
end;

define C-function atk-component-get-mdi-zorder
  input parameter component :: <AtkComponent>;
  result res :: <gint>;
  c-name: "atk_component_get_mdi_zorder";
end;

define C-function atk-component-grab-focus
  input parameter component :: <AtkComponent>;
  result res :: <gboolean>;
  c-name: "atk_component_grab_focus";
end;

define C-function atk-component-remove-focus-handler
  input parameter component :: <AtkComponent>;
  input parameter handler_id :: <guint>;
  c-name: "atk_component_remove_focus_handler";
end;

define C-function atk-component-set-extents
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  input parameter coord_type :: <AtkCoordType>;
  result res :: <gboolean>;
  c-name: "atk_component_set_extents";
end;

define C-function atk-component-set-position
  input parameter component :: <AtkComponent>;
  input parameter x :: <gint>;
  input parameter y :: <gint>;
  input parameter coord_type :: <AtkCoordType>;
  result res :: <gboolean>;
  c-name: "atk_component_set_position";
end;

define C-function atk-component-set-size
  input parameter component :: <AtkComponent>;
  input parameter width :: <gint>;
  input parameter height :: <gint>;
  result res :: <gboolean>;
  c-name: "atk_component_set_size";
end;

define C-function atk-component-get-alpha
  input parameter component :: <AtkComponent>;
  result res :: <gdouble>;
  c-name: "atk_component_get_alpha";
end;

define C-subtype <_GtkAccelMap> (<C-void*>) end;
define constant <GtkAccelMap> = <_GtkAccelMap>;

define C-subtype <_GtkAccelMapClass> (<C-void*>) end;
define constant <GtkAccelMapClass> = <_GtkAccelMapClass>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4263>"*/
define constant <GtkAccelMapForeach> = <anonymous-4263>;

define C-function gtk-accel-map-add-entry
  input parameter accel_path :: <c-string>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  c-name: "gtk_accel_map_add_entry";
end;

define C-function gtk-accel-map-lookup-entry
  input parameter accel_path :: <c-string>;
  input parameter key :: <GtkAccelKey>;
  result res :: <gboolean>;
  c-name: "gtk_accel_map_lookup_entry";
end;

define C-function gtk-accel-map-change-entry
  input parameter accel_path :: <c-string>;
  input parameter accel_key :: <guint>;
  input parameter accel_mods :: <GdkModifierType>;
  input parameter replace :: <gboolean>;
  result res :: <gboolean>;
  c-name: "gtk_accel_map_change_entry";
end;

define C-function gtk-accel-map-load-utf8
  input parameter file_name :: <c-string>;
  c-name: "gtk_accel_map_load_utf8";
end;

define C-function gtk-accel-map-save-utf8
  input parameter file_name :: <c-string>;
  c-name: "gtk_accel_map_save_utf8";
end;

define C-function gtk-accel-map-foreach
  input parameter data :: <gpointer>;
  input parameter foreach_func :: <GtkAccelMapForeach>;
  c-name: "gtk_accel_map_foreach";
end;

define C-function gtk-accel-map-load-fd
  input parameter fd :: <gint>;
  c-name: "gtk_accel_map_load_fd";
end;

define C-function gtk-accel-map-load-scanner
  input parameter scanner :: <GScanner>;
  c-name: "gtk_accel_map_load_scanner";
end;

define C-function gtk-accel-map-save-fd
  input parameter fd :: <gint>;
  c-name: "gtk_accel_map_save_fd";
end;

define C-function gtk-accel-map-lock-path
  input parameter accel_path :: <c-string>;
  c-name: "gtk_accel_map_lock_path";
end;

define C-function gtk-accel-map-unlock-path
  input parameter accel_path :: <c-string>;
  c-name: "gtk_accel_map_unlock_path";
end;

define C-function gtk-accel-map-add-filter
  input parameter filter_pattern :: <c-string>;
  c-name: "gtk_accel_map_add_filter";
end;

define C-function gtk-accel-map-foreach-unfiltered
  input parameter data :: <gpointer>;
  input parameter foreach_func :: <GtkAccelMapForeach>;
  c-name: "gtk_accel_map_foreach_unfiltered";
end;

define C-function gtk-accel-map-get-type
  result res :: <GType>;
  c-name: "gtk_accel_map_get_type";
end;

define C-function gtk-accel-map-get
  result res :: <GtkAccelMap>;
  c-name: "gtk_accel_map_get";
end;

define C-function _gtk-accel-map-init
  c-name: "_gtk_accel_map_init";
end;

define C-function _gtk-accel-map-add-group
  input parameter accel_path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "_gtk_accel_map_add_group";
end;

define C-function _gtk-accel-map-remove-group
  input parameter accel_path :: <c-string>;
  input parameter accel_group :: <GtkAccelGroup>;
  c-name: "_gtk_accel_map_remove_group";
end;

define C-function _gtk-accel-path-is-valid
  input parameter accel_path :: <c-string>;
  result res :: <gboolean>;
  c-name: "_gtk_accel_path_is_valid";
end;

define constant gtk-accel-map-load = gtk-accel-map-load-utf8;

define constant gtk-accel-map-save = gtk-accel-map-save-utf8;

define C-subtype <_GtkAccelLabel> (<GtkLabel>, <AtkImplementorIface>) end;
define constant <GtkAccelLabel> = <_GtkAccelLabel>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4251>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4252>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4253>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4254>"*/
define C-subtype <_GtkAccelLabelClass> (<C-void*>) end;
define constant <GtkAccelLabelClass> = <_GtkAccelLabelClass>;

define C-function gtk-accel-label-get-type
  result res :: <GType>;
  c-name: "gtk_accel_label_get_type";
end;

define C-function gtk-accel-label-new
  input parameter string :: <c-string>;
  result res :: <GtkWidget>;
  c-name: "gtk_accel_label_new";
end;

define C-function gtk-accel-label-get-accel-widget
  input parameter accel_label :: <GtkAccelLabel>;
  result res :: <GtkWidget>;
  c-name: "gtk_accel_label_get_accel_widget";
end;

define C-function gtk-accel-label-get-accel-width
  input parameter accel_label :: <GtkAccelLabel>;
  result res :: <guint>;
  c-name: "gtk_accel_label_get_accel_width";
end;

define C-function gtk-accel-label-set-accel-widget
  input parameter accel_label :: <GtkAccelLabel>;
  input parameter accel_widget :: <GtkWidget>;
  c-name: "gtk_accel_label_set_accel_widget";
end;

define C-function gtk-accel-label-set-accel-closure
  input parameter accel_label :: <GtkAccelLabel>;
  input parameter accel_closure :: <GClosure>;
  c-name: "gtk_accel_label_set_accel_closure";
end;

define C-function gtk-accel-label-refetch
  input parameter accel_label :: <GtkAccelLabel>;
  result res :: <gboolean>;
  c-name: "gtk_accel_label_refetch";
end;

define C-function _gtk-accel-label-class-get-accelerator-label
  input parameter klass :: <GtkAccelLabelClass>;
  input parameter accelerator_key :: <guint>;
  input parameter accelerator_mods :: <GdkModifierType>;
  result res :: <c-string>;
  c-name: "_gtk_accel_label_class_get_accelerator_label";
end;

define constant gtk-accel-label-accelerator-width = gtk-accel-label-get-accel-width;

define C-subtype <_GtkAboutDialog> (<C-void*>) end;
define constant <GtkAboutDialog> = <_GtkAboutDialog>;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4076>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4077>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4078>"*/
 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4079>"*/
define C-subtype <_GtkAboutDialogClass> (<C-void*>) end;
define constant <GtkAboutDialogClass> = <_GtkAboutDialogClass>;

define C-function gtk-about-dialog-get-type
  result res :: <GType>;
  c-name: "gtk_about_dialog_get_type";
end;

define C-function gtk-about-dialog-new
  result res :: <GtkWidget>;
  c-name: "gtk_about_dialog_new";
end;

define C-function gtk-show-about-dialog
  input parameter parent :: <GtkWindow>;
  input parameter first_property_name :: <c-string>;
  c-name: "gtk_show_about_dialog";
end;

define C-function gtk-about-dialog-get-name
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_name";
end;

define C-function gtk-about-dialog-set-name
  input parameter about :: <GtkAboutDialog>;
  input parameter name :: <c-string>;
  c-name: "gtk_about_dialog_set_name";
end;

define C-function gtk-about-dialog-get-version
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_version";
end;

define C-function gtk-about-dialog-set-version
  input parameter about :: <GtkAboutDialog>;
  input parameter version :: <c-string>;
  c-name: "gtk_about_dialog_set_version";
end;

define C-function gtk-about-dialog-get-copyright
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_copyright";
end;

define C-function gtk-about-dialog-set-copyright
  input parameter about :: <GtkAboutDialog>;
  input parameter copyright :: <c-string>;
  c-name: "gtk_about_dialog_set_copyright";
end;

define C-function gtk-about-dialog-get-comments
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_comments";
end;

define C-function gtk-about-dialog-set-comments
  input parameter about :: <GtkAboutDialog>;
  input parameter comments :: <c-string>;
  c-name: "gtk_about_dialog_set_comments";
end;

define C-function gtk-about-dialog-get-license
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_license";
end;

define C-function gtk-about-dialog-set-license
  input parameter about :: <GtkAboutDialog>;
  input parameter license :: <c-string>;
  c-name: "gtk_about_dialog_set_license";
end;

define C-function gtk-about-dialog-get-wrap-license
  input parameter about :: <GtkAboutDialog>;
  result res :: <gboolean>;
  c-name: "gtk_about_dialog_get_wrap_license";
end;

define C-function gtk-about-dialog-set-wrap-license
  input parameter about :: <GtkAboutDialog>;
  input parameter wrap_license :: <gboolean>;
  c-name: "gtk_about_dialog_set_wrap_license";
end;

define C-function gtk-about-dialog-get-website
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_website";
end;

define C-function gtk-about-dialog-set-website
  input parameter about :: <GtkAboutDialog>;
  input parameter website :: <c-string>;
  c-name: "gtk_about_dialog_set_website";
end;

define C-function gtk-about-dialog-get-website-label
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_website_label";
end;

define C-function gtk-about-dialog-set-website-label
  input parameter about :: <GtkAboutDialog>;
  input parameter website_label :: <c-string>;
  c-name: "gtk_about_dialog_set_website_label";
end;

define C-function gtk-about-dialog-get-authors
  input parameter about :: <GtkAboutDialog>;
  result res :: <gchar**>;
  c-name: "gtk_about_dialog_get_authors";
end;

define C-function gtk-about-dialog-set-authors
  input parameter about :: <GtkAboutDialog>;
  input parameter authors :: <gchar**>;
  c-name: "gtk_about_dialog_set_authors";
end;

define C-function gtk-about-dialog-get-documenters
  input parameter about :: <GtkAboutDialog>;
  result res :: <gchar**>;
  c-name: "gtk_about_dialog_get_documenters";
end;

define C-function gtk-about-dialog-set-documenters
  input parameter about :: <GtkAboutDialog>;
  input parameter documenters :: <gchar**>;
  c-name: "gtk_about_dialog_set_documenters";
end;

define C-function gtk-about-dialog-get-artists
  input parameter about :: <GtkAboutDialog>;
  result res :: <gchar**>;
  c-name: "gtk_about_dialog_get_artists";
end;

define C-function gtk-about-dialog-set-artists
  input parameter about :: <GtkAboutDialog>;
  input parameter artists :: <gchar**>;
  c-name: "gtk_about_dialog_set_artists";
end;

define C-function gtk-about-dialog-get-translator-credits
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_translator_credits";
end;

define C-function gtk-about-dialog-set-translator-credits
  input parameter about :: <GtkAboutDialog>;
  input parameter translator_credits :: <c-string>;
  c-name: "gtk_about_dialog_set_translator_credits";
end;

define C-function gtk-about-dialog-get-logo
  input parameter about :: <GtkAboutDialog>;
  result res :: <GdkPixbuf>;
  c-name: "gtk_about_dialog_get_logo";
end;

define C-function gtk-about-dialog-set-logo
  input parameter about :: <GtkAboutDialog>;
  input parameter logo :: <GdkPixbuf>;
  c-name: "gtk_about_dialog_set_logo";
end;

define C-function gtk-about-dialog-get-logo-icon-name
  input parameter about :: <GtkAboutDialog>;
  result res :: <c-string>;
  c-name: "gtk_about_dialog_get_logo_icon_name";
end;

define C-function gtk-about-dialog-set-logo-icon-name
  input parameter about :: <GtkAboutDialog>;
  input parameter icon_name :: <c-string>;
  c-name: "gtk_about_dialog_set_logo_icon_name";
end;

 /* Ignoring declaration for {instance of <function-type-declaration>} "<anonymous-4111>"*/
define constant <GtkAboutDialogActivateLinkFunc> = <anonymous-4111>;

define C-function gtk-about-dialog-set-email-hook
  input parameter func :: <GtkAboutDialogActivateLinkFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  result res :: <GtkAboutDialogActivateLinkFunc>;
  c-name: "gtk_about_dialog_set_email_hook";
end;

define C-function gtk-about-dialog-set-url-hook
  input parameter func :: <GtkAboutDialogActivateLinkFunc>;
  input parameter data :: <gpointer>;
  input parameter destroy :: <GDestroyNotify>;
  result res :: <GtkAboutDialogActivateLinkFunc>;
  c-name: "gtk_about_dialog_set_url_hook";
end;