[Gd-chatter] r11355 - in branches/opendylan-melange: gtk-c-ffi gtk-hello-world melange
hannes at gwydiondylan.org
hannes at gwydiondylan.org
Wed May 16 00:39:17 CEST 2007
Author: hannes
Date: Wed May 16 00:39:13 2007
New Revision: 11355
Modified:
branches/opendylan-melange/gtk-c-ffi/gtk-2-10-win32.dylan
branches/opendylan-melange/gtk-c-ffi/gtk-2-10-win32.intr
branches/opendylan-melange/gtk-c-ffi/gtk-module-2-10-win32.dylan
branches/opendylan-melange/gtk-hello-world/gtk-hello-world.dylan
branches/opendylan-melange/melange/c-decl-state.dylan
branches/opendylan-melange/melange/c-decl-write-c-ffi.dylan
branches/opendylan-melange/melange/interface.dylan
branches/opendylan-melange/melange/name-map.dylan
Log:
Job: fd
more work on the melange, define C-struct are now emitted
Modified: branches/opendylan-melange/gtk-c-ffi/gtk-2-10-win32.dylan
==============================================================================
--- branches/opendylan-melange/gtk-c-ffi/gtk-2-10-win32.dylan (original)
+++ branches/opendylan-melange/gtk-c-ffi/gtk-2-10-win32.dylan Wed May 16 00:39:13 2007
@@ -4,16 +4,21 @@
define constant <GType> = <gulong>;
-define C-subtype <_GTypeClass> (<C-void*>) end;
-define constant <GTypeClass> = <_GTypeClass>;
+define C-struct <_GTypeClass>
+ slot GTypeClass-g-type :: <C-unsigned-long>;
+end;
+
+define C-pointer-type <GTypeClass> => <_GTypeClass>;
define C-subtype <_GTypeInstance> (<C-void*>) end;
define constant <GTypeInstance> = <_GTypeInstance>;
define constant <guint> = <C-unsigned-int>;
-define C-subtype <_GData> (<C-void*>) end;
-define constant <GData> = <_GData>;
+define C-struct <_GData>
+end;
+
+define C-pointer-type <GData> => <_GData>;
define C-subtype <_GObject> (<_GTypeInstance>) end;
define constant <GInitiallyUnowned> = <_GObject>;
@@ -29,16 +34,24 @@
define constant <gchar> = <C-signed-char>;
+define constant <gchar*> = <C-String>;
//define C-pointer-type <gchar*> => <gchar>;
-define constant <gchar*> = <C-string>;
define constant <GObject> = <_GObject>;
-define C-subtype <_GdkColor> (<C-void*>) end;
-define constant <GdkColor> = <_GdkColor>;
+define C-struct <_GdkColor>
+ slot GdkColor-pixel :: <C-unsigned-int>;
+ slot GdkColor-red :: <C-unsigned-short>;
+ slot GdkColor-green :: <C-unsigned-short>;
+ slot GdkColor-blue :: <C-unsigned-short>;
+end;
+
+define C-pointer-type <GdkColor> => <_GdkColor>;
define constant <GdkColor<@5>> = <GdkColor>;
-define C-subtype <_PangoFontDescription> (<C-void*>) end;
-define constant <PangoFontDescription> = <_PangoFontDescription>;
+define C-struct <_PangoFontDescription>
+end;
+
+define C-pointer-type <PangoFontDescription> => <_PangoFontDescription>;
define constant <gint> = <C-signed-int>;
@@ -76,8 +89,13 @@
define constant $GDK-FONT-FONT = 0;
define constant $GDK-FONT-FONTSET = 1;
-define C-subtype <_GdkFont> (<C-void*>) end;
-define constant <GdkFont> = <_GdkFont>;
+define C-struct <_GdkFont>
+ slot GdkFont-type :: <GdkFontType>;
+ slot GdkFont-ascent :: <C-signed-int>;
+ slot GdkFont-descent :: <C-signed-int>;
+end;
+
+define C-pointer-type <GdkFont> => <_GdkFont>;
define C-pointer-type <gchar**> => <gchar*>;
define constant <gchar*<@5>> = <gchar**>;
@@ -89,11 +107,19 @@
define C-pointer-type <GtkRcFlags*> => <GtkRcFlags>;
define constant <GtkRcFlags<@5>> = <GtkRcFlags*>;
-define C-subtype <_GArray> (<C-void*>) end;
-define constant <GArray> = <_GArray>;
+define C-struct <_GArray>
+ slot GArray-data :: <gchar*>;
+ slot GArray-len :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GArray> => <_GArray>;
-define C-subtype <_GSList> (<C-void*>) end;
-define constant <GSList> = <_GSList>;
+define C-struct <_GSList>
+ slot GSList-data :: <C-void*>;
+ slot GSList-next :: <GSList>;
+end;
+
+define C-pointer-type <GSList> => <_GSList>;
define C-subtype <_GtkRcStyle> (<_GObject>) end;
define constant <GtkRcStyle> = <_GtkRcStyle>;
@@ -101,11 +127,21 @@
define C-subtype <_GtkStyle> (<_GObject>) end;
define constant <GtkStyle> = <_GtkStyle>;
-define C-subtype <_GtkRequisition> (<C-void*>) end;
-define constant <GtkRequisition> = <_GtkRequisition>;
+define C-struct <_GtkRequisition>
+ slot GtkRequisition-width :: <C-signed-int>;
+ slot GtkRequisition-height :: <C-signed-int>;
+end;
+
+define C-pointer-type <GtkRequisition> => <_GtkRequisition>;
-define C-subtype <_GdkRectangle> (<C-void*>) end;
-define constant <GdkRectangle> = <_GdkRectangle>;
+define C-struct <_GdkRectangle>
+ slot GdkRectangle-x :: <C-signed-int>;
+ slot GdkRectangle-y :: <C-signed-int>;
+ slot GdkRectangle-width :: <C-signed-int>;
+ slot GdkRectangle-height :: <C-signed-int>;
+end;
+
+define C-pointer-type <GdkRectangle> => <_GdkRectangle>;
define constant <GtkAllocation> = <GdkRectangle>;
@@ -122,8 +158,10 @@
define constant <GtkWindow> = <_GtkWindow>;
-define C-subtype <_GtkWindowGeometryInfo> (<C-void*>) end;
-define constant <GtkWindowGeometryInfo> = <_GtkWindowGeometryInfo>;
+define C-struct <_GtkWindowGeometryInfo>
+end;
+
+define C-pointer-type <GtkWindowGeometryInfo> => <_GtkWindowGeometryInfo>;
define C-subtype <_GtkWindowGroup> (<_GObject>) end;
define constant <GtkWindowGroup> = <_GtkWindowGroup>;
@@ -149,8 +187,10 @@
//define constant $GDK-MODIFIER-MASK = #ex000000005C001FFF;
define constant <GdkGC<@32>> = <GdkGC*>;
-define C-subtype <_cairo-font-options> (<C-void*>) end;
-define constant <cairo-font-options-t> = <_cairo-font-options>;
+define C-struct <_cairo-font-options>
+end;
+
+define C-pointer-type <cairo-font-options-t> => <_cairo-font-options>;
define C-subtype <_GdkScreen> (<_GObject>) end;
define constant <GdkScreen> = <_GdkScreen>;
@@ -167,8 +207,20 @@
define constant $G-PARAM-STATIC-NICK = 64;
define constant $G-PARAM-STATIC-BLURB = 128;
-define C-subtype <_GParamSpec> (<C-void*>) end;
-define constant <GParamSpec> = <_GParamSpec>;
+define C-struct <_GParamSpec>
+ slot GParamSpec-g-type-instance :: <_GTypeInstance>;
+ slot GParamSpec-name :: <gchar*>;
+ slot GParamSpec-flags :: <GParamFlags>;
+ slot GParamSpec-value-type :: <C-unsigned-long>;
+ slot GParamSpec-owner-type :: <C-unsigned-long>;
+ slot GParamSpec-_nick :: <gchar*>;
+ slot GParamSpec-_blurb :: <gchar*>;
+ slot GParamSpec-qdata :: <GData>;
+ slot GParamSpec-ref-count :: <C-unsigned-int>;
+ slot GParamSpec-param-id :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GParamSpec> => <_GParamSpec>;
define constant <glong> = <C-signed-long>;
@@ -182,11 +234,19 @@
define C-subtype <anonymous-1507> (<C-void*>) end;
define constant <anonymous-1507<@2>> = <anonymous-1507>;
-define C-subtype <_GValue> (<C-void*>) end;
-define constant <GValue> = <_GValue>;
+define C-struct <_GValue>
+ slot GValue-g-type :: <C-unsigned-long>;
+ slot GValue-data :: <anonymous-1507<@2>>;
+end;
+
+define C-pointer-type <GValue> => <_GValue>;
+
+define C-struct <_GObjectConstructParam>
+ slot GObjectConstructParam-pspec :: <GParamSpec>;
+ slot GObjectConstructParam-value :: <GValue>;
+end;
-define C-subtype <_GObjectConstructParam> (<C-void*>) end;
-define constant <GObjectConstructParam> = <_GObjectConstructParam>;
+define C-pointer-type <GObjectConstructParam> => <_GObjectConstructParam>;
define constant <anonymous-1653> = <C-function-pointer>;
define constant <anonymous-1654> = <C-function-pointer>;
@@ -198,8 +258,20 @@
define constant <anonymous-1659> = <C-function-pointer>;
define C-pointer-type <gpointer*> => <gpointer>;
define constant <gpointer<@8>> = <gpointer*>;
-define C-subtype <_GObjectClass> (<C-void*>) end;
-define constant <GInitiallyUnownedClass> = <_GObjectClass>;
+define C-struct <_GObjectClass>
+ slot GObjectClass-g-type-class :: <_GTypeClass>;
+ slot GObjectClass-construct-properties :: <GSList>;
+ slot GObjectClass-constructor :: <anonymous-1653>;
+ slot GObjectClass-set-property :: <anonymous-1654>;
+ slot GObjectClass-get-property :: <anonymous-1655>;
+ slot GObjectClass-dispose :: <anonymous-1656>;
+ slot GObjectClass-finalize :: <anonymous-1657>;
+ slot GObjectClass-dispatch-properties-changed :: <anonymous-1658>;
+ slot GObjectClass-notify :: <anonymous-1659>;
+ slot GObjectClass-pdummy :: <gpointer<@8>>;
+end;
+
+define C-pointer-type <GInitiallyUnownedClass> => <_GObjectClass>;
define constant <GtkType> = <GType>;
@@ -210,16 +282,31 @@
define constant <anonymous-3344> = <C-function-pointer>;
define constant <GtkSignalFunc> = <anonymous-3344>;
-define C-subtype <anonymous-3345> (<C-void*>) end;
+define C-struct <anonymous-3345>
+ slot nonymous-3345-f :: <anonymous-3344>;
+ slot nonymous-3345-d :: <C-void*>;
+end;
+
define C-subtype <anonymous-3346> (<C-void*>) end;
-define C-subtype <_GtkArg> (<C-void*>) end;
-define constant <GtkArg> = <_GtkArg>;
+define C-struct <_GtkArg>
+ slot GtkArg-type :: <C-unsigned-long>;
+ slot GtkArg-name :: <gchar*>;
+ slot GtkArg-d :: <anonymous-3346>;
+end;
+
+define C-pointer-type <GtkArg> => <_GtkArg>;
define constant <anonymous-3357> = <C-function-pointer>;
define constant <anonymous-3358> = <C-function-pointer>;
define constant <anonymous-3359> = <C-function-pointer>;
-define C-subtype <_GtkObjectClass> (<C-void*>) end;
-define constant <GtkObjectClass> = <_GtkObjectClass>;
+define C-struct <_GtkObjectClass>
+ slot GtkObjectClass-parent-class :: <_GObjectClass>;
+ slot GtkObjectClass-set-arg :: <anonymous-3357>;
+ slot GtkObjectClass-get-arg :: <anonymous-3358>;
+ slot GtkObjectClass-destroy :: <anonymous-3359>;
+end;
+
+define C-pointer-type <GtkObjectClass> => <_GtkObjectClass>;
define constant <anonymous-3634> = <C-function-pointer>;
define constant <anonymous-3635> = <C-function-pointer>;
@@ -303,25 +390,51 @@
define constant <gint8> = <C-signed-char>;
-define C-subtype <_GdkEventAny> (<C-void*>) end;
-define constant <GdkEventAny> = <_GdkEventAny>;
+define C-struct <_GdkEventAny>
+ slot GdkEventAny-type :: <GdkEventType>;
+ slot GdkEventAny-window :: <GdkWindow>;
+ slot GdkEventAny-send-event :: <C-signed-char>;
+end;
+
+define C-pointer-type <GdkEventAny> => <_GdkEventAny>;
+
+define C-struct <_GdkRegion>
+end;
+
+define C-pointer-type <GdkRegion> => <_GdkRegion>;
+
+define C-struct <_GdkEventExpose>
+ slot GdkEventExpose-type :: <GdkEventType>;
+ slot GdkEventExpose-window :: <GdkWindow>;
+ slot GdkEventExpose-send-event :: <C-signed-char>;
+ slot GdkEventExpose-area :: <_GdkRectangle>;
+ slot GdkEventExpose-region :: <GdkRegion>;
+ slot GdkEventExpose-count :: <C-signed-int>;
+end;
-define C-subtype <_GdkRegion> (<C-void*>) end;
-define constant <GdkRegion> = <_GdkRegion>;
+define C-pointer-type <GdkEventExpose> => <_GdkEventExpose>;
-define C-subtype <_GdkEventExpose> (<C-void*>) end;
-define constant <GdkEventExpose> = <_GdkEventExpose>;
+define C-struct <_GdkEventNoExpose>
+ slot GdkEventNoExpose-type :: <GdkEventType>;
+ slot GdkEventNoExpose-window :: <GdkWindow>;
+ slot GdkEventNoExpose-send-event :: <C-signed-char>;
+end;
-define C-subtype <_GdkEventNoExpose> (<C-void*>) end;
-define constant <GdkEventNoExpose> = <_GdkEventNoExpose>;
+define C-pointer-type <GdkEventNoExpose> => <_GdkEventNoExpose>;
define constant <GdkVisibilityState> = <C-int>;
define constant $GDK-VISIBILITY-UNOBSCURED = 0;
define constant $GDK-VISIBILITY-PARTIAL = 1;
define constant $GDK-VISIBILITY-FULLY-OBSCURED = 2;
-define C-subtype <_GdkEventVisibility> (<C-void*>) end;
-define constant <GdkEventVisibility> = <_GdkEventVisibility>;
+define C-struct <_GdkEventVisibility>
+ slot GdkEventVisibility-type :: <GdkEventType>;
+ slot GdkEventVisibility-window :: <GdkWindow>;
+ slot GdkEventVisibility-send-event :: <C-signed-char>;
+ slot GdkEventVisibility-state :: <GdkVisibilityState>;
+end;
+
+define C-pointer-type <GdkEventVisibility> => <_GdkEventVisibility>;
define C-pointer-type <gdouble*> => <gdouble>;
define constant <gint16> = <C-signed-short>;
@@ -347,20 +460,57 @@
define constant $GDK-AXIS-WHEEL = 6;
define constant $GDK-AXIS-LAST = 7;
-define C-subtype <_GdkDeviceAxis> (<C-void*>) end;
-define constant <GdkDeviceAxis> = <_GdkDeviceAxis>;
+define C-struct <_GdkDeviceAxis>
+ slot GdkDeviceAxis-use :: <GdkAxisUse>;
+ slot GdkDeviceAxis-min :: <C-double>;
+ slot GdkDeviceAxis-max :: <C-double>;
+end;
+
+define C-pointer-type <GdkDeviceAxis> => <_GdkDeviceAxis>;
-define C-subtype <_GdkDeviceKey> (<C-void*>) end;
-define constant <GdkDeviceKey> = <_GdkDeviceKey>;
+define C-struct <_GdkDeviceKey>
+ slot GdkDeviceKey-keyval :: <C-unsigned-int>;
+ slot GdkDeviceKey-modifiers :: <GdkModifierType>;
+end;
+
+define C-pointer-type <GdkDeviceKey> => <_GdkDeviceKey>;
define C-subtype <_GdkDevice> (<_GObject>) end;
define constant <GdkDevice> = <_GdkDevice>;
-define C-subtype <_GdkEventMotion> (<C-void*>) end;
-define constant <GdkEventMotion> = <_GdkEventMotion>;
+define C-struct <_GdkEventMotion>
+ slot GdkEventMotion-type :: <GdkEventType>;
+ slot GdkEventMotion-window :: <GdkWindow>;
+ slot GdkEventMotion-send-event :: <C-signed-char>;
+ slot GdkEventMotion-time :: <C-unsigned-int>;
+ slot GdkEventMotion-x :: <C-double>;
+ slot GdkEventMotion-y :: <C-double>;
+ slot GdkEventMotion-axes :: <gdouble*>;
+ slot GdkEventMotion-state :: <C-unsigned-int>;
+ slot GdkEventMotion-is-hint :: <C-signed-short>;
+ slot GdkEventMotion-device :: <GdkDevice>;
+ slot GdkEventMotion-x-root :: <C-double>;
+ slot GdkEventMotion-y-root :: <C-double>;
+end;
+
+define C-pointer-type <GdkEventMotion> => <_GdkEventMotion>;
+
+define C-struct <_GdkEventButton>
+ slot GdkEventButton-type :: <GdkEventType>;
+ slot GdkEventButton-window :: <GdkWindow>;
+ slot GdkEventButton-send-event :: <C-signed-char>;
+ slot GdkEventButton-time :: <C-unsigned-int>;
+ slot GdkEventButton-x :: <C-double>;
+ slot GdkEventButton-y :: <C-double>;
+ slot GdkEventButton-axes :: <gdouble*>;
+ slot GdkEventButton-state :: <C-unsigned-int>;
+ slot GdkEventButton-button :: <C-unsigned-int>;
+ slot GdkEventButton-device :: <GdkDevice>;
+ slot GdkEventButton-x-root :: <C-double>;
+ slot GdkEventButton-y-root :: <C-double>;
+end;
-define C-subtype <_GdkEventButton> (<C-void*>) end;
-define constant <GdkEventButton> = <_GdkEventButton>;
+define C-pointer-type <GdkEventButton> => <_GdkEventButton>;
define constant <GdkScrollDirection> = <C-int>;
define constant $GDK-SCROLL-UP = 0;
@@ -368,11 +518,37 @@
define constant $GDK-SCROLL-LEFT = 2;
define constant $GDK-SCROLL-RIGHT = 3;
-define C-subtype <_GdkEventScroll> (<C-void*>) end;
-define constant <GdkEventScroll> = <_GdkEventScroll>;
+define C-struct <_GdkEventScroll>
+ slot GdkEventScroll-type :: <GdkEventType>;
+ slot GdkEventScroll-window :: <GdkWindow>;
+ slot GdkEventScroll-send-event :: <C-signed-char>;
+ slot GdkEventScroll-time :: <C-unsigned-int>;
+ slot GdkEventScroll-x :: <C-double>;
+ slot GdkEventScroll-y :: <C-double>;
+ slot GdkEventScroll-state :: <C-unsigned-int>;
+ slot GdkEventScroll-direction :: <GdkScrollDirection>;
+ slot GdkEventScroll-device :: <GdkDevice>;
+ slot GdkEventScroll-x-root :: <C-double>;
+ slot GdkEventScroll-y-root :: <C-double>;
+end;
+
+define C-pointer-type <GdkEventScroll> => <_GdkEventScroll>;
+
+define C-struct <_GdkEventKey>
+ slot GdkEventKey-type :: <GdkEventType>;
+ slot GdkEventKey-window :: <GdkWindow>;
+ slot GdkEventKey-send-event :: <C-signed-char>;
+ slot GdkEventKey-time :: <C-unsigned-int>;
+ slot GdkEventKey-state :: <C-unsigned-int>;
+ slot GdkEventKey-keyval :: <C-unsigned-int>;
+ slot GdkEventKey-length :: <C-signed-int>;
+ slot GdkEventKey-string :: <gchar*>;
+ slot GdkEventKey-hardware-keycode :: <C-unsigned-short>;
+ slot GdkEventKey-group :: <C-unsigned-char>;
+ bitfield slot GdkEventKey-is-modifier :: <C-int>, width: 1;
+end;
-define C-subtype <_GdkEventKey> (<C-void*>) end;
-define constant <GdkEventKey> = <_GdkEventKey>;
+define C-pointer-type <GdkEventKey> => <_GdkEventKey>;
define constant <GdkCrossingMode> = <C-int>;
define constant $GDK-CROSSING-NORMAL = 0;
@@ -387,36 +563,103 @@
define constant $GDK-NOTIFY-NONLINEAR-VIRTUAL = 4;
define constant $GDK-NOTIFY-UNKNOWN = 5;
-define C-subtype <_GdkEventCrossing> (<C-void*>) end;
-define constant <GdkEventCrossing> = <_GdkEventCrossing>;
+define C-struct <_GdkEventCrossing>
+ slot GdkEventCrossing-type :: <GdkEventType>;
+ slot GdkEventCrossing-window :: <GdkWindow>;
+ slot GdkEventCrossing-send-event :: <C-signed-char>;
+ slot GdkEventCrossing-subwindow :: <GdkWindow>;
+ slot GdkEventCrossing-time :: <C-unsigned-int>;
+ slot GdkEventCrossing-x :: <C-double>;
+ slot GdkEventCrossing-y :: <C-double>;
+ slot GdkEventCrossing-x-root :: <C-double>;
+ slot GdkEventCrossing-y-root :: <C-double>;
+ slot GdkEventCrossing-mode :: <GdkCrossingMode>;
+ slot GdkEventCrossing-detail :: <GdkNotifyType>;
+ slot GdkEventCrossing-focus :: <C-signed-int>;
+ slot GdkEventCrossing-state :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GdkEventCrossing> => <_GdkEventCrossing>;
+
+define C-struct <_GdkEventFocus>
+ slot GdkEventFocus-type :: <GdkEventType>;
+ slot GdkEventFocus-window :: <GdkWindow>;
+ slot GdkEventFocus-send-event :: <C-signed-char>;
+ slot GdkEventFocus-in :: <C-signed-short>;
+end;
+
+define C-pointer-type <GdkEventFocus> => <_GdkEventFocus>;
+
+define C-struct <_GdkEventConfigure>
+ slot GdkEventConfigure-type :: <GdkEventType>;
+ slot GdkEventConfigure-window :: <GdkWindow>;
+ slot GdkEventConfigure-send-event :: <C-signed-char>;
+ slot GdkEventConfigure-x :: <C-signed-int>;
+ slot GdkEventConfigure-y :: <C-signed-int>;
+ slot GdkEventConfigure-width :: <C-signed-int>;
+ slot GdkEventConfigure-height :: <C-signed-int>;
+end;
-define C-subtype <_GdkEventFocus> (<C-void*>) end;
-define constant <GdkEventFocus> = <_GdkEventFocus>;
+define C-pointer-type <GdkEventConfigure> => <_GdkEventConfigure>;
-define C-subtype <_GdkEventConfigure> (<C-void*>) end;
-define constant <GdkEventConfigure> = <_GdkEventConfigure>;
+define C-struct <_GdkAtom>
+end;
-define C-subtype <_GdkAtom> (<C-void*>) end;
define constant <GdkAtom> = <_GdkAtom>;
-define C-subtype <_GdkEventProperty> (<C-void*>) end;
-define constant <GdkEventProperty> = <_GdkEventProperty>;
+define C-struct <_GdkEventProperty>
+ slot GdkEventProperty-type :: <GdkEventType>;
+ slot GdkEventProperty-window :: <GdkWindow>;
+ slot GdkEventProperty-send-event :: <C-signed-char>;
+ slot GdkEventProperty-atom :: <_GdkAtom>;
+ slot GdkEventProperty-time :: <C-unsigned-int>;
+ slot GdkEventProperty-state :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GdkEventProperty> => <_GdkEventProperty>;
define constant <GdkNativeWindow> = <guint32>;
-define C-subtype <_GdkEventSelection> (<C-void*>) end;
-define constant <GdkEventSelection> = <_GdkEventSelection>;
+define C-struct <_GdkEventSelection>
+ slot GdkEventSelection-type :: <GdkEventType>;
+ slot GdkEventSelection-window :: <GdkWindow>;
+ slot GdkEventSelection-send-event :: <C-signed-char>;
+ slot GdkEventSelection-selection :: <_GdkAtom>;
+ slot GdkEventSelection-target :: <_GdkAtom>;
+ slot GdkEventSelection-property :: <_GdkAtom>;
+ slot GdkEventSelection-time :: <C-unsigned-int>;
+ slot GdkEventSelection-requestor :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GdkEventSelection> => <_GdkEventSelection>;
define constant <GdkOwnerChange> = <C-int>;
define constant $GDK-OWNER-CHANGE-NEW-OWNER = 0;
define constant $GDK-OWNER-CHANGE-DESTROY = 1;
define constant $GDK-OWNER-CHANGE-CLOSE = 2;
-define C-subtype <_GdkEventOwnerChange> (<C-void*>) end;
-define constant <GdkEventOwnerChange> = <_GdkEventOwnerChange>;
+define C-struct <_GdkEventOwnerChange>
+ slot GdkEventOwnerChange-type :: <GdkEventType>;
+ slot GdkEventOwnerChange-window :: <GdkWindow>;
+ slot GdkEventOwnerChange-send-event :: <C-signed-char>;
+ slot GdkEventOwnerChange-owner :: <C-unsigned-int>;
+ slot GdkEventOwnerChange-reason :: <GdkOwnerChange>;
+ slot GdkEventOwnerChange-selection :: <_GdkAtom>;
+ slot GdkEventOwnerChange-time :: <C-unsigned-int>;
+ slot GdkEventOwnerChange-selection-time :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GdkEventOwnerChange> => <_GdkEventOwnerChange>;
+
+define C-struct <_GdkEventProximity>
+ slot GdkEventProximity-type :: <GdkEventType>;
+ slot GdkEventProximity-window :: <GdkWindow>;
+ slot GdkEventProximity-send-event :: <C-signed-char>;
+ slot GdkEventProximity-time :: <C-unsigned-int>;
+ slot GdkEventProximity-device :: <GdkDevice>;
+end;
-define C-subtype <_GdkEventProximity> (<C-void*>) end;
-define constant <GdkEventProximity> = <_GdkEventProximity>;
+define C-pointer-type <GdkEventProximity> => <_GdkEventProximity>;
define constant <gushort> = <C-unsigned-short>;
@@ -427,8 +670,16 @@
define C-pointer-type <long*> => <C-signed-long>;
define constant <long<@5>> = <long*>;
define C-subtype <anonymous-2545> (<C-void*>) end;
-define C-subtype <_GdkEventClient> (<C-void*>) end;
-define constant <GdkEventClient> = <_GdkEventClient>;
+define C-struct <_GdkEventClient>
+ slot GdkEventClient-type :: <GdkEventType>;
+ slot GdkEventClient-window :: <GdkWindow>;
+ slot GdkEventClient-send-event :: <C-signed-char>;
+ slot GdkEventClient-message-type :: <_GdkAtom>;
+ slot GdkEventClient-data-format :: <C-unsigned-short>;
+ slot GdkEventClient-data :: <anonymous-2545>;
+end;
+
+define C-pointer-type <GdkEventClient> => <_GdkEventClient>;
define constant <GdkDragProtocol> = <C-int>;
define constant $GDK-DRAG-PROTO-MOTIF = 0;
@@ -439,8 +690,13 @@
define constant $GDK-DRAG-PROTO-OLE2 = 5;
define constant $GDK-DRAG-PROTO-LOCAL = 6;
-define C-subtype <_GList> (<C-void*>) end;
-define constant <GList> = <_GList>;
+define C-struct <_GList>
+ slot GList-data :: <C-void*>;
+ slot GList-next :: <GList>;
+ slot GList-prev :: <GList>;
+end;
+
+define C-pointer-type <GList> => <_GList>;
define constant <GdkDragAction> = <C-int>;
define constant $GDK-ACTION-DEFAULT = 1;
@@ -455,8 +711,17 @@
define constant <gshort> = <C-signed-short>;
-define C-subtype <_GdkEventDND> (<C-void*>) end;
-define constant <GdkEventDND> = <_GdkEventDND>;
+define C-struct <_GdkEventDND>
+ slot GdkEventDND-type :: <GdkEventType>;
+ slot GdkEventDND-window :: <GdkWindow>;
+ slot GdkEventDND-send-event :: <C-signed-char>;
+ slot GdkEventDND-context :: <GdkDragContext>;
+ slot GdkEventDND-time :: <C-unsigned-int>;
+ slot GdkEventDND-x-root :: <C-signed-short>;
+ slot GdkEventDND-y-root :: <C-signed-short>;
+end;
+
+define C-pointer-type <GdkEventDND> => <_GdkEventDND>;
define constant <GdkWindowState> = <C-int>;
define constant $GDK-WINDOW-STATE-WITHDRAWN = 1;
@@ -467,19 +732,41 @@
define constant $GDK-WINDOW-STATE-ABOVE = 32;
define constant $GDK-WINDOW-STATE-BELOW = 64;
-define C-subtype <_GdkEventWindowState> (<C-void*>) end;
-define constant <GdkEventWindowState> = <_GdkEventWindowState>;
+define C-struct <_GdkEventWindowState>
+ slot GdkEventWindowState-type :: <GdkEventType>;
+ slot GdkEventWindowState-window :: <GdkWindow>;
+ slot GdkEventWindowState-send-event :: <C-signed-char>;
+ slot GdkEventWindowState-changed-mask :: <GdkWindowState>;
+ slot GdkEventWindowState-new-window-state :: <GdkWindowState>;
+end;
+
+define C-pointer-type <GdkEventWindowState> => <_GdkEventWindowState>;
define constant <GdkSettingAction> = <C-int>;
define constant $GDK-SETTING-ACTION-NEW = 0;
define constant $GDK-SETTING-ACTION-CHANGED = 1;
define constant $GDK-SETTING-ACTION-DELETED = 2;
-define C-subtype <_GdkEventSetting> (<C-void*>) end;
-define constant <GdkEventSetting> = <_GdkEventSetting>;
+define C-struct <_GdkEventSetting>
+ slot GdkEventSetting-type :: <GdkEventType>;
+ slot GdkEventSetting-window :: <GdkWindow>;
+ slot GdkEventSetting-send-event :: <C-signed-char>;
+ slot GdkEventSetting-action :: <GdkSettingAction>;
+ slot GdkEventSetting-name :: <char*>;
+end;
+
+define C-pointer-type <GdkEventSetting> => <_GdkEventSetting>;
+
+define C-struct <_GdkEventGrabBroken>
+ slot GdkEventGrabBroken-type :: <GdkEventType>;
+ slot GdkEventGrabBroken-window :: <GdkWindow>;
+ slot GdkEventGrabBroken-send-event :: <C-signed-char>;
+ slot GdkEventGrabBroken-keyboard :: <C-signed-int>;
+ slot GdkEventGrabBroken-implicit :: <C-signed-int>;
+ slot GdkEventGrabBroken-grab-window :: <GdkWindow>;
+end;
-define C-subtype <_GdkEventGrabBroken> (<C-void*>) end;
-define constant <GdkEventGrabBroken> = <_GdkEventGrabBroken>;
+define C-pointer-type <GdkEventGrabBroken> => <_GdkEventGrabBroken>;
define C-subtype <_GdkEvent> (<C-void*>) end;
define constant <GdkEvent> = <_GdkEvent>;
@@ -523,14 +810,28 @@
define constant <anonymous-2573> = <C-function-pointer>;
define constant <anonymous-2574> = <C-function-pointer>;
define constant <anonymous-2575> = <C-function-pointer>;
-define C-subtype <_GdkDisplayPointerHooks> (<C-void*>) end;
-define constant <GdkDisplayPointerHooks> = <_GdkDisplayPointerHooks>;
+define C-struct <_GdkDisplayPointerHooks>
+ slot GdkDisplayPointerHooks-get-pointer :: <anonymous-2573>;
+ slot GdkDisplayPointerHooks-window-get-pointer :: <anonymous-2574>;
+ slot GdkDisplayPointerHooks-window-at-pointer :: <anonymous-2575>;
+end;
+
+define C-pointer-type <GdkDisplayPointerHooks> => <_GdkDisplayPointerHooks>;
define C-subtype <_GdkDisplay> (<_GObject>) end;
define constant <GdkDisplay> = <_GdkDisplay>;
-define C-subtype <_GtkSelectionData> (<C-void*>) end;
-define constant <GtkSelectionData> = <_GtkSelectionData>;
+define C-struct <_GtkSelectionData>
+ slot GtkSelectionData-selection :: <_GdkAtom>;
+ slot GtkSelectionData-target :: <_GdkAtom>;
+ slot GtkSelectionData-type :: <_GdkAtom>;
+ slot GtkSelectionData-format :: <C-signed-int>;
+ slot GtkSelectionData-data :: <guchar*>;
+ slot GtkSelectionData-length :: <C-signed-int>;
+ slot GtkSelectionData-display :: <GdkDisplay>;
+end;
+
+define C-pointer-type <GtkSelectionData> => <_GtkSelectionData>;
define constant <anonymous-3682> = <C-function-pointer>;
define constant <anonymous-3683> = <C-function-pointer>;
@@ -639,8 +940,12 @@
define constant $ATK-ROLE-INPUT-METHOD-WINDOW = 87;
define constant $ATK-ROLE-LAST-DEFINED = 88;
-define C-subtype <_GPtrArray> (<C-void*>) end;
-define constant <GPtrArray> = <_GPtrArray>;
+define C-struct <_GPtrArray>
+ slot GPtrArray-pdata :: <gpointer*>;
+ slot GPtrArray-len :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GPtrArray> => <_GPtrArray>;
define C-subtype <_AtkRelationSet> (<_GObject>) end;
define constant <AtkRelationSet> = <_AtkRelationSet>;
@@ -667,8 +972,82 @@
define constant <anonymous-3700> = <C-function-pointer>;
define constant <anonymous-3701> = <C-function-pointer>;
define constant <anonymous-3702> = <C-function-pointer>;
-define C-subtype <_GtkWidgetClass> (<C-void*>) end;
-define constant <GtkWidgetClass> = <_GtkWidgetClass>;
+define C-struct <_GtkWidgetClass>
+ slot GtkWidgetClass-parent-class :: <_GtkObjectClass>;
+ slot GtkWidgetClass-activate-signal :: <C-unsigned-int>;
+ slot GtkWidgetClass-set-scroll-adjustments-signal :: <C-unsigned-int>;
+ slot GtkWidgetClass-dispatch-child-properties-changed :: <anonymous-3634>;
+ slot GtkWidgetClass-show :: <anonymous-3635>;
+ slot GtkWidgetClass-show-all :: <anonymous-3636>;
+ slot GtkWidgetClass-hide :: <anonymous-3637>;
+ slot GtkWidgetClass-hide-all :: <anonymous-3638>;
+ slot GtkWidgetClass-map :: <anonymous-3639>;
+ slot GtkWidgetClass-unmap :: <anonymous-3640>;
+ slot GtkWidgetClass-realize :: <anonymous-3641>;
+ slot GtkWidgetClass-unrealize :: <anonymous-3642>;
+ slot GtkWidgetClass-size-request :: <anonymous-3643>;
+ slot GtkWidgetClass-size-allocate :: <anonymous-3644>;
+ slot GtkWidgetClass-state-changed :: <anonymous-3645>;
+ slot GtkWidgetClass-parent-set :: <anonymous-3646>;
+ slot GtkWidgetClass-hierarchy-changed :: <anonymous-3647>;
+ slot GtkWidgetClass-style-set :: <anonymous-3648>;
+ slot GtkWidgetClass-direction-changed :: <anonymous-3649>;
+ slot GtkWidgetClass-grab-notify :: <anonymous-3650>;
+ slot GtkWidgetClass-child-notify :: <anonymous-3651>;
+ slot GtkWidgetClass-mnemonic-activate :: <anonymous-3652>;
+ slot GtkWidgetClass-grab-focus :: <anonymous-3653>;
+ slot GtkWidgetClass-focus :: <anonymous-3654>;
+ slot GtkWidgetClass-event :: <anonymous-3655>;
+ slot GtkWidgetClass-button-press-event :: <anonymous-3656>;
+ slot GtkWidgetClass-button-release-event :: <anonymous-3657>;
+ slot GtkWidgetClass-scroll-event :: <anonymous-3658>;
+ slot GtkWidgetClass-motion-notify-event :: <anonymous-3659>;
+ slot GtkWidgetClass-delete-event :: <anonymous-3660>;
+ slot GtkWidgetClass-destroy-event :: <anonymous-3661>;
+ slot GtkWidgetClass-expose-event :: <anonymous-3662>;
+ slot GtkWidgetClass-key-press-event :: <anonymous-3663>;
+ slot GtkWidgetClass-key-release-event :: <anonymous-3664>;
+ slot GtkWidgetClass-enter-notify-event :: <anonymous-3665>;
+ slot GtkWidgetClass-leave-notify-event :: <anonymous-3666>;
+ slot GtkWidgetClass-configure-event :: <anonymous-3667>;
+ slot GtkWidgetClass-focus-in-event :: <anonymous-3668>;
+ slot GtkWidgetClass-focus-out-event :: <anonymous-3669>;
+ slot GtkWidgetClass-map-event :: <anonymous-3670>;
+ slot GtkWidgetClass-unmap-event :: <anonymous-3671>;
+ slot GtkWidgetClass-property-notify-event :: <anonymous-3672>;
+ slot GtkWidgetClass-selection-clear-event :: <anonymous-3673>;
+ slot GtkWidgetClass-selection-request-event :: <anonymous-3674>;
+ slot GtkWidgetClass-selection-notify-event :: <anonymous-3675>;
+ slot GtkWidgetClass-proximity-in-event :: <anonymous-3676>;
+ slot GtkWidgetClass-proximity-out-event :: <anonymous-3677>;
+ slot GtkWidgetClass-visibility-notify-event :: <anonymous-3678>;
+ slot GtkWidgetClass-client-event :: <anonymous-3679>;
+ slot GtkWidgetClass-no-expose-event :: <anonymous-3680>;
+ slot GtkWidgetClass-window-state-event :: <anonymous-3681>;
+ slot GtkWidgetClass-selection-get :: <anonymous-3682>;
+ slot GtkWidgetClass-selection-received :: <anonymous-3683>;
+ slot GtkWidgetClass-drag-begin :: <anonymous-3684>;
+ slot GtkWidgetClass-drag-end :: <anonymous-3685>;
+ slot GtkWidgetClass-drag-data-get :: <anonymous-3686>;
+ slot GtkWidgetClass-drag-data-delete :: <anonymous-3687>;
+ slot GtkWidgetClass-drag-leave :: <anonymous-3688>;
+ slot GtkWidgetClass-drag-motion :: <anonymous-3689>;
+ slot GtkWidgetClass-drag-drop :: <anonymous-3690>;
+ slot GtkWidgetClass-drag-data-received :: <anonymous-3691>;
+ slot GtkWidgetClass-popup-menu :: <anonymous-3692>;
+ slot GtkWidgetClass-show-help :: <anonymous-3693>;
+ slot GtkWidgetClass-get-accessible :: <anonymous-3694>;
+ slot GtkWidgetClass-screen-changed :: <anonymous-3695>;
+ slot GtkWidgetClass-can-activate-accel :: <anonymous-3696>;
+ slot GtkWidgetClass-grab-broken-event :: <anonymous-3697>;
+ slot GtkWidgetClass-composited-changed :: <anonymous-3698>;
+ slot GtkWidgetClass-_gtk-reserved4 :: <anonymous-3699>;
+ slot GtkWidgetClass-_gtk-reserved5 :: <anonymous-3700>;
+ slot GtkWidgetClass-_gtk-reserved6 :: <anonymous-3701>;
+ slot GtkWidgetClass-_gtk-reserved7 :: <anonymous-3702>;
+end;
+
+define C-pointer-type <GtkWidgetClass> => <_GtkWidgetClass>;
define constant <anonymous-3852> = <C-function-pointer>;
define constant <anonymous-3853> = <C-function-pointer>;
@@ -686,11 +1065,30 @@
define constant <anonymous-3862> = <C-function-pointer>;
define constant <anonymous-3863> = <C-function-pointer>;
define constant <anonymous-3864> = <C-function-pointer>;
-define C-subtype <_GtkContainerClass> (<C-void*>) end;
-define constant <GtkContainerClass> = <_GtkContainerClass>;
+define C-struct <_GtkContainerClass>
+ slot GtkContainerClass-parent-class :: <_GtkWidgetClass>;
+ slot GtkContainerClass-add :: <anonymous-3852>;
+ slot GtkContainerClass-remove :: <anonymous-3853>;
+ slot GtkContainerClass-check-resize :: <anonymous-3854>;
+ slot GtkContainerClass-forall :: <anonymous-3855>;
+ slot GtkContainerClass-set-focus-child :: <anonymous-3856>;
+ slot GtkContainerClass-child-type :: <anonymous-3857>;
+ slot GtkContainerClass-composite-name :: <anonymous-3858>;
+ slot GtkContainerClass-set-child-property :: <anonymous-3859>;
+ slot GtkContainerClass-get-child-property :: <anonymous-3860>;
+ slot GtkContainerClass-_gtk-reserved1 :: <anonymous-3861>;
+ slot GtkContainerClass-_gtk-reserved2 :: <anonymous-3862>;
+ slot GtkContainerClass-_gtk-reserved3 :: <anonymous-3863>;
+ slot GtkContainerClass-_gtk-reserved4 :: <anonymous-3864>;
+end;
+
+define C-pointer-type <GtkContainerClass> => <_GtkContainerClass>;
+
+define C-struct <_GtkBinClass>
+ slot GtkBinClass-parent-class :: <_GtkContainerClass>;
+end;
-define C-subtype <_GtkBinClass> (<C-void*>) end;
-define constant <GtkBinClass> = <_GtkBinClass>;
+define C-pointer-type <GtkBinClass> => <_GtkBinClass>;
define constant <anonymous-3926> = <C-function-pointer>;
define constant <anonymous-3927> = <C-function-pointer>;
@@ -702,17 +1100,37 @@
define constant <anonymous-3933> = <C-function-pointer>;
define constant <anonymous-3934> = <C-function-pointer>;
define constant <anonymous-3935> = <C-function-pointer>;
-define C-subtype <_GtkWindowClass> (<C-void*>) end;
-define constant <GtkWindowClass> = <_GtkWindowClass>;
+define C-struct <_GtkWindowClass>
+ slot GtkWindowClass-parent-class :: <_GtkBinClass>;
+ slot GtkWindowClass-set-focus :: <anonymous-3926>;
+ slot GtkWindowClass-frame-event :: <anonymous-3927>;
+ slot GtkWindowClass-activate-focus :: <anonymous-3928>;
+ slot GtkWindowClass-activate-default :: <anonymous-3929>;
+ slot GtkWindowClass-move-focus :: <anonymous-3930>;
+ slot GtkWindowClass-keys-changed :: <anonymous-3931>;
+ slot GtkWindowClass-_gtk-reserved1 :: <anonymous-3932>;
+ slot GtkWindowClass-_gtk-reserved2 :: <anonymous-3933>;
+ slot GtkWindowClass-_gtk-reserved3 :: <anonymous-3934>;
+ slot GtkWindowClass-_gtk-reserved4 :: <anonymous-3935>;
+end;
+
+define C-pointer-type <GtkWindowClass> => <_GtkWindowClass>;
-define constant <GObjectClass> = <_GObjectClass>;
+define C-pointer-type <GObjectClass> => <_GObjectClass>;
define constant <anonymous-3936> = <C-function-pointer>;
define constant <anonymous-3937> = <C-function-pointer>;
define constant <anonymous-3938> = <C-function-pointer>;
define constant <anonymous-3939> = <C-function-pointer>;
-define C-subtype <_GtkWindowGroupClass> (<C-void*>) end;
-define constant <GtkWindowGroupClass> = <_GtkWindowGroupClass>;
+define C-struct <_GtkWindowGroupClass>
+ slot GtkWindowGroupClass-parent-class :: <_GObjectClass>;
+ slot GtkWindowGroupClass-_gtk-reserved1 :: <anonymous-3936>;
+ slot GtkWindowGroupClass-_gtk-reserved2 :: <anonymous-3937>;
+ slot GtkWindowGroupClass-_gtk-reserved3 :: <anonymous-3938>;
+ slot GtkWindowGroupClass-_gtk-reserved4 :: <anonymous-3939>;
+end;
+
+define C-pointer-type <GtkWindowGroupClass> => <_GtkWindowGroupClass>;
define C-function gtk-window-get-type
result res :: <GType>;
@@ -760,23 +1178,52 @@
c-name: "gtk_window_get_role";
end;
-define C-subtype <_GtkAccelKey> (<C-void*>) end;
-define constant <GtkAccelKey> = <_GtkAccelKey>;
+define C-struct <_GtkAccelKey>
+ slot GtkAccelKey-accel-key :: <C-unsigned-int>;
+ slot GtkAccelKey-accel-mods :: <GdkModifierType>;
+ bitfield slot GtkAccelKey-accel-flags :: <C-int>, width: 16;
+end;
+
+define C-pointer-type <GtkAccelKey> => <_GtkAccelKey>;
define constant <anonymous-1573> = <C-function-pointer>;
define constant <anonymous-1561> = <C-function-pointer>;
define constant <GClosureNotify> = <anonymous-1561>;
-define C-subtype <_GClosureNotifyData> (<C-void*>) end;
-define constant <GClosureNotifyData> = <_GClosureNotifyData>;
+define C-struct <_GClosureNotifyData>
+ slot GClosureNotifyData-data :: <C-void*>;
+ slot GClosureNotifyData-notify :: <anonymous-1561>;
+end;
+
+define C-pointer-type <GClosureNotifyData> => <_GClosureNotifyData>;
+
+define C-struct <_GClosure>
+ bitfield slot GClosure-ref-count :: <C-int>, width: 15;
+ bitfield slot GClosure-meta-marshal :: <C-int>, width: 1;
+ bitfield slot GClosure-n-guards :: <C-int>, width: 1;
+ bitfield slot GClosure-n-fnotifiers :: <C-int>, width: 2;
+ bitfield slot GClosure-n-inotifiers :: <C-int>, width: 8;
+ bitfield slot GClosure-in-inotify :: <C-int>, width: 1;
+ bitfield slot GClosure-floating :: <C-int>, width: 1;
+ bitfield slot GClosure-derivative-flag :: <C-int>, width: 1;
+ bitfield slot GClosure-in-marshal :: <C-int>, width: 1;
+ bitfield slot GClosure-is-invalid :: <C-int>, width: 1;
+ slot GClosure-marshal :: <anonymous-1573>;
+ slot GClosure-data :: <C-void*>;
+ slot GClosure-notifiers :: <GClosureNotifyData>;
+end;
-define C-subtype <_GClosure> (<C-void*>) end;
-define constant <GClosure> = <_GClosure>;
+define C-pointer-type <GClosure> => <_GClosure>;
define constant <GQuark> = <guint32>;
-define C-subtype <_GtkAccelGroupEntry> (<C-void*>) end;
-define constant <GtkAccelGroupEntry> = <_GtkAccelGroupEntry>;
+define C-struct <_GtkAccelGroupEntry>
+ slot GtkAccelGroupEntry-key :: <_GtkAccelKey>;
+ slot GtkAccelGroupEntry-closure :: <GClosure>;
+ slot GtkAccelGroupEntry-accel-path-quark :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GtkAccelGroupEntry> => <_GtkAccelGroupEntry>;
define C-subtype <_GtkAccelGroup> (<_GObject>) end;
define constant <GtkAccelGroup> = <_GtkAccelGroup>;
@@ -984,8 +1431,21 @@
c-name: "gtk_window_get_gravity";
end;
-define C-subtype <_GdkGeometry> (<C-void*>) end;
-define constant <GdkGeometry> = <_GdkGeometry>;
+define C-struct <_GdkGeometry>
+ slot GdkGeometry-min-width :: <C-signed-int>;
+ slot GdkGeometry-min-height :: <C-signed-int>;
+ slot GdkGeometry-max-width :: <C-signed-int>;
+ slot GdkGeometry-max-height :: <C-signed-int>;
+ slot GdkGeometry-base-width :: <C-signed-int>;
+ slot GdkGeometry-base-height :: <C-signed-int>;
+ slot GdkGeometry-width-inc :: <C-signed-int>;
+ slot GdkGeometry-height-inc :: <C-signed-int>;
+ slot GdkGeometry-min-aspect :: <C-double>;
+ slot GdkGeometry-max-aspect :: <C-double>;
+ slot GdkGeometry-win-gravity :: <GdkGravity>;
+end;
+
+define C-pointer-type <GdkGeometry> => <_GdkGeometry>;
define constant <GdkWindowHints> = <C-int>;
define constant $GDK-HINT-POS = 1;
@@ -1111,8 +1571,13 @@
c-name: "gtk_window_set_icon_name";
end;
-define C-subtype <_GError> (<C-void*>) end;
-define constant <GError> = <_GError>;
+define C-struct <_GError>
+ slot GError-domain :: <C-unsigned-int>;
+ slot GError-code :: <C-signed-int>;
+ slot GError-message :: <gchar*>;
+end;
+
+define C-pointer-type <GError> => <_GError>;
define C-pointer-type <GError*> => <GError>;
define C-function gtk-window-set-icon-from-file-utf8
@@ -1456,13 +1921,26 @@
define constant $GTK-DOUBLE-BUFFERED = 2097152;
define constant $GTK-NO-SHOW-ALL = 4194304;
-define C-subtype <_GtkWidgetAuxInfo> (<C-void*>) end;
-define constant <GtkWidgetAuxInfo> = <_GtkWidgetAuxInfo>;
+define C-struct <_GtkWidgetAuxInfo>
+ slot GtkWidgetAuxInfo-x :: <C-signed-int>;
+ slot GtkWidgetAuxInfo-y :: <C-signed-int>;
+ slot GtkWidgetAuxInfo-width :: <C-signed-int>;
+ slot GtkWidgetAuxInfo-height :: <C-signed-int>;
+ bitfield slot GtkWidgetAuxInfo-x-set :: <C-int>, width: 1;
+ bitfield slot GtkWidgetAuxInfo-y-set :: <C-int>, width: 1;
+end;
+
+define C-pointer-type <GtkWidgetAuxInfo> => <_GtkWidgetAuxInfo>;
define constant <GdkBitmap> = <_GdkDrawable>;
-define C-subtype <_GtkWidgetShapeInfo> (<C-void*>) end;
-define constant <GtkWidgetShapeInfo> = <_GtkWidgetShapeInfo>;
+define C-struct <_GtkWidgetShapeInfo>
+ slot GtkWidgetShapeInfo-offset-x :: <C-signed-short>;
+ slot GtkWidgetShapeInfo-offset-y :: <C-signed-short>;
+ slot GtkWidgetShapeInfo-shape-mask :: <GdkBitmap>;
+end;
+
+define C-pointer-type <GtkWidgetShapeInfo> => <_GtkWidgetShapeInfo>;
define C-subtype <_GtkClipboard> (<_GObject>) end;
define constant <GtkClipboard> = <_GtkClipboard>;
@@ -1958,11 +2436,15 @@
c-name: "gtk_widget_get_root_window";
end;
-define C-subtype <_GtkSettingsPropertyValue> (<C-void*>) end;
-define constant <GtkSettingsPropertyValue> = <_GtkSettingsPropertyValue>;
+define C-struct <_GtkSettingsPropertyValue>
+end;
+
+define C-pointer-type <GtkSettingsPropertyValue> => <_GtkSettingsPropertyValue>;
+
+define C-struct <_GtkRcContext>
+end;
-define C-subtype <_GtkRcContext> (<C-void*>) end;
-define constant <GtkRcContext> = <_GtkRcContext>;
+define C-pointer-type <GtkRcContext> => <_GtkRcContext>;
define C-subtype <_GtkSettings> (<_GObject>) end;
define constant <GtkSettings> = <_GtkSettings>;
@@ -2177,8 +2659,13 @@
define constant <gsize> = <C-unsigned-int>;
-define C-subtype <_GString> (<C-void*>) end;
-define constant <GString> = <_GString>;
+define C-struct <_GString>
+ slot GString-str :: <gchar*>;
+ slot GString-len :: <C-unsigned-int>;
+ slot GString-allocated-len :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GString> => <_GString>;
define constant <anonymous-3397> = <C-function-pointer>;
define constant <GtkRcPropertyParser> = <anonymous-3397>;
@@ -2354,14 +2841,24 @@
define constant <AtkAttributeSet> = <GSList>;
-define C-subtype <_AtkAttribute> (<C-void*>) end;
-define constant <AtkAttribute> = <_AtkAttribute>;
+define C-struct <_AtkAttribute>
+ slot AtkAttribute-name :: <gchar*>;
+ slot AtkAttribute-value :: <gchar*>;
+end;
+
+define C-pointer-type <AtkAttribute> => <_AtkAttribute>;
+
+define C-struct <_AtkImplementor>
+end;
+
+define C-pointer-type <AtkImplementor> => <_AtkImplementor>;
-define C-subtype <_AtkImplementor> (<C-void*>) end;
-define constant <AtkImplementor> = <_AtkImplementor>;
+define C-struct <_GTypeInterface>
+ slot GTypeInterface-g-type :: <C-unsigned-long>;
+ slot GTypeInterface-g-instance-type :: <C-unsigned-long>;
+end;
-define C-subtype <_GTypeInterface> (<C-void*>) end;
-define constant <GTypeInterface> = <_GTypeInterface>;
+define C-pointer-type <GTypeInterface> => <_GTypeInterface>;
define constant <anonymous-3603> = <C-function-pointer>;
define C-subtype <_AtkImplementorIface> (<C-void*>) end;
@@ -2385,8 +2882,13 @@
define constant <anonymous-3589> = <C-function-pointer>;
define constant <anonymous-3590> = <C-function-pointer>;
define constant <anonymous-3591> = <C-function-pointer>;
-define C-subtype <_AtkPropertyValues> (<C-void*>) end;
-define constant <AtkPropertyValues> = <_AtkPropertyValues>;
+define C-struct <_AtkPropertyValues>
+ slot AtkPropertyValues-property-name :: <gchar*>;
+ slot AtkPropertyValues-old-value :: <_GValue>;
+ slot AtkPropertyValues-new-value :: <_GValue>;
+end;
+
+define C-pointer-type <AtkPropertyValues> => <_AtkPropertyValues>;
define constant <anonymous-3576> = <C-function-pointer>;
define constant <AtkPropertyChangeHandler> = <anonymous-3576>;
@@ -2405,8 +2907,38 @@
define constant <anonymous-3575> = <C-function-pointer>;
define constant <AtkFunction> = <anonymous-3575>;
-define C-subtype <_AtkObjectClass> (<C-void*>) end;
-define constant <AtkObjectClass> = <_AtkObjectClass>;
+define C-struct <_AtkObjectClass>
+ slot AtkObjectClass-parent :: <_GObjectClass>;
+ slot AtkObjectClass-get-name :: <anonymous-3577>;
+ slot AtkObjectClass-get-description :: <anonymous-3578>;
+ slot AtkObjectClass-get-parent :: <anonymous-3579>;
+ slot AtkObjectClass-get-n-children :: <anonymous-3580>;
+ slot AtkObjectClass-ref-child :: <anonymous-3581>;
+ slot AtkObjectClass-get-index-in-parent :: <anonymous-3582>;
+ slot AtkObjectClass-ref-relation-set :: <anonymous-3583>;
+ slot AtkObjectClass-get-role :: <anonymous-3584>;
+ slot AtkObjectClass-get-layer :: <anonymous-3585>;
+ slot AtkObjectClass-get-mdi-zorder :: <anonymous-3586>;
+ slot AtkObjectClass-ref-state-set :: <anonymous-3587>;
+ slot AtkObjectClass-set-name :: <anonymous-3588>;
+ slot AtkObjectClass-set-description :: <anonymous-3589>;
+ slot AtkObjectClass-set-parent :: <anonymous-3590>;
+ slot AtkObjectClass-set-role :: <anonymous-3591>;
+ slot AtkObjectClass-connect-property-change-handler :: <anonymous-3592>;
+ slot AtkObjectClass-remove-property-change-handler :: <anonymous-3593>;
+ slot AtkObjectClass-initialize :: <anonymous-3594>;
+ slot AtkObjectClass-children-changed :: <anonymous-3595>;
+ slot AtkObjectClass-focus-event :: <anonymous-3596>;
+ slot AtkObjectClass-property-change :: <anonymous-3597>;
+ slot AtkObjectClass-state-change :: <anonymous-3598>;
+ slot AtkObjectClass-visible-data-changed :: <anonymous-3599>;
+ slot AtkObjectClass-active-descendant-changed :: <anonymous-3600>;
+ slot AtkObjectClass-get-attributes :: <anonymous-3601>;
+ slot AtkObjectClass-pad1 :: <anonymous-3575>;
+ slot AtkObjectClass-pad2 :: <anonymous-3575>;
+end;
+
+define C-pointer-type <AtkObjectClass> => <_AtkObjectClass>;
define C-function atk-object-get-type
result res :: <GType>;
@@ -2951,8 +3483,10 @@
define C-subtype <_GTypeCValue> (<C-void*>) end;
define constant <GTypeCValue> = <_GTypeCValue>;
-define C-subtype <_GTypePlugin> (<C-void*>) end;
-define constant <GTypePlugin> = <_GTypePlugin>;
+define C-struct <_GTypePlugin>
+end;
+
+define C-pointer-type <GTypePlugin> => <_GTypePlugin>;
define constant <anonymous-1415> = <C-function-pointer>;
define constant <GBaseInitFunc> = <anonymous-1415>;
@@ -2977,11 +3511,33 @@
define constant <anonymous-1429> = <C-function-pointer>;
define constant <anonymous-1430> = <C-function-pointer>;
define constant <anonymous-1431> = <C-function-pointer>;
-define C-subtype <_GTypeValueTable> (<C-void*>) end;
-define constant <GTypeValueTable> = <_GTypeValueTable>;
+define C-struct <_GTypeValueTable>
+ slot GTypeValueTable-value-init :: <anonymous-1426>;
+ slot GTypeValueTable-value-free :: <anonymous-1427>;
+ slot GTypeValueTable-value-copy :: <anonymous-1428>;
+ slot GTypeValueTable-value-peek-pointer :: <anonymous-1429>;
+ slot GTypeValueTable-collect-format :: <gchar*>;
+ slot GTypeValueTable-collect-value :: <anonymous-1430>;
+ slot GTypeValueTable-lcopy-format :: <gchar*>;
+ slot GTypeValueTable-lcopy-value :: <anonymous-1431>;
+end;
+
+define C-pointer-type <GTypeValueTable> => <_GTypeValueTable>;
+
+define C-struct <_GTypeInfo>
+ slot GTypeInfo-class-size :: <C-unsigned-short>;
+ slot GTypeInfo-base-init :: <anonymous-1415>;
+ slot GTypeInfo-base-finalize :: <anonymous-1416>;
+ slot GTypeInfo-class-init :: <anonymous-1417>;
+ slot GTypeInfo-class-finalize :: <anonymous-1418>;
+ slot GTypeInfo-class-data :: <C-void*>;
+ slot GTypeInfo-instance-size :: <C-unsigned-short>;
+ slot GTypeInfo-n-preallocs :: <C-unsigned-short>;
+ slot GTypeInfo-instance-init :: <anonymous-1419>;
+ slot GTypeInfo-value-table :: <GTypeValueTable>;
+end;
-define C-subtype <_GTypeInfo> (<C-void*>) end;
-define constant <GTypeInfo> = <_GTypeInfo>;
+define C-pointer-type <GTypeInfo> => <_GTypeInfo>;
define constant <GTypeFundamentalFlags> = <C-int>;
define constant $G-TYPE-FLAG-CLASSED = 1;
@@ -2989,8 +3545,11 @@
define constant $G-TYPE-FLAG-DERIVABLE = 4;
define constant $G-TYPE-FLAG-DEEP-DERIVABLE = 8;
-define C-subtype <_GTypeFundamentalInfo> (<C-void*>) end;
-define constant <GTypeFundamentalInfo> = <_GTypeFundamentalInfo>;
+define C-struct <_GTypeFundamentalInfo>
+ slot GTypeFundamentalInfo-type-flags :: <GTypeFundamentalFlags>;
+end;
+
+define C-pointer-type <GTypeFundamentalInfo> => <_GTypeFundamentalInfo>;
define constant <anonymous-1420> = <C-function-pointer>;
define constant <GInterfaceInitFunc> = <anonymous-1420>;
@@ -2998,11 +3557,22 @@
define constant <anonymous-1421> = <C-function-pointer>;
define constant <GInterfaceFinalizeFunc> = <anonymous-1421>;
-define C-subtype <_GInterfaceInfo> (<C-void*>) end;
-define constant <GInterfaceInfo> = <_GInterfaceInfo>;
+define C-struct <_GInterfaceInfo>
+ slot GInterfaceInfo-interface-init :: <anonymous-1420>;
+ slot GInterfaceInfo-interface-finalize :: <anonymous-1421>;
+ slot GInterfaceInfo-interface-data :: <C-void*>;
+end;
+
+define C-pointer-type <GInterfaceInfo> => <_GInterfaceInfo>;
-define C-subtype <_GTypeQuery> (<C-void*>) end;
-define constant <GTypeQuery> = <_GTypeQuery>;
+define C-struct <_GTypeQuery>
+ slot GTypeQuery-type :: <C-unsigned-long>;
+ slot GTypeQuery-type-name :: <gchar*>;
+ slot GTypeQuery-class-size :: <C-unsigned-int>;
+ slot GTypeQuery-instance-size :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GTypeQuery> => <_GTypeQuery>;
define constant <GTypeDebugFlags> = <C-int>;
define constant $G-TYPE-DEBUG-NONE = 0;
@@ -3525,16 +4095,31 @@
define constant <anonymous-217> = <C-function-pointer>;
define constant <GTranslateFunc> = <anonymous-217>;
-define C-subtype <anonymous-226> (<C-void*>) end;
+define C-struct <anonymous-226>
+ bitfield slot nonymous-226-mantissa-low :: <C-int>, width: 32;
+ bitfield slot nonymous-226-mantissa-high :: <C-int>, width: 20;
+ bitfield slot nonymous-226-biased-exponent :: <C-int>, width: 11;
+ bitfield slot nonymous-226-sign :: <C-int>, width: 1;
+end;
+
define C-subtype <_GDoubleIEEE754> (<C-void*>) end;
define constant <GDoubleIEEE754> = <_GDoubleIEEE754>;
-define C-subtype <anonymous-221> (<C-void*>) end;
+define C-struct <anonymous-221>
+ bitfield slot nonymous-221-mantissa :: <C-int>, width: 23;
+ bitfield slot nonymous-221-biased-exponent :: <C-int>, width: 8;
+ bitfield slot nonymous-221-sign :: <C-int>, width: 1;
+end;
+
define C-subtype <_GFloatIEEE754> (<C-void*>) end;
define constant <GFloatIEEE754> = <_GFloatIEEE754>;
-define C-subtype <_GTimeVal> (<C-void*>) end;
-define constant <GTimeVal> = <_GTimeVal>;
+define C-struct <_GTimeVal>
+ slot GTimeVal-tv-sec :: <C-signed-long>;
+ slot GTimeVal-tv-usec :: <C-signed-long>;
+end;
+
+define C-pointer-type <GTimeVal> => <_GTimeVal>;
define constant $G-MAXUINT8 = 255;
@@ -3558,7 +4143,9 @@
define constant <gssize> = <C-signed-int>;
-define C-subtype <_GMutex> (<C-void*>) end;
+define C-struct <_GMutex>
+end;
+
define constant <GStaticMutex> = <_GMutex>;
define constant <char<@4>> = <char*>;
@@ -3970,8 +4557,12 @@
c-name: "g_get_language_names";
end;
-define C-subtype <_GDebugKey> (<C-void*>) end;
-define constant <GDebugKey> = <_GDebugKey>;
+define C-struct <_GDebugKey>
+ slot GDebugKey-key :: <gchar*>;
+ slot GDebugKey-value :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GDebugKey> => <_GDebugKey>;
define C-function g-parse-debug-string
input parameter arg1 :: <gchar*>;
@@ -4096,9 +4687,12 @@
c-name: "g_bit_storage";
end;
-define constant <GTrashStack> = <_GTrashStack>;
+define C-pointer-type <GTrashStack> => <_GTrashStack>;
+
+define C-struct <_GTrashStack>
+ slot GTrashStack-next :: <GTrashStack>;
+end;
-define C-subtype <_GTrashStack> (<C-void*>) end;
define C-pointer-type <GTrashStack*> => <GTrashStack>;
define C-function g-trash-stack-push
input parameter arg1 :: <GTrashStack*>;
@@ -4727,8 +5321,10 @@
c-name: "g_intern_static_string";
end;
-define C-subtype <_GTree> (<C-void*>) end;
-define constant <GTree> = <_GTree>;
+define C-struct <_GTree>
+end;
+
+define C-pointer-type <GTree> => <_GTree>;
define constant <anonymous-1357> = <C-function-pointer>;
define constant <GTraverseFunc> = <anonymous-1357>;
@@ -4845,9 +5441,16 @@
c-name: "g_tree_nnodes";
end;
-define constant <GNode> = <_GNode>;
+define C-pointer-type <GNode> => <_GNode>;
+
+define C-struct <_GNode>
+ slot GNode-data :: <C-void*>;
+ slot GNode-next :: <GNode>;
+ slot GNode-prev :: <GNode>;
+ slot GNode-parent :: <GNode>;
+ slot GNode-children :: <GNode>;
+end;
-define C-subtype <_GNode> (<C-void*>) end;
define constant <GTraverseFlags> = <C-int>;
define constant $G-TRAVERSE-LEAVES = 1;
define constant $G-TRAVERSE-NON-LEAVES = 2;
@@ -5058,8 +5661,16 @@
define constant <anonymous-456> = <C-function-pointer>;
define constant <anonymous-457> = <C-function-pointer>;
define constant <anonymous-458> = <C-function-pointer>;
-define C-subtype <_GMemVTable> (<C-void*>) end;
-define constant <GMemVTable> = <_GMemVTable>;
+define C-struct <_GMemVTable>
+ slot GMemVTable-malloc :: <anonymous-453>;
+ slot GMemVTable-realloc :: <anonymous-454>;
+ slot GMemVTable-free :: <anonymous-455>;
+ slot GMemVTable-calloc :: <anonymous-456>;
+ slot GMemVTable-try-malloc :: <anonymous-457>;
+ slot GMemVTable-try-realloc :: <anonymous-458>;
+end;
+
+define C-pointer-type <GMemVTable> => <_GMemVTable>;
define C-function g-malloc
input parameter arg1 :: <gulong>;
@@ -5120,11 +5731,15 @@
c-name: "g_mem_profile";
end;
-define C-subtype <_GAllocator> (<C-void*>) end;
-define constant <GAllocator> = <_GAllocator>;
+define C-struct <_GAllocator>
+end;
+
+define C-pointer-type <GAllocator> => <_GAllocator>;
+
+define C-struct <_GMemChunk>
+end;
-define C-subtype <_GMemChunk> (<C-void*>) end;
-define constant <GMemChunk> = <_GMemChunk>;
+define C-pointer-type <GMemChunk> => <_GMemChunk>;
define C-function g-mem-chunk-new
input parameter arg1 :: <gchar*>;
@@ -5259,8 +5874,10 @@
c-name: "g_slice_get_config_state";
end;
-define C-subtype <_GTimer> (<C-void*>) end;
-define constant <GTimer> = <_GTimer>;
+define C-struct <_GTimer>
+end;
+
+define C-pointer-type <GTimer> => <_GTimer>;
define C-function g-timer-new
result res :: <GTimer>;
@@ -5326,8 +5943,13 @@
define constant $G-USEC-PER-SEC = 1000000;
-define C-subtype <_GThreadPool> (<C-void*>) end;
-define constant <GThreadPool> = <_GThreadPool>;
+define C-struct <_GThreadPool>
+ slot GThreadPool-func :: <anonymous-213>;
+ slot GThreadPool-user-data :: <C-void*>;
+ slot GThreadPool-exclusive :: <C-signed-int>;
+end;
+
+define C-pointer-type <GThreadPool> => <_GThreadPool>;
define C-function g-thread-pool-new
input parameter arg1 :: <GFunc>;
@@ -5431,19 +6053,32 @@
define constant $G-THREAD-PRIORITY-HIGH = 2;
define constant $G-THREAD-PRIORITY-URGENT = 3;
-define C-subtype <_GThread> (<C-void*>) end;
-define constant <GThread> = <_GThread>;
+define C-struct <_GThread>
+ slot GThread-func :: <anonymous-291>;
+ slot GThread-data :: <C-void*>;
+ slot GThread-joinable :: <C-signed-int>;
+ slot GThread-priority :: <GThreadPriority>;
+end;
+
+define C-pointer-type <GThread> => <_GThread>;
+
+define C-pointer-type <GMutex> => <_GMutex>;
+
+define C-struct <_GCond>
+end;
+
+define C-pointer-type <GCond> => <_GCond>;
-define constant <GMutex> = <_GMutex>;
+define C-struct <_GPrivate>
+end;
-define C-subtype <_GCond> (<C-void*>) end;
-define constant <GCond> = <_GCond>;
+define C-pointer-type <GPrivate> => <_GPrivate>;
-define C-subtype <_GPrivate> (<C-void*>) end;
-define constant <GPrivate> = <_GPrivate>;
+define C-struct <_GStaticPrivate>
+ slot GStaticPrivate-index :: <C-unsigned-int>;
+end;
-define C-subtype <_GStaticPrivate> (<C-void*>) end;
-define constant <GStaticPrivate> = <_GStaticPrivate>;
+define C-pointer-type <GStaticPrivate> => <_GStaticPrivate>;
define constant <anonymous-293> = <C-function-pointer>;
define constant <anonymous-294> = <C-function-pointer>;
@@ -5466,8 +6101,31 @@
define constant <anonymous-311> = <C-function-pointer>;
define constant <anonymous-312> = <C-function-pointer>;
define constant <anonymous-313> = <C-function-pointer>;
-define C-subtype <_GThreadFunctions> (<C-void*>) end;
-define constant <GThreadFunctions> = <_GThreadFunctions>;
+define C-struct <_GThreadFunctions>
+ slot GThreadFunctions-mutex-new :: <anonymous-293>;
+ slot GThreadFunctions-mutex-lock :: <anonymous-294>;
+ slot GThreadFunctions-mutex-trylock :: <anonymous-295>;
+ slot GThreadFunctions-mutex-unlock :: <anonymous-296>;
+ slot GThreadFunctions-mutex-free :: <anonymous-297>;
+ slot GThreadFunctions-cond-new :: <anonymous-298>;
+ slot GThreadFunctions-cond-signal :: <anonymous-299>;
+ slot GThreadFunctions-cond-broadcast :: <anonymous-300>;
+ slot GThreadFunctions-cond-wait :: <anonymous-301>;
+ slot GThreadFunctions-cond-timed-wait :: <anonymous-302>;
+ slot GThreadFunctions-cond-free :: <anonymous-303>;
+ slot GThreadFunctions-private-new :: <anonymous-304>;
+ slot GThreadFunctions-private-get :: <anonymous-305>;
+ slot GThreadFunctions-private-set :: <anonymous-306>;
+ slot GThreadFunctions-thread-create :: <anonymous-307>;
+ slot GThreadFunctions-thread-yield :: <anonymous-308>;
+ slot GThreadFunctions-thread-join :: <anonymous-309>;
+ slot GThreadFunctions-thread-exit :: <anonymous-310>;
+ slot GThreadFunctions-thread-set-priority :: <anonymous-311>;
+ slot GThreadFunctions-thread-self :: <anonymous-312>;
+ slot GThreadFunctions-thread-equal :: <anonymous-313>;
+end;
+
+define C-pointer-type <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"*/
@@ -5549,8 +6207,13 @@
c-name: "g_static_private_free";
end;
-define C-subtype <_GStaticRecMutex> (<C-void*>) end;
-define constant <GStaticRecMutex> = <_GStaticRecMutex>;
+define C-struct <_GStaticRecMutex>
+ slot GStaticRecMutex-mutex :: <_GMutex>;
+ slot GStaticRecMutex-depth :: <C-unsigned-int>;
+ slot GStaticRecMutex-owner :: <_GSystemThread>;
+end;
+
+define C-pointer-type <GStaticRecMutex> => <_GStaticRecMutex>;
define C-function g-static-rec-mutex-init
input parameter arg1 :: <GStaticRecMutex>;
@@ -5590,8 +6253,17 @@
c-name: "g_static_rec_mutex_free";
end;
-define C-subtype <_GStaticRWLock> (<C-void*>) end;
-define constant <GStaticRWLock> = <_GStaticRWLock>;
+define C-struct <_GStaticRWLock>
+ slot GStaticRWLock-mutex :: <_GMutex>;
+ slot GStaticRWLock-read-cond :: <GCond>;
+ slot GStaticRWLock-write-cond :: <GCond>;
+ slot GStaticRWLock-read-counter :: <C-unsigned-int>;
+ slot GStaticRWLock-have-writer :: <C-signed-int>;
+ slot GStaticRWLock-want-to-read :: <C-unsigned-int>;
+ slot GStaticRWLock-want-to-write :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GStaticRWLock> => <_GStaticRWLock>;
define C-function g-static-rw-lock-init
input parameter arg1 :: <GStaticRWLock>;
@@ -5646,8 +6318,12 @@
define constant $G-ONCE-STATUS-PROGRESS = 1;
define constant $G-ONCE-STATUS-READY = 2;
-define C-subtype <_GOnce> (<C-void*>) end;
-define constant <GOnce> = <_GOnce>;
+define C-struct <_GOnce>
+ slot GOnce-status :: <GOnceStatus>;
+ slot GOnce-retval :: <C-void*>;
+end;
+
+define C-pointer-type <GOnce> => <_GOnce>;
define C-function g-once-impl
input parameter arg1 :: <GOnce>;
@@ -5712,8 +6388,10 @@
c-name: "g_atomic_pointer_set";
end;
-define C-subtype <_GStringChunk> (<C-void*>) end;
-define constant <GStringChunk> = <_GStringChunk>;
+define C-struct <_GStringChunk>
+end;
+
+define C-pointer-type <GStringChunk> => <_GStringChunk>;
define C-function g-string-chunk-new
input parameter arg1 :: <gsize>;
@@ -6657,8 +7335,37 @@
c-name: "g_shell_parse_argv";
end;
-define C-subtype <_GScannerConfig> (<C-void*>) end;
-define constant <GScannerConfig> = <_GScannerConfig>;
+define C-struct <_GScannerConfig>
+ slot GScannerConfig-cset-skip-characters :: <gchar*>;
+ slot GScannerConfig-cset-identifier-first :: <gchar*>;
+ slot GScannerConfig-cset-identifier-nth :: <gchar*>;
+ slot GScannerConfig-cpair-comment-single :: <gchar*>;
+ bitfield slot GScannerConfig-case-sensitive :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-skip-comment-multi :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-skip-comment-single :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-comment-multi :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-identifier :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-identifier-1char :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-identifier-NULL :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-symbols :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-binary :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-octal :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-float :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-hex :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-hex-dollar :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-string-sq :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scan-string-dq :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-numbers-2-int :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-int-2-float :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-identifier-2-string :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-char-2-token :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-symbol-2-token :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-scope-0-fallback :: <C-int>, width: 1;
+ bitfield slot GScannerConfig-store-int64 :: <C-int>, width: 1;
+ slot GScannerConfig-padding-dummy :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GScannerConfig> => <_GScannerConfig>;
define constant <GTokenType> = <C-int>;
define constant $G-TOKEN-EOF = 0;
@@ -6689,15 +7396,40 @@
define C-subtype <_GTokenValue> (<C-void*>) end;
define constant <GTokenValue> = <_GTokenValue>;
-define C-subtype <_GHashTable> (<C-void*>) end;
-define constant <GHashTable> = <_GHashTable>;
+define C-struct <_GHashTable>
+end;
+
+define C-pointer-type <GHashTable> => <_GHashTable>;
-define constant <GScanner> = <_GScanner>;
+define C-pointer-type <GScanner> => <_GScanner>;
define constant <anonymous-1220> = <C-function-pointer>;
define constant <GScannerMsgFunc> = <anonymous-1220>;
-define C-subtype <_GScanner> (<C-void*>) end;
+define C-struct <_GScanner>
+ slot GScanner-user-data :: <C-void*>;
+ slot GScanner-max-parse-errors :: <C-unsigned-int>;
+ slot GScanner-parse-errors :: <C-unsigned-int>;
+ slot GScanner-input-name :: <gchar*>;
+ slot GScanner-qdata :: <GData>;
+ slot GScanner-config :: <GScannerConfig>;
+ slot GScanner-token :: <GTokenType>;
+ slot GScanner-value :: <_GTokenValue>;
+ slot GScanner-line :: <C-unsigned-int>;
+ slot GScanner-position :: <C-unsigned-int>;
+ slot GScanner-next-token :: <GTokenType>;
+ slot GScanner-next-value :: <_GTokenValue>;
+ slot GScanner-next-line :: <C-unsigned-int>;
+ slot GScanner-next-position :: <C-unsigned-int>;
+ slot GScanner-symbol-table :: <GHashTable>;
+ slot GScanner-input-fd :: <C-signed-int>;
+ slot GScanner-text :: <gchar*>;
+ slot GScanner-text-end :: <gchar*>;
+ slot GScanner-buffer :: <gchar*>;
+ slot GScanner-scope-id :: <C-unsigned-int>;
+ slot GScanner-msg-handler :: <anonymous-1220>;
+end;
+
define constant <GErrorType> = <C-int>;
define constant $G-ERR-UNKNOWN = 0;
define constant $G-ERR-UNEXP-EOF = 1;
@@ -7107,11 +7839,16 @@
define constant $G-DATALIST-FLAGS-MASK = 3;
-define C-subtype <_GRelation> (<C-void*>) end;
-define constant <GRelation> = <_GRelation>;
+define C-struct <_GRelation>
+end;
+
+define C-pointer-type <GRelation> => <_GRelation>;
+
+define C-struct <_GTuples>
+ slot GTuples-len :: <C-unsigned-int>;
+end;
-define C-subtype <_GTuples> (<C-void*>) end;
-define constant <GTuples> = <_GTuples>;
+define C-pointer-type <GTuples> => <_GTuples>;
define C-function g-relation-new
input parameter arg1 :: <gint>;
@@ -7185,8 +7922,10 @@
c-name: "g_tuples_index";
end;
-define C-subtype <_GRand> (<C-void*>) end;
-define constant <GRand> = <_GRand>;
+define C-struct <_GRand>
+end;
+
+define C-pointer-type <GRand> => <_GRand>;
define C-function g-rand-new-with-seed
input parameter arg1 :: <guint32>;
@@ -7287,8 +8026,13 @@
c-name: "g_random_double_range";
end;
-define C-subtype <_GQueue> (<C-void*>) end;
-define constant <GQueue> = <_GQueue>;
+define C-struct <_GQueue>
+ slot GQueue-head :: <GList>;
+ slot GQueue-tail :: <GList>;
+ slot GQueue-length :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GQueue> => <_GQueue>;
define C-function g-queue-new
result res :: <GQueue>;
@@ -7751,8 +8495,10 @@
c-name: "g_spaced_primes_closest";
end;
-define C-subtype <_GPatternSpec> (<C-void*>) end;
-define constant <GPatternSpec> = <_GPatternSpec>;
+define C-struct <_GPatternSpec>
+end;
+
+define C-pointer-type <GPatternSpec> => <_GPatternSpec>;
define C-function g-pattern-spec-new
input parameter arg1 :: <gchar*>;
@@ -7795,11 +8541,15 @@
c-name: "g_pattern_match_simple";
end;
-define C-subtype <_GOptionContext> (<C-void*>) end;
-define constant <GOptionContext> = <_GOptionContext>;
+define C-struct <_GOptionContext>
+end;
+
+define C-pointer-type <GOptionContext> => <_GOptionContext>;
-define C-subtype <_GOptionGroup> (<C-void*>) end;
-define constant <GOptionGroup> = <_GOptionGroup>;
+define C-struct <_GOptionGroup>
+end;
+
+define C-pointer-type <GOptionGroup> => <_GOptionGroup>;
define constant <GOptionArg> = <C-int>;
define constant $G-OPTION-ARG-NONE = 0;
@@ -7812,8 +8562,17 @@
define constant $G-OPTION-ARG-DOUBLE = 7;
define constant $G-OPTION-ARG-INT64 = 8;
-define C-subtype <_GOptionEntry> (<C-void*>) end;
-define constant <GOptionEntry> = <_GOptionEntry>;
+define C-struct <_GOptionEntry>
+ slot GOptionEntry-long-name :: <gchar*>;
+ slot GOptionEntry-short-name :: <C-signed-char>;
+ slot GOptionEntry-flags :: <C-signed-int>;
+ slot GOptionEntry-arg :: <GOptionArg>;
+ slot GOptionEntry-arg-data :: <C-void*>;
+ slot GOptionEntry-description :: <gchar*>;
+ slot GOptionEntry-arg-description :: <gchar*>;
+end;
+
+define C-pointer-type <GOptionEntry> => <_GOptionEntry>;
define constant <GOptionFlags> = <C-int>;
define constant $G-OPTION-FLAG-HIDDEN = 1;
@@ -8153,16 +8912,25 @@
define constant $G-MARKUP-DO-NOT-USE-THIS-UNSUPPORTED-FLAG = 1;
define constant $G-MARKUP-TREAT-CDATA-AS-TEXT = 2;
-define C-subtype <_GMarkupParseContext> (<C-void*>) end;
-define constant <GMarkupParseContext> = <_GMarkupParseContext>;
+define C-struct <_GMarkupParseContext>
+end;
+
+define C-pointer-type <GMarkupParseContext> => <_GMarkupParseContext>;
define constant <anonymous-1044> = <C-function-pointer>;
define constant <anonymous-1045> = <C-function-pointer>;
define constant <anonymous-1046> = <C-function-pointer>;
define constant <anonymous-1047> = <C-function-pointer>;
define constant <anonymous-1048> = <C-function-pointer>;
-define C-subtype <_GMarkupParser> (<C-void*>) end;
-define constant <GMarkupParser> = <_GMarkupParser>;
+define C-struct <_GMarkupParser>
+ slot GMarkupParser-start-element :: <anonymous-1044>;
+ slot GMarkupParser-end-element :: <anonymous-1045>;
+ slot GMarkupParser-text :: <anonymous-1046>;
+ slot GMarkupParser-passthrough :: <anonymous-1047>;
+ slot GMarkupParser-error :: <anonymous-1048>;
+end;
+
+define C-pointer-type <GMarkupParser> => <_GMarkupParser>;
define C-function g-markup-parse-context-new
input parameter arg1 :: <GMarkupParser>;
@@ -8227,8 +8995,10 @@
c-name: "g_markup_vprintf_escaped";
end;
-define C-subtype <_GMappedFile> (<C-void*>) end;
-define constant <GMappedFile> = <_GMappedFile>;
+define C-struct <_GMappedFile>
+end;
+
+define C-pointer-type <GMappedFile> => <_GMappedFile>;
define C-function g-mapped-file-new
input parameter arg1 :: <gchar*>;
@@ -8255,23 +9025,32 @@
c-name: "g_mapped_file_free";
end;
-define C-subtype <_GMainContext> (<C-void*>) end;
-define constant <GMainContext> = <_GMainContext>;
+define C-struct <_GMainContext>
+end;
+
+define C-pointer-type <GMainContext> => <_GMainContext>;
-define C-subtype <_GMainLoop> (<C-void*>) end;
-define constant <GMainLoop> = <_GMainLoop>;
+define C-struct <_GMainLoop>
+end;
+
+define C-pointer-type <GMainLoop> => <_GMainLoop>;
define constant <anonymous-722> = <C-function-pointer>;
define constant <anonymous-723> = <C-function-pointer>;
-define constant <GSource> = <_GSource>;
+define C-pointer-type <GSource> => <_GSource>;
define constant <anonymous-720> = <C-function-pointer>;
define constant <GSourceFunc> = <anonymous-720>;
define C-pointer-type <GSourceFunc*> => <GSourceFunc>;
define constant <anonymous-724> = <C-function-pointer>;
-define C-subtype <_GSourceCallbackFuncs> (<C-void*>) end;
-define constant <GSourceCallbackFuncs> = <_GSourceCallbackFuncs>;
+define C-struct <_GSourceCallbackFuncs>
+ slot GSourceCallbackFuncs-ref :: <anonymous-722>;
+ slot GSourceCallbackFuncs-unref :: <anonymous-723>;
+ slot GSourceCallbackFuncs-get :: <anonymous-724>;
+end;
+
+define C-pointer-type <GSourceCallbackFuncs> => <_GSourceCallbackFuncs>;
define constant <anonymous-726> = <C-function-pointer>;
define constant <anonymous-727> = <C-function-pointer>;
@@ -8280,15 +9059,43 @@
define constant <anonymous-725> = <C-function-pointer>;
define constant <GSourceDummyMarshal> = <anonymous-725>;
-define C-subtype <_GSourceFuncs> (<C-void*>) end;
-define constant <GSourceFuncs> = <_GSourceFuncs>;
+define C-struct <_GSourceFuncs>
+ slot GSourceFuncs-prepare :: <anonymous-726>;
+ slot GSourceFuncs-check :: <anonymous-727>;
+ slot GSourceFuncs-dispatch :: <anonymous-728>;
+ slot GSourceFuncs-finalize :: <anonymous-729>;
+ slot GSourceFuncs-closure-callback :: <anonymous-720>;
+ slot GSourceFuncs-closure-marshal :: <anonymous-725>;
+end;
+
+define C-pointer-type <GSourceFuncs> => <_GSourceFuncs>;
+
+define C-struct <_GSource>
+ slot GSource-callback-data :: <C-void*>;
+ slot GSource-callback-funcs :: <GSourceCallbackFuncs>;
+ slot GSource-source-funcs :: <GSourceFuncs>;
+ slot GSource-ref-count :: <C-unsigned-int>;
+ slot GSource-context :: <GMainContext>;
+ slot GSource-priority :: <C-signed-int>;
+ slot GSource-flags :: <C-unsigned-int>;
+ slot GSource-source-id :: <C-unsigned-int>;
+ slot GSource-poll-fds :: <GSList>;
+ slot GSource-prev :: <GSource>;
+ slot GSource-next :: <GSource>;
+ slot GSource-reserved1 :: <C-void*>;
+ slot GSource-reserved2 :: <C-void*>;
+end;
-define C-subtype <_GSource> (<C-void*>) end;
define constant <anonymous-721> = <C-function-pointer>;
define constant <GChildWatchFunc> = <anonymous-721>;
-define C-subtype <_GPollFD> (<C-void*>) end;
-define constant <GPollFD> = <_GPollFD>;
+define C-struct <_GPollFD>
+ slot GPollFD-fd :: <C-signed-int>;
+ slot GPollFD-events :: <C-unsigned-short>;
+ slot GPollFD-revents :: <C-unsigned-short>;
+end;
+
+define C-pointer-type <GPollFD> => <_GPollFD>;
define constant <anonymous-730> = <C-function-pointer>;
define constant <GPollFunc> = <anonymous-730>;
@@ -8721,8 +9528,10 @@
c-name: "g_key_file_error_quark";
end;
-define C-subtype <_GKeyFile> (<C-void*>) end;
-define constant <GKeyFile> = <_GKeyFile>;
+define C-struct <_GKeyFile>
+end;
+
+define C-pointer-type <GKeyFile> => <_GKeyFile>;
define constant <GKeyFileFlags> = <C-int>;
define constant $G-KEY-FILE-NONE = 0;
@@ -9073,7 +9882,7 @@
define constant $G-IO-STATUS-EOF = 2;
define constant $G-IO-STATUS-AGAIN = 3;
-define constant <GIOChannel> = <_GIOChannel>;
+define C-pointer-type <GIOChannel> => <_GIOChannel>;
define constant <anonymous-943> = <C-function-pointer>;
define constant <anonymous-944> = <C-function-pointer>;
@@ -9106,14 +9915,48 @@
define constant <anonymous-949> = <C-function-pointer>;
define constant <anonymous-950> = <C-function-pointer>;
-define C-subtype <_GIOFuncs> (<C-void*>) end;
-define constant <GIOFuncs> = <_GIOFuncs>;
+define C-struct <_GIOFuncs>
+ slot GIOFuncs-io-read :: <anonymous-943>;
+ slot GIOFuncs-io-write :: <anonymous-944>;
+ slot GIOFuncs-io-seek :: <anonymous-945>;
+ slot GIOFuncs-io-close :: <anonymous-946>;
+ slot GIOFuncs-io-create-watch :: <anonymous-947>;
+ slot GIOFuncs-io-free :: <anonymous-948>;
+ slot GIOFuncs-io-set-flags :: <anonymous-949>;
+ slot GIOFuncs-io-get-flags :: <anonymous-950>;
+end;
+
+define C-pointer-type <GIOFuncs> => <_GIOFuncs>;
+
+define C-struct <_GIConv>
+end;
-define C-subtype <_GIConv> (<C-void*>) end;
define constant <GIConv> = <_GIConv>;
define constant <gchar<@6>> = <gchar*>;
-define C-subtype <_GIOChannel> (<C-void*>) end;
+define C-struct <_GIOChannel>
+ slot GIOChannel-ref-count :: <C-signed-int>;
+ slot GIOChannel-funcs :: <GIOFuncs>;
+ slot GIOChannel-encoding :: <gchar*>;
+ slot GIOChannel-read-cd :: <_GIConv>;
+ slot GIOChannel-write-cd :: <_GIConv>;
+ slot GIOChannel-line-term :: <gchar*>;
+ slot GIOChannel-line-term-len :: <C-unsigned-int>;
+ slot GIOChannel-buf-size :: <C-unsigned-int>;
+ slot GIOChannel-read-buf :: <GString>;
+ slot GIOChannel-encoded-read-buf :: <GString>;
+ slot GIOChannel-write-buf :: <GString>;
+ slot GIOChannel-partial-write-buf :: <gchar<@6>>;
+ bitfield slot GIOChannel-use-buffer :: <C-int>, width: 1;
+ bitfield slot GIOChannel-do-encode :: <C-int>, width: 1;
+ bitfield slot GIOChannel-close-on-unref :: <C-int>, width: 1;
+ bitfield slot GIOChannel-is-readable :: <C-int>, width: 1;
+ bitfield slot GIOChannel-is-writeable :: <C-int>, width: 1;
+ bitfield slot GIOChannel-is-seekable :: <C-int>, width: 1;
+ slot GIOChannel-reserved1 :: <C-void*>;
+ slot GIOChannel-reserved2 :: <C-void*>;
+end;
+
define constant <GIOError> = <C-int>;
define constant $G-IO-ERROR-NONE = 0;
define constant $G-IO-ERROR-AGAIN = 1;
@@ -9615,16 +10458,35 @@
define constant g-filename-to-uri = g-filename-to-uri-utf8;
-define constant <GHook> = <_GHook>;
+define C-pointer-type <GHook> => <_GHook>;
+
+define C-struct <_GHook>
+ slot GHook-data :: <C-void*>;
+ slot GHook-next :: <GHook>;
+ slot GHook-prev :: <GHook>;
+ slot GHook-ref-count :: <C-unsigned-int>;
+ slot GHook-hook-id :: <C-unsigned-long>;
+ slot GHook-flags :: <C-unsigned-int>;
+ slot GHook-func :: <C-void*>;
+ slot GHook-destroy :: <anonymous-212>;
+end;
-define C-subtype <_GHook> (<C-void*>) end;
-define constant <GHookList> = <_GHookList>;
+define C-pointer-type <GHookList> => <_GHookList>;
define constant <anonymous-664> = <C-function-pointer>;
define constant <GHookFinalizeFunc> = <anonymous-664>;
define constant <gpointer<@2>> = <gpointer*>;
-define C-subtype <_GHookList> (<C-void*>) end;
+define C-struct <_GHookList>
+ slot GHookList-seq-id :: <C-unsigned-long>;
+ bitfield slot GHookList-hook-size :: <C-int>, width: 16;
+ bitfield slot GHookList-is-setup :: <C-int>, width: 1;
+ slot GHookList-hooks :: <GHook>;
+ slot GHookList-dummy3 :: <C-void*>;
+ slot GHookList-finalize-hook :: <anonymous-664>;
+ slot GHookList-dummy :: <gpointer<@2>>;
+end;
+
define constant <anonymous-658> = <C-function-pointer>;
define constant <GHookCompareFunc> = <anonymous-658>;
@@ -9942,8 +10804,10 @@
define constant g-file-open-tmp = g-file-open-tmp-utf8;
-define C-subtype <_GDir> (<C-void*>) end;
-define constant <GDir> = <_GDir>;
+define C-struct <_GDir>
+end;
+
+define C-pointer-type <GDir> => <_GDir>;
define C-function g-dir-open-utf8
input parameter arg1 :: <gchar*>;
@@ -9979,8 +10843,16 @@
define constant <GDateDay> = <guint8>;
-define C-subtype <_GDate> (<C-void*>) end;
-define constant <GDate> = <_GDate>;
+define C-struct <_GDate>
+ bitfield slot GDate-julian-days :: <C-int>, width: 32;
+ bitfield slot GDate-julian :: <C-int>, width: 1;
+ bitfield slot GDate-dmy :: <C-int>, width: 1;
+ bitfield slot GDate-day :: <C-int>, width: 6;
+ bitfield slot GDate-month :: <C-int>, width: 4;
+ bitfield slot GDate-year :: <C-int>, width: 16;
+end;
+
+define C-pointer-type <GDate> => <_GDate>;
define constant <GDateDMY> = <C-int>;
define constant $G-DATE-DAY = 0;
@@ -10285,7 +11157,18 @@
c-name: "g_date_compare";
end;
-define C-subtype <tm> (<C-void*>) end;
+define C-struct <tm>
+ slot m-tm-sec :: <C-signed-int>;
+ slot m-tm-min :: <C-signed-int>;
+ slot m-tm-hour :: <C-signed-int>;
+ slot m-tm-mday :: <C-signed-int>;
+ slot m-tm-mon :: <C-signed-int>;
+ slot m-tm-year :: <C-signed-int>;
+ slot m-tm-wday :: <C-signed-int>;
+ slot m-tm-yday :: <C-signed-int>;
+ slot m-tm-isdst :: <C-signed-int>;
+end;
+
define C-function g-date-to-struct-tm
input parameter arg1 :: <GDate>;
input parameter arg2 :: <tm>;
@@ -10362,8 +11245,15 @@
define constant <anonymous-515> = <C-function-pointer>;
define constant <GCompletionStrncmpFunc> = <anonymous-515>;
-define C-subtype <_GCompletion> (<C-void*>) end;
-define constant <GCompletion> = <_GCompletion>;
+define C-struct <_GCompletion>
+ slot GCompletion-items :: <GList>;
+ slot GCompletion-func :: <anonymous-514>;
+ slot GCompletion-prefix :: <gchar*>;
+ slot GCompletion-cache :: <GList>;
+ slot GCompletion-strncmp-func :: <anonymous-515>;
+end;
+
+define C-pointer-type <GCompletion> => <_GCompletion>;
define C-function g-completion-new
input parameter arg1 :: <GCompletionFunc>;
@@ -10415,8 +11305,10 @@
c-name: "g_completion_free";
end;
-define C-subtype <_GCache> (<C-void*>) end;
-define constant <GCache> = <_GCache>;
+define C-struct <_GCache>
+end;
+
+define C-pointer-type <GCache> => <_GCache>;
define constant <anonymous-505> = <C-function-pointer>;
define constant <GCacheNewFunc> = <anonymous-505>;
@@ -10486,8 +11378,10 @@
c-name: "g_bookmark_file_error_quark";
end;
-define C-subtype <_GBookmarkFile> (<C-void*>) end;
-define constant <GBookmarkFile> = <_GBookmarkFile>;
+define C-struct <_GBookmarkFile>
+end;
+
+define C-pointer-type <GBookmarkFile> => <_GBookmarkFile>;
define C-function g-bookmark-file-new
result res :: <GBookmarkFile>;
@@ -10857,8 +11751,10 @@
c-name: "g_on_error_stack_trace";
end;
-define C-subtype <_GAsyncQueue> (<C-void*>) end;
-define constant <GAsyncQueue> = <_GAsyncQueue>;
+define C-struct <_GAsyncQueue>
+end;
+
+define C-pointer-type <GAsyncQueue> => <_GAsyncQueue>;
define C-function g-async-queue-new
result res :: <GAsyncQueue>;
@@ -10989,8 +11885,12 @@
end;
define C-pointer-type <guint8*> => <guint8>;
-define C-subtype <_GByteArray> (<C-void*>) end;
-define constant <GByteArray> = <_GByteArray>;
+define C-struct <_GByteArray>
+ slot GByteArray-data :: <guint8*>;
+ slot GByteArray-len :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GByteArray> => <_GByteArray>;
define C-function g-array-new
input parameter arg1 :: <gboolean>;
@@ -11245,8 +12145,13 @@
end;
define C-pointer-type <int*> => <C-signed-int>;
-define C-subtype <_heapinfo> (<C-void*>) end;
-define constant <_HEAPINFO> = <_heapinfo>;
+define C-struct <_heapinfo>
+ slot heapinfo-_pentry :: <int*>;
+ slot heapinfo-_size :: <C-unsigned-int>;
+ slot heapinfo-_useflag :: <C-signed-int>;
+end;
+
+define C-pointer-type <_HEAPINFO> => <_heapinfo>;
/* Ignoring declaration for {instance of <variable-declaration>} "_amblksiz"*/
//define constant $_HEAP-MAXREQ = #ex00000000FFFFFFE0;
@@ -11267,8 +12172,13 @@
define constant $_USEDENTRY = 1;
-define C-subtype <_GValueArray> (<C-void*>) end;
-define constant <GValueArray> = <_GValueArray>;
+define C-struct <_GValueArray>
+ slot GValueArray-n-values :: <C-unsigned-int>;
+ slot GValueArray-values :: <GValue>;
+ slot GValueArray-n-prealloced :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GValueArray> => <_GValueArray>;
define C-function g-value-array-get-nth
input parameter arg1 :: <GValueArray>;
@@ -11350,8 +12260,15 @@
define constant <anonymous-1758> = <C-function-pointer>;
define constant <GTypePluginCompleteInterfaceInfo> = <anonymous-1758>;
-define C-subtype <_GTypePluginClass> (<C-void*>) end;
-define constant <GTypePluginClass> = <_GTypePluginClass>;
+define C-struct <_GTypePluginClass>
+ slot GTypePluginClass-base-iface :: <_GTypeInterface>;
+ slot GTypePluginClass-use-plugin :: <anonymous-1755>;
+ slot GTypePluginClass-unuse-plugin :: <anonymous-1756>;
+ slot GTypePluginClass-complete-type-info :: <anonymous-1757>;
+ slot GTypePluginClass-complete-interface-info :: <anonymous-1758>;
+end;
+
+define C-pointer-type <GTypePluginClass> => <_GTypePluginClass>;
define C-function g-type-plugin-get-type
result res :: <GType>;
@@ -11393,8 +12310,17 @@
define constant <anonymous-1744> = <C-function-pointer>;
define constant <anonymous-1745> = <C-function-pointer>;
define constant <anonymous-1746> = <C-function-pointer>;
-define C-subtype <_GTypeModuleClass> (<C-void*>) end;
-define constant <GTypeModuleClass> = <_GTypeModuleClass>;
+define C-struct <_GTypeModuleClass>
+ slot GTypeModuleClass-parent-class :: <_GObjectClass>;
+ slot GTypeModuleClass-load :: <anonymous-1741>;
+ slot GTypeModuleClass-unload :: <anonymous-1742>;
+ slot GTypeModuleClass-reserved1 :: <anonymous-1743>;
+ slot GTypeModuleClass-reserved2 :: <anonymous-1744>;
+ slot GTypeModuleClass-reserved3 :: <anonymous-1745>;
+ slot GTypeModuleClass-reserved4 :: <anonymous-1746>;
+end;
+
+define C-pointer-type <GTypeModuleClass> => <_GTypeModuleClass>;
define C-function g-type-module-get-type
result res :: <GType>;
@@ -11436,8 +12362,13 @@
c-name: "g_type_module_add_interface";
end;
-define C-subtype <_GEnumValue> (<C-void*>) end;
-define constant <GEnumValue> = <_GEnumValue>;
+define C-struct <_GEnumValue>
+ slot GEnumValue-value :: <C-signed-int>;
+ slot GEnumValue-value-name :: <gchar*>;
+ slot GEnumValue-value-nick :: <gchar*>;
+end;
+
+define C-pointer-type <GEnumValue> => <_GEnumValue>;
define C-function g-type-module-register-enum
input parameter arg1 :: <GTypeModule>;
@@ -11447,8 +12378,13 @@
c-name: "g_type_module_register_enum";
end;
-define C-subtype <_GFlagsValue> (<C-void*>) end;
-define constant <GFlagsValue> = <_GFlagsValue>;
+define C-struct <_GFlagsValue>
+ slot GFlagsValue-value :: <C-unsigned-int>;
+ slot GFlagsValue-value-name :: <gchar*>;
+ slot GFlagsValue-value-nick :: <gchar*>;
+end;
+
+define C-pointer-type <GFlagsValue> => <_GFlagsValue>;
define C-function g-type-module-register-flags
input parameter arg1 :: <GTypeModule>;
@@ -11458,11 +12394,24 @@
c-name: "g_type_module_register_flags";
end;
-define C-subtype <_GEnumClass> (<C-void*>) end;
-define constant <GEnumClass> = <_GEnumClass>;
+define C-struct <_GEnumClass>
+ slot GEnumClass-g-type-class :: <_GTypeClass>;
+ slot GEnumClass-minimum :: <C-signed-int>;
+ slot GEnumClass-maximum :: <C-signed-int>;
+ slot GEnumClass-n-values :: <C-unsigned-int>;
+ slot GEnumClass-values :: <GEnumValue>;
+end;
+
+define C-pointer-type <GEnumClass> => <_GEnumClass>;
+
+define C-struct <_GFlagsClass>
+ slot GFlagsClass-g-type-class :: <_GTypeClass>;
+ slot GFlagsClass-mask :: <C-unsigned-int>;
+ slot GFlagsClass-n-values :: <C-unsigned-int>;
+ slot GFlagsClass-values :: <GFlagsValue>;
+end;
-define C-subtype <_GFlagsClass> (<C-void*>) end;
-define constant <GFlagsClass> = <_GFlagsClass>;
+define C-pointer-type <GFlagsClass> => <_GFlagsClass>;
define C-function g-enum-get-value
input parameter arg1 :: <GEnumClass>;
@@ -11630,8 +12579,12 @@
c-name: "g_object_new";
end;
-define C-subtype <_GParameter> (<C-void*>) end;
-define constant <GParameter> = <_GParameter>;
+define C-struct <_GParameter>
+ slot GParameter-name :: <gchar*>;
+ slot GParameter-value :: <_GValue>;
+end;
+
+define C-pointer-type <GParameter> => <_GParameter>;
define C-function g-object-newv
input parameter arg1 :: <GType>;
@@ -11942,11 +12895,25 @@
define constant $G-SIGNAL-ACTION = 32;
define constant $G-SIGNAL-NO-HOOKS = 64;
-define C-subtype <_GSignalQuery> (<C-void*>) end;
-define constant <GSignalQuery> = <_GSignalQuery>;
+define C-struct <_GSignalQuery>
+ slot GSignalQuery-signal-id :: <C-unsigned-int>;
+ slot GSignalQuery-signal-name :: <gchar*>;
+ slot GSignalQuery-itype :: <C-unsigned-long>;
+ slot GSignalQuery-signal-flags :: <GSignalFlags>;
+ slot GSignalQuery-return-type :: <C-unsigned-long>;
+ slot GSignalQuery-n-params :: <C-unsigned-int>;
+ slot GSignalQuery-param-types :: <GType*>;
+end;
+
+define C-pointer-type <GSignalQuery> => <_GSignalQuery>;
+
+define C-struct <_GSignalInvocationHint>
+ slot GSignalInvocationHint-signal-id :: <C-unsigned-int>;
+ slot GSignalInvocationHint-detail :: <C-unsigned-int>;
+ slot GSignalInvocationHint-run-type :: <GSignalFlags>;
+end;
-define C-subtype <_GSignalInvocationHint> (<C-void*>) end;
-define constant <GSignalInvocationHint> = <_GSignalInvocationHint>;
+define C-pointer-type <GSignalInvocationHint> => <_GSignalInvocationHint>;
define constant <anonymous-1562> = <C-function-pointer>;
define constant <GClosureMarshal> = <anonymous-1562>;
@@ -12464,11 +13431,22 @@
define constant <anonymous-1522> = <C-function-pointer>;
define constant <anonymous-1523> = <C-function-pointer>;
define constant <gpointer<@4>> = <gpointer*>;
-define C-subtype <_GParamSpecClass> (<C-void*>) end;
-define constant <GParamSpecClass> = <_GParamSpecClass>;
+define C-struct <_GParamSpecClass>
+ slot GParamSpecClass-g-type-class :: <_GTypeClass>;
+ slot GParamSpecClass-value-type :: <C-unsigned-long>;
+ slot GParamSpecClass-finalize :: <anonymous-1520>;
+ slot GParamSpecClass-value-set-default :: <anonymous-1521>;
+ slot GParamSpecClass-value-validate :: <anonymous-1522>;
+ slot GParamSpecClass-values-cmp :: <anonymous-1523>;
+ slot GParamSpecClass-dummy :: <gpointer<@4>>;
+end;
+
+define C-pointer-type <GParamSpecClass> => <_GParamSpecClass>;
+
+define C-struct <_GParamSpecPool>
+end;
-define C-subtype <_GParamSpecPool> (<C-void*>) end;
-define constant <GParamSpecPool> = <_GParamSpecPool>;
+define C-pointer-type <GParamSpecPool> => <_GParamSpecPool>;
define C-function g-param-spec-ref
input parameter arg1 :: <GParamSpec>;
@@ -12617,8 +13595,18 @@
define constant <anonymous-1548> = <C-function-pointer>;
define constant <anonymous-1549> = <C-function-pointer>;
define constant <anonymous-1550> = <C-function-pointer>;
-define C-subtype <_GParamSpecTypeInfo> (<C-void*>) end;
-define constant <GParamSpecTypeInfo> = <_GParamSpecTypeInfo>;
+define C-struct <_GParamSpecTypeInfo>
+ slot GParamSpecTypeInfo-instance-size :: <C-unsigned-short>;
+ slot GParamSpecTypeInfo-n-preallocs :: <C-unsigned-short>;
+ slot GParamSpecTypeInfo-instance-init :: <anonymous-1546>;
+ slot GParamSpecTypeInfo-value-type :: <C-unsigned-long>;
+ slot GParamSpecTypeInfo-finalize :: <anonymous-1547>;
+ slot GParamSpecTypeInfo-value-set-default :: <anonymous-1548>;
+ slot GParamSpecTypeInfo-value-validate :: <anonymous-1549>;
+ slot GParamSpecTypeInfo-values-cmp :: <anonymous-1550>;
+end;
+
+define C-pointer-type <GParamSpecTypeInfo> => <_GParamSpecTypeInfo>;
define C-function g-param-type-register-static
input parameter arg1 :: <gchar*>;
@@ -12686,8 +13674,12 @@
define constant $G-PARAM-USER-SHIFT = 8;
-define C-subtype <_GCClosure> (<C-void*>) end;
-define constant <GCClosure> = <_GCClosure>;
+define C-struct <_GCClosure>
+ slot GCClosure-closure :: <_GClosure>;
+ slot GCClosure-callback :: <C-void*>;
+end;
+
+define C-pointer-type <GCClosure> => <_GCClosure>;
define C-function g-cclosure-new
input parameter arg1 :: <GCallback>;
@@ -12815,71 +13807,185 @@
c-name: "g_io_condition_get_type";
end;
-define C-subtype <_GParamSpecChar> (<C-void*>) end;
-define constant <GParamSpecChar> = <_GParamSpecChar>;
+define C-struct <_GParamSpecChar>
+ slot GParamSpecChar-parent-instance :: <_GParamSpec>;
+ slot GParamSpecChar-minimum :: <C-signed-char>;
+ slot GParamSpecChar-maximum :: <C-signed-char>;
+ slot GParamSpecChar-default-value :: <C-signed-char>;
+end;
+
+define C-pointer-type <GParamSpecChar> => <_GParamSpecChar>;
+
+define C-struct <_GParamSpecUChar>
+ slot GParamSpecUChar-parent-instance :: <_GParamSpec>;
+ slot GParamSpecUChar-minimum :: <C-unsigned-char>;
+ slot GParamSpecUChar-maximum :: <C-unsigned-char>;
+ slot GParamSpecUChar-default-value :: <C-unsigned-char>;
+end;
+
+define C-pointer-type <GParamSpecUChar> => <_GParamSpecUChar>;
+
+define C-struct <_GParamSpecBoolean>
+ slot GParamSpecBoolean-parent-instance :: <_GParamSpec>;
+ slot GParamSpecBoolean-default-value :: <C-signed-int>;
+end;
+
+define C-pointer-type <GParamSpecBoolean> => <_GParamSpecBoolean>;
+
+define C-struct <_GParamSpecInt>
+ slot GParamSpecInt-parent-instance :: <_GParamSpec>;
+ slot GParamSpecInt-minimum :: <C-signed-int>;
+ slot GParamSpecInt-maximum :: <C-signed-int>;
+ slot GParamSpecInt-default-value :: <C-signed-int>;
+end;
+
+define C-pointer-type <GParamSpecInt> => <_GParamSpecInt>;
+
+define C-struct <_GParamSpecUInt>
+ slot GParamSpecUInt-parent-instance :: <_GParamSpec>;
+ slot GParamSpecUInt-minimum :: <C-unsigned-int>;
+ slot GParamSpecUInt-maximum :: <C-unsigned-int>;
+ slot GParamSpecUInt-default-value :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GParamSpecUInt> => <_GParamSpecUInt>;
+
+define C-struct <_GParamSpecLong>
+ slot GParamSpecLong-parent-instance :: <_GParamSpec>;
+ slot GParamSpecLong-minimum :: <C-signed-long>;
+ slot GParamSpecLong-maximum :: <C-signed-long>;
+ slot GParamSpecLong-default-value :: <C-signed-long>;
+end;
+
+define C-pointer-type <GParamSpecLong> => <_GParamSpecLong>;
+
+define C-struct <_GParamSpecULong>
+ slot GParamSpecULong-parent-instance :: <_GParamSpec>;
+ slot GParamSpecULong-minimum :: <C-unsigned-long>;
+ slot GParamSpecULong-maximum :: <C-unsigned-long>;
+ slot GParamSpecULong-default-value :: <C-unsigned-long>;
+end;
+
+define C-pointer-type <GParamSpecULong> => <_GParamSpecULong>;
+
+define C-struct <_GParamSpecInt64>
+ slot GParamSpecInt64-parent-instance :: <_GParamSpec>;
+ slot GParamSpecInt64-minimum :: <C-signed-long>;
+ slot GParamSpecInt64-maximum :: <C-signed-long>;
+ slot GParamSpecInt64-default-value :: <C-signed-long>;
+end;
+
+define C-pointer-type <GParamSpecInt64> => <_GParamSpecInt64>;
+
+define C-struct <_GParamSpecUInt64>
+ slot GParamSpecUInt64-parent-instance :: <_GParamSpec>;
+ slot GParamSpecUInt64-minimum :: <C-unsigned-long>;
+ slot GParamSpecUInt64-maximum :: <C-unsigned-long>;
+ slot GParamSpecUInt64-default-value :: <C-unsigned-long>;
+end;
+
+define C-pointer-type <GParamSpecUInt64> => <_GParamSpecUInt64>;
+
+define C-struct <_GParamSpecUnichar>
+ slot GParamSpecUnichar-parent-instance :: <_GParamSpec>;
+ slot GParamSpecUnichar-default-value :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GParamSpecUnichar> => <_GParamSpecUnichar>;
+
+define C-struct <_GParamSpecEnum>
+ slot GParamSpecEnum-parent-instance :: <_GParamSpec>;
+ slot GParamSpecEnum-enum-class :: <GEnumClass>;
+ slot GParamSpecEnum-default-value :: <C-signed-int>;
+end;
+
+define C-pointer-type <GParamSpecEnum> => <_GParamSpecEnum>;
+
+define C-struct <_GParamSpecFlags>
+ slot GParamSpecFlags-parent-instance :: <_GParamSpec>;
+ slot GParamSpecFlags-flags-class :: <GFlagsClass>;
+ slot GParamSpecFlags-default-value :: <C-unsigned-int>;
+end;
-define C-subtype <_GParamSpecUChar> (<C-void*>) end;
-define constant <GParamSpecUChar> = <_GParamSpecUChar>;
+define C-pointer-type <GParamSpecFlags> => <_GParamSpecFlags>;
-define C-subtype <_GParamSpecBoolean> (<C-void*>) end;
-define constant <GParamSpecBoolean> = <_GParamSpecBoolean>;
+define C-struct <_GParamSpecFloat>
+ slot GParamSpecFloat-parent-instance :: <_GParamSpec>;
+ slot GParamSpecFloat-minimum :: <C-float>;
+ slot GParamSpecFloat-maximum :: <C-float>;
+ slot GParamSpecFloat-default-value :: <C-float>;
+ slot GParamSpecFloat-epsilon :: <C-float>;
+end;
-define C-subtype <_GParamSpecInt> (<C-void*>) end;
-define constant <GParamSpecInt> = <_GParamSpecInt>;
+define C-pointer-type <GParamSpecFloat> => <_GParamSpecFloat>;
-define C-subtype <_GParamSpecUInt> (<C-void*>) end;
-define constant <GParamSpecUInt> = <_GParamSpecUInt>;
+define C-struct <_GParamSpecDouble>
+ slot GParamSpecDouble-parent-instance :: <_GParamSpec>;
+ slot GParamSpecDouble-minimum :: <C-double>;
+ slot GParamSpecDouble-maximum :: <C-double>;
+ slot GParamSpecDouble-default-value :: <C-double>;
+ slot GParamSpecDouble-epsilon :: <C-double>;
+end;
-define C-subtype <_GParamSpecLong> (<C-void*>) end;
-define constant <GParamSpecLong> = <_GParamSpecLong>;
+define C-pointer-type <GParamSpecDouble> => <_GParamSpecDouble>;
-define C-subtype <_GParamSpecULong> (<C-void*>) end;
-define constant <GParamSpecULong> = <_GParamSpecULong>;
+define C-struct <_GParamSpecString>
+ slot GParamSpecString-parent-instance :: <_GParamSpec>;
+ slot GParamSpecString-default-value :: <gchar*>;
+ slot GParamSpecString-cset-first :: <gchar*>;
+ slot GParamSpecString-cset-nth :: <gchar*>;
+ slot GParamSpecString-substitutor :: <C-signed-char>;
+ bitfield slot GParamSpecString-null-fold-if-empty :: <C-int>, width: 1;
+ bitfield slot GParamSpecString-ensure-non-null :: <C-int>, width: 1;
+end;
-define C-subtype <_GParamSpecInt64> (<C-void*>) end;
-define constant <GParamSpecInt64> = <_GParamSpecInt64>;
+define C-pointer-type <GParamSpecString> => <_GParamSpecString>;
-define C-subtype <_GParamSpecUInt64> (<C-void*>) end;
-define constant <GParamSpecUInt64> = <_GParamSpecUInt64>;
+define C-struct <_GParamSpecParam>
+ slot GParamSpecParam-parent-instance :: <_GParamSpec>;
+end;
-define C-subtype <_GParamSpecUnichar> (<C-void*>) end;
-define constant <GParamSpecUnichar> = <_GParamSpecUnichar>;
+define C-pointer-type <GParamSpecParam> => <_GParamSpecParam>;
-define C-subtype <_GParamSpecEnum> (<C-void*>) end;
-define constant <GParamSpecEnum> = <_GParamSpecEnum>;
+define C-struct <_GParamSpecBoxed>
+ slot GParamSpecBoxed-parent-instance :: <_GParamSpec>;
+end;
-define C-subtype <_GParamSpecFlags> (<C-void*>) end;
-define constant <GParamSpecFlags> = <_GParamSpecFlags>;
+define C-pointer-type <GParamSpecBoxed> => <_GParamSpecBoxed>;
-define C-subtype <_GParamSpecFloat> (<C-void*>) end;
-define constant <GParamSpecFloat> = <_GParamSpecFloat>;
+define C-struct <_GParamSpecPointer>
+ slot GParamSpecPointer-parent-instance :: <_GParamSpec>;
+end;
-define C-subtype <_GParamSpecDouble> (<C-void*>) end;
-define constant <GParamSpecDouble> = <_GParamSpecDouble>;
+define C-pointer-type <GParamSpecPointer> => <_GParamSpecPointer>;
-define C-subtype <_GParamSpecString> (<C-void*>) end;
-define constant <GParamSpecString> = <_GParamSpecString>;
+define C-struct <_GParamSpecValueArray>
+ slot GParamSpecValueArray-parent-instance :: <_GParamSpec>;
+ slot GParamSpecValueArray-element-spec :: <GParamSpec>;
+ slot GParamSpecValueArray-fixed-n-elements :: <C-unsigned-int>;
+end;
-define C-subtype <_GParamSpecParam> (<C-void*>) end;
-define constant <GParamSpecParam> = <_GParamSpecParam>;
+define C-pointer-type <GParamSpecValueArray> => <_GParamSpecValueArray>;
-define C-subtype <_GParamSpecBoxed> (<C-void*>) end;
-define constant <GParamSpecBoxed> = <_GParamSpecBoxed>;
+define C-struct <_GParamSpecObject>
+ slot GParamSpecObject-parent-instance :: <_GParamSpec>;
+end;
-define C-subtype <_GParamSpecPointer> (<C-void*>) end;
-define constant <GParamSpecPointer> = <_GParamSpecPointer>;
+define C-pointer-type <GParamSpecObject> => <_GParamSpecObject>;
-define C-subtype <_GParamSpecValueArray> (<C-void*>) end;
-define constant <GParamSpecValueArray> = <_GParamSpecValueArray>;
+define C-struct <_GParamSpecOverride>
+ slot GParamSpecOverride-parent-instance :: <_GParamSpec>;
+ slot GParamSpecOverride-overridden :: <GParamSpec>;
+end;
-define C-subtype <_GParamSpecObject> (<C-void*>) end;
-define constant <GParamSpecObject> = <_GParamSpecObject>;
+define C-pointer-type <GParamSpecOverride> => <_GParamSpecOverride>;
-define C-subtype <_GParamSpecOverride> (<C-void*>) end;
-define constant <GParamSpecOverride> = <_GParamSpecOverride>;
+define C-struct <_GParamSpecGType>
+ slot GParamSpecGType-parent-instance :: <_GParamSpec>;
+ slot GParamSpecGType-is-a-type :: <C-unsigned-long>;
+end;
-define C-subtype <_GParamSpecGType> (<C-void*>) end;
-define constant <GParamSpecGType> = <_GParamSpecGType>;
+define C-pointer-type <GParamSpecGType> => <_GParamSpecGType>;
define C-function g-param-spec-char
input parameter arg1 :: <gchar*>;
@@ -13220,11 +14326,18 @@
define constant <GStrv> = <gchar**>;
-define C-subtype <_GtkSettingsClass> (<C-void*>) end;
-define constant <GtkSettingsClass> = <_GtkSettingsClass>;
+define C-struct <_GtkSettingsClass>
+ slot GtkSettingsClass-parent-class :: <_GObjectClass>;
+end;
+
+define C-pointer-type <GtkSettingsClass> => <_GtkSettingsClass>;
+
+define C-struct <_GtkSettingsValue>
+ slot GtkSettingsValue-origin :: <gchar*>;
+ slot GtkSettingsValue-value :: <_GValue>;
+end;
-define C-subtype <_GtkSettingsValue> (<C-void*>) end;
-define constant <GtkSettingsValue> = <_GtkSettingsValue>;
+define C-pointer-type <GtkSettingsValue> => <_GtkSettingsValue>;
define C-function gtk-settings-get-type
result res :: <GType>;
@@ -13335,8 +14448,19 @@
define constant <anonymous-3508> = <C-function-pointer>;
define constant <anonymous-3509> = <C-function-pointer>;
define constant <anonymous-3510> = <C-function-pointer>;
-define C-subtype <_GtkRcStyleClass> (<C-void*>) end;
-define constant <GtkRcStyleClass> = <_GtkRcStyleClass>;
+define C-struct <_GtkRcStyleClass>
+ slot GtkRcStyleClass-parent-class :: <_GObjectClass>;
+ slot GtkRcStyleClass-create-rc-style :: <anonymous-3503>;
+ slot GtkRcStyleClass-parse :: <anonymous-3504>;
+ slot GtkRcStyleClass-merge :: <anonymous-3505>;
+ slot GtkRcStyleClass-create-style :: <anonymous-3506>;
+ slot GtkRcStyleClass-_gtk-reserved1 :: <anonymous-3507>;
+ slot GtkRcStyleClass-_gtk-reserved2 :: <anonymous-3508>;
+ slot GtkRcStyleClass-_gtk-reserved3 :: <anonymous-3509>;
+ slot GtkRcStyleClass-_gtk-reserved4 :: <anonymous-3510>;
+end;
+
+define C-pointer-type <GtkRcStyleClass> => <_GtkRcStyleClass>;
define C-function gtk-rc-add-default-file-utf8
input parameter arg1 :: <gchar*>;
@@ -13556,8 +14680,14 @@
define constant gtk-rc-parse = gtk-rc-parse-utf8;
-define C-subtype <_GtkBorder> (<C-void*>) end;
-define constant <GtkBorder> = <_GtkBorder>;
+define C-struct <_GtkBorder>
+ slot GtkBorder-left :: <C-signed-int>;
+ slot GtkBorder-right :: <C-signed-int>;
+ slot GtkBorder-top :: <C-signed-int>;
+ slot GtkBorder-bottom :: <C-signed-int>;
+end;
+
+define C-pointer-type <GtkBorder> => <_GtkBorder>;
define constant <anonymous-3398> = <C-function-pointer>;
define constant <anonymous-3399> = <C-function-pointer>;
@@ -13565,8 +14695,10 @@
define constant <anonymous-3401> = <C-function-pointer>;
define constant <anonymous-3402> = <C-function-pointer>;
define constant <anonymous-3403> = <C-function-pointer>;
-define C-subtype <_GtkIconSource> (<C-void*>) end;
-define constant <GtkIconSource> = <_GtkIconSource>;
+define C-struct <_GtkIconSource>
+end;
+
+define C-pointer-type <GtkIconSource> => <_GtkIconSource>;
define constant <anonymous-3404> = <C-function-pointer>;
define constant <anonymous-3405> = <C-function-pointer>;
@@ -13579,8 +14711,12 @@
define constant $GTK-SHADOW-ETCHED-OUT = 4;
define constant <anonymous-3407> = <C-function-pointer>;
-define C-subtype <_GdkPoint> (<C-void*>) end;
-define constant <GdkPoint> = <_GdkPoint>;
+define C-struct <_GdkPoint>
+ slot GdkPoint-x :: <C-signed-int>;
+ slot GdkPoint-y :: <C-signed-int>;
+end;
+
+define C-pointer-type <GdkPoint> => <_GdkPoint>;
define constant <anonymous-3408> = <C-function-pointer>;
define constant <GtkArrowType> = <C-int>;
@@ -13635,17 +14771,70 @@
define constant <anonymous-3435> = <C-function-pointer>;
define constant <anonymous-3436> = <C-function-pointer>;
define constant <anonymous-3437> = <C-function-pointer>;
-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-struct <_GtkStyleClass>
+ slot GtkStyleClass-parent-class :: <_GObjectClass>;
+ slot GtkStyleClass-realize :: <anonymous-3398>;
+ slot GtkStyleClass-unrealize :: <anonymous-3399>;
+ slot GtkStyleClass-copy :: <anonymous-3400>;
+ slot GtkStyleClass-clone :: <anonymous-3401>;
+ slot GtkStyleClass-init-from-rc :: <anonymous-3402>;
+ slot GtkStyleClass-set-background :: <anonymous-3403>;
+ slot GtkStyleClass-render-icon :: <anonymous-3404>;
+ slot GtkStyleClass-draw-hline :: <anonymous-3405>;
+ slot GtkStyleClass-draw-vline :: <anonymous-3406>;
+ slot GtkStyleClass-draw-shadow :: <anonymous-3407>;
+ slot GtkStyleClass-draw-polygon :: <anonymous-3408>;
+ slot GtkStyleClass-draw-arrow :: <anonymous-3409>;
+ slot GtkStyleClass-draw-diamond :: <anonymous-3410>;
+ slot GtkStyleClass-draw-string :: <anonymous-3411>;
+ slot GtkStyleClass-draw-box :: <anonymous-3412>;
+ slot GtkStyleClass-draw-flat-box :: <anonymous-3413>;
+ slot GtkStyleClass-draw-check :: <anonymous-3414>;
+ slot GtkStyleClass-draw-option :: <anonymous-3415>;
+ slot GtkStyleClass-draw-tab :: <anonymous-3416>;
+ slot GtkStyleClass-draw-shadow-gap :: <anonymous-3417>;
+ slot GtkStyleClass-draw-box-gap :: <anonymous-3418>;
+ slot GtkStyleClass-draw-extension :: <anonymous-3419>;
+ slot GtkStyleClass-draw-focus :: <anonymous-3420>;
+ slot GtkStyleClass-draw-slider :: <anonymous-3421>;
+ slot GtkStyleClass-draw-handle :: <anonymous-3422>;
+ slot GtkStyleClass-draw-expander :: <anonymous-3423>;
+ slot GtkStyleClass-draw-layout :: <anonymous-3424>;
+ slot GtkStyleClass-draw-resize-grip :: <anonymous-3425>;
+ slot GtkStyleClass-_gtk-reserved1 :: <anonymous-3426>;
+ slot GtkStyleClass-_gtk-reserved2 :: <anonymous-3427>;
+ slot GtkStyleClass-_gtk-reserved3 :: <anonymous-3428>;
+ slot GtkStyleClass-_gtk-reserved4 :: <anonymous-3429>;
+ slot GtkStyleClass-_gtk-reserved5 :: <anonymous-3430>;
+ slot GtkStyleClass-_gtk-reserved6 :: <anonymous-3431>;
+ slot GtkStyleClass-_gtk-reserved7 :: <anonymous-3432>;
+ slot GtkStyleClass-_gtk-reserved8 :: <anonymous-3433>;
+ slot GtkStyleClass-_gtk-reserved9 :: <anonymous-3434>;
+ slot GtkStyleClass-_gtk-reserved10 :: <anonymous-3435>;
+ slot GtkStyleClass-_gtk-reserved11 :: <anonymous-3436>;
+ slot GtkStyleClass-_gtk-reserved12 :: <anonymous-3437>;
+end;
+
+define C-pointer-type <GtkStyleClass> => <_GtkStyleClass>;
+
+define C-struct <_GtkThemeEngine>
+end;
+
+define C-pointer-type <GtkThemeEngine> => <_GtkThemeEngine>;
+
+define C-struct <_GtkIconSet>
+end;
+
+define C-pointer-type <GtkIconSet> => <_GtkIconSet>;
+
+define C-struct <_GtkRcProperty>
+ slot GtkRcProperty-type-name :: <C-unsigned-int>;
+ slot GtkRcProperty-property-name :: <C-unsigned-int>;
+ slot GtkRcProperty-origin :: <gchar*>;
+ slot GtkRcProperty-value :: <_GValue>;
+end;
-define C-subtype <_GtkRcProperty> (<C-void*>) end;
-define constant <GtkRcProperty> = <_GtkRcProperty>;
+define C-pointer-type <GtkRcProperty> => <_GtkRcProperty>;
define C-function gtk-style-get-type
result res :: <GType>;
@@ -14352,8 +15541,18 @@
c-name: "pango_trim_string";
end;
-define C-subtype <_iobuf> (<C-void*>) end;
-define constant <FILE> = <_iobuf>;
+define C-struct <_iobuf>
+ slot iobuf-_ptr :: <char*>;
+ slot iobuf-_cnt :: <C-signed-int>;
+ slot iobuf-_base :: <char*>;
+ slot iobuf-_flag :: <C-signed-int>;
+ slot iobuf-_file :: <C-signed-int>;
+ slot iobuf-_charbuf :: <C-signed-int>;
+ slot iobuf-_bufsiz :: <C-signed-int>;
+ slot iobuf-_tmpfname :: <char*>;
+end;
+
+define C-pointer-type <FILE> => <_iobuf>;
define C-function pango-read-line
input parameter arg1 :: <FILE>;
@@ -14514,8 +15713,10 @@
define constant $PANGO-VERSION = 11601;
-define C-subtype <_PangoFontMetrics> (<C-void*>) end;
-define constant <PangoFontMetrics> = <_PangoFontMetrics>;
+define C-struct <_PangoFontMetrics>
+end;
+
+define C-pointer-type <PangoFontMetrics> => <_PangoFontMetrics>;
define constant <PangoFontMask> = <C-int>;
define constant $PANGO-FONT-MASK-FAMILY = 1;
@@ -14875,11 +16076,15 @@
c-name: "pango_font_describe_with_absolute_size";
end;
-define C-subtype <_PangoCoverage> (<C-void*>) end;
-define constant <PangoCoverage> = <_PangoCoverage>;
+define C-struct <_PangoCoverage>
+end;
+
+define C-pointer-type <PangoCoverage> => <_PangoCoverage>;
+
+define C-struct <_PangoLanguage>
+end;
-define C-subtype <_PangoLanguage> (<C-void*>) end;
-define constant <PangoLanguage> = <_PangoLanguage>;
+define C-pointer-type <PangoLanguage> => <_PangoLanguage>;
define C-function pango-font-get-coverage
input parameter arg1 :: <PangoFont>;
@@ -14888,8 +16093,10 @@
c-name: "pango_font_get_coverage";
end;
-define C-subtype <_PangoEngineShape> (<C-void*>) end;
-define constant <PangoEngineShape> = <_PangoEngineShape>;
+define C-struct <_PangoEngineShape>
+end;
+
+define C-pointer-type <PangoEngineShape> => <_PangoEngineShape>;
define C-function pango-font-find-shaper
input parameter arg1 :: <PangoFont>;
@@ -14908,8 +16115,14 @@
define constant <PangoGlyph> = <guint32>;
-define C-subtype <_PangoRectangle> (<C-void*>) end;
-define constant <PangoRectangle> = <_PangoRectangle>;
+define C-struct <_PangoRectangle>
+ slot PangoRectangle-x :: <C-signed-int>;
+ slot PangoRectangle-y :: <C-signed-int>;
+ slot PangoRectangle-width :: <C-signed-int>;
+ slot PangoRectangle-height :: <C-signed-int>;
+end;
+
+define C-pointer-type <PangoRectangle> => <_PangoRectangle>;
define C-function pango-font-get-glyph-extents
input parameter arg1 :: <PangoFont>;
@@ -14928,11 +16141,26 @@
c-name: "pango_font_get_font_map";
end;
-define C-subtype <_PangoLogAttr> (<C-void*>) end;
-define constant <PangoLogAttr> = <_PangoLogAttr>;
+define C-struct <_PangoLogAttr>
+ bitfield slot PangoLogAttr-is-line-break :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-mandatory-break :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-char-break :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-white :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-cursor-position :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-word-start :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-word-end :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-sentence-boundary :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-sentence-start :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-is-sentence-end :: <C-int>, width: 1;
+ bitfield slot PangoLogAttr-backspace-deletes-character :: <C-int>, width: 1;
+end;
+
+define C-pointer-type <PangoLogAttr> => <_PangoLogAttr>;
+
+define C-struct <_PangoEngineLang>
+end;
-define C-subtype <_PangoEngineLang> (<C-void*>) end;
-define constant <PangoEngineLang> = <_PangoEngineLang>;
+define C-pointer-type <PangoEngineLang> => <_PangoEngineLang>;
define C-function pango-units-from-double
input parameter arg1 :: <C-double>;
@@ -15014,8 +16242,16 @@
c-name: "pango_gravity_to_rotation";
end;
-define C-subtype <_PangoMatrix> (<C-void*>) end;
-define constant <PangoMatrix> = <_PangoMatrix>;
+define C-struct <_PangoMatrix>
+ slot PangoMatrix-xx :: <C-double>;
+ slot PangoMatrix-xy :: <C-double>;
+ slot PangoMatrix-yx :: <C-double>;
+ slot PangoMatrix-yy :: <C-double>;
+ slot PangoMatrix-x0 :: <C-double>;
+ slot PangoMatrix-y0 :: <C-double>;
+end;
+
+define C-pointer-type <PangoMatrix> => <_PangoMatrix>;
define C-function pango-gravity-get-for-matrix
input parameter arg1 :: <PangoMatrix>;
@@ -15101,8 +16337,10 @@
c-name: "pango_gravity_get_for_script";
end;
-define C-subtype <_PangoScriptIter> (<C-void*>) end;
-define constant <PangoScriptIter> = <_PangoScriptIter>;
+define C-struct <_PangoScriptIter>
+end;
+
+define C-pointer-type <PangoScriptIter> => <_PangoScriptIter>;
define C-function pango-script-for-unichar
input parameter arg1 :: <gunichar>;
@@ -15356,8 +16594,10 @@
define constant $WEOF = 65535;
-define C-subtype <_PangoTabArray> (<C-void*>) end;
-define constant <PangoTabArray> = <_PangoTabArray>;
+define C-struct <_PangoTabArray>
+end;
+
+define C-pointer-type <PangoTabArray> => <_PangoTabArray>;
define constant <PangoTabAlign> = <C-int>;
define constant $PANGO-TAB-LEFT = 0;
@@ -15445,25 +16685,46 @@
define constant $PANGO-UNDERLINE-LOW = 3;
define constant $PANGO-UNDERLINE-ERROR = 4;
-define C-subtype <_PangoRendererPrivate> (<C-void*>) end;
-define constant <PangoRendererPrivate> = <_PangoRendererPrivate>;
+define C-struct <_PangoRendererPrivate>
+end;
+
+define C-pointer-type <PangoRendererPrivate> => <_PangoRendererPrivate>;
define C-subtype <_PangoRenderer> (<_GObject>) end;
define constant <PangoRenderer> = <_PangoRenderer>;
define constant <PangoGlyphUnit> = <gint32>;
-define C-subtype <_PangoGlyphGeometry> (<C-void*>) end;
-define constant <PangoGlyphGeometry> = <_PangoGlyphGeometry>;
+define C-struct <_PangoGlyphGeometry>
+ slot PangoGlyphGeometry-width :: <C-signed-int>;
+ slot PangoGlyphGeometry-x-offset :: <C-signed-int>;
+ slot PangoGlyphGeometry-y-offset :: <C-signed-int>;
+end;
+
+define C-pointer-type <PangoGlyphGeometry> => <_PangoGlyphGeometry>;
+
+define C-struct <_PangoGlyphVisAttr>
+ bitfield slot PangoGlyphVisAttr-is-cluster-start :: <C-int>, width: 1;
+end;
-define C-subtype <_PangoGlyphVisAttr> (<C-void*>) end;
-define constant <PangoGlyphVisAttr> = <_PangoGlyphVisAttr>;
+define C-pointer-type <PangoGlyphVisAttr> => <_PangoGlyphVisAttr>;
-define C-subtype <_PangoGlyphInfo> (<C-void*>) end;
-define constant <PangoGlyphInfo> = <_PangoGlyphInfo>;
+define C-struct <_PangoGlyphInfo>
+ slot PangoGlyphInfo-glyph :: <C-unsigned-int>;
+ slot PangoGlyphInfo-geometry :: <_PangoGlyphGeometry>;
+ slot PangoGlyphInfo-attr :: <_PangoGlyphVisAttr>;
+end;
+
+define C-pointer-type <PangoGlyphInfo> => <_PangoGlyphInfo>;
+
+define C-struct <_PangoGlyphString>
+ slot PangoGlyphString-num-glyphs :: <C-signed-int>;
+ slot PangoGlyphString-glyphs :: <PangoGlyphInfo>;
+ slot PangoGlyphString-log-clusters :: <gint*>;
+ slot PangoGlyphString-space :: <C-signed-int>;
+end;
-define C-subtype <_PangoGlyphString> (<C-void*>) end;
-define constant <PangoGlyphString> = <_PangoGlyphString>;
+define C-pointer-type <PangoGlyphString> => <_PangoGlyphString>;
define constant <anonymous-2151> = <C-function-pointer>;
define constant <PangoRenderPart> = <C-int>;
@@ -15502,17 +16763,36 @@
define constant <anonymous-1920> = <C-function-pointer>;
define constant <anonymous-1921> = <C-function-pointer>;
define constant <anonymous-1922> = <C-function-pointer>;
-define C-subtype <_PangoAttrClass> (<C-void*>) end;
-define constant <PangoAttrClass> = <_PangoAttrClass>;
+define C-struct <_PangoAttrClass>
+ slot PangoAttrClass-type :: <PangoAttrType>;
+ slot PangoAttrClass-copy :: <anonymous-1920>;
+ slot PangoAttrClass-destroy :: <anonymous-1921>;
+ slot PangoAttrClass-equal :: <anonymous-1922>;
+end;
+
+define C-pointer-type <PangoAttrClass> => <_PangoAttrClass>;
+
+define C-struct <_PangoAttribute>
+ slot PangoAttribute-klass :: <PangoAttrClass>;
+ slot PangoAttribute-start-index :: <C-unsigned-int>;
+ slot PangoAttribute-end-index :: <C-unsigned-int>;
+end;
-define C-subtype <_PangoAttribute> (<C-void*>) end;
-define constant <PangoAttribute> = <_PangoAttribute>;
+define C-pointer-type <PangoAttribute> => <_PangoAttribute>;
define constant <anonymous-1919> = <C-function-pointer>;
define constant <PangoAttrDataCopyFunc> = <anonymous-1919>;
-define C-subtype <_PangoAttrShape> (<C-void*>) end;
-define constant <PangoAttrShape> = <_PangoAttrShape>;
+define C-struct <_PangoAttrShape>
+ slot PangoAttrShape-attr :: <_PangoAttribute>;
+ slot PangoAttrShape-ink-rect :: <_PangoRectangle>;
+ slot PangoAttrShape-logical-rect :: <_PangoRectangle>;
+ slot PangoAttrShape-data :: <C-void*>;
+ sl