[Gd-chatter] r11372 - branches/opendylan-melange/gtk-c-ffi
hannes at gwydiondylan.org
hannes at gwydiondylan.org
Wed May 23 13:48:35 CEST 2007
Author: hannes
Date: Wed May 23 13:48:33 2007
New Revision: 11372
Modified:
branches/opendylan-melange/gtk-c-ffi/gtk-2-8-linux.dylan
branches/opendylan-melange/gtk-c-ffi/gtk-2-8-linux.intr
branches/opendylan-melange/gtk-c-ffi/gtk-module-2-8-linux.dylan
Log:
Job: fd
merge changes from windows intr file
re-generate module and interface file
Modified: branches/opendylan-melange/gtk-c-ffi/gtk-2-8-linux.dylan
==============================================================================
--- branches/opendylan-melange/gtk-c-ffi/gtk-2-8-linux.dylan (original)
+++ branches/opendylan-melange/gtk-c-ffi/gtk-2-8-linux.dylan Wed May 23 13:48:33 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 <GObject> = <_GObject>;
@@ -30,12 +35,20 @@
define constant <gchar> = <C-signed-char>;
define constant <gchar*> = <C-string>;
-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>;
@@ -65,7 +78,9 @@
define C-pointer-type <GdkGC*> => <GdkGC>;
define constant <GdkGC<@5>> = <GdkGC*>;
define C-subtype <_GdkDrawable> (<_GObject>) end;
-define constant <GdkPixmap> = <_GdkDrawable>;
+define C-subtype <_GdkPixmap> (<_GdkDrawable>) end;
+
+define constant <GdkPixmap> = <_GdkPixmap>;
define C-pointer-type <GdkPixmap*> => <GdkPixmap>;
define constant <GdkPixmap<@5>> = <GdkPixmap*>;
@@ -73,8 +88,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**>;
@@ -86,11 +106,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-subtype <_GSList> (<C-void*>) end;
-define constant <GSList> = <_GSList>;
+define C-pointer-type <GArray> => <_GArray>;
+
+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>;
@@ -98,15 +126,27 @@
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-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-subtype <_GdkRectangle> (<C-void*>) end;
-define constant <GdkRectangle> = <_GdkRectangle>;
+define C-pointer-type <GdkRectangle> => <_GdkRectangle>;
define constant <GtkAllocation> = <GdkRectangle>;
-define constant <GdkWindow> = <_GdkDrawable>;
+define C-subtype <_GdkWindow> (<_GdkDrawable>) end;
+
+define constant <GdkWindow> = <_GdkWindow>;
define C-subtype <_GtkWidget> (<_GtkObject>, <_AtkImplementorIface>) end;
define constant <GtkWidget> = <_GtkWidget>;
@@ -119,8 +159,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>;
@@ -139,12 +181,12 @@
define constant $GDK-BUTTON3-MASK = 1024;
define constant $GDK-BUTTON4-MASK = 2048;
define constant $GDK-BUTTON5-MASK = 4096;
-//define constant $GDK-RELEASE-MASK = #ex0000000040000000;
-//define constant $GDK-MODIFIER-MASK = #ex0000000040001FFF;
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>;
@@ -161,8 +203,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>;
@@ -176,11 +230,19 @@
define C-subtype <anonymous-1398> (<C-void*>) end;
define constant <anonymous-1398<@2>> = <anonymous-1398>;
-define C-subtype <_GValue> (<C-void*>) end;
-define constant <GValue> = <_GValue>;
+define C-struct <_GValue>
+ slot GValue-g-type :: <C-unsigned-long>;
+ array slot GValue-data :: <anonymous-1398>, length: 2;
+end;
+
+define C-pointer-type <GValue> => <_GValue>;
-define C-subtype <_GObjectConstructParam> (<C-void*>) end;
-define constant <GObjectConstructParam> = <_GObjectConstructParam>;
+define C-struct <_GObjectConstructParam>
+ slot GObjectConstructParam-pspec :: <GParamSpec>;
+ slot GObjectConstructParam-value :: <GValue>;
+end;
+
+define C-pointer-type <GObjectConstructParam> => <_GObjectConstructParam>;
define constant <anonymous-1544> = <C-function-pointer>;
define constant <anonymous-1545> = <C-function-pointer>;
@@ -192,8 +254,20 @@
define constant <anonymous-1550> = <C-function-pointer>;
define C-pointer-type <gpointer*> => <gpointer>;
define constant <gpointer<@8>> = <gpointer*>;
-define C-subtype <_GObjectClass> (<C-void*>) end;
-define constant <GObjectClass> = <_GObjectClass>;
+define C-struct <_GObjectClass>
+ slot GObjectClass-g-type-class :: <_GTypeClass>;
+ slot GObjectClass-construct-properties :: <GSList>;
+ slot GObjectClass-constructor :: <anonymous-1544>;
+ slot GObjectClass-set-property :: <anonymous-1545>;
+ slot GObjectClass-get-property :: <anonymous-1546>;
+ slot GObjectClass-dispose :: <anonymous-1547>;
+ slot GObjectClass-finalize :: <anonymous-1548>;
+ slot GObjectClass-dispatch-properties-changed :: <anonymous-1549>;
+ slot GObjectClass-notify :: <anonymous-1550>;
+ array slot GObjectClass-pdummy :: <gpointer>, length: 8;
+end;
+
+define C-pointer-type <GObjectClass> => <_GObjectClass>;
define constant <GtkType> = <GType>;
@@ -204,16 +278,31 @@
define constant <anonymous-3156> = <C-function-pointer>;
define constant <GtkSignalFunc> = <anonymous-3156>;
-define C-subtype <anonymous-3157> (<C-void*>) end;
+define C-struct <anonymous-3157>
+ slot nonymous-3157-f :: <anonymous-3156>;
+ slot nonymous-3157-d :: <C-void*>;
+end;
+
define C-subtype <anonymous-3158> (<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-3158>;
+end;
+
+define C-pointer-type <GtkArg> => <_GtkArg>;
define constant <anonymous-3169> = <C-function-pointer>;
define constant <anonymous-3170> = <C-function-pointer>;
define constant <anonymous-3171> = <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-3169>;
+ slot GtkObjectClass-get-arg :: <anonymous-3170>;
+ slot GtkObjectClass-destroy :: <anonymous-3171>;
+end;
+
+define C-pointer-type <GtkObjectClass> => <_GtkObjectClass>;
define constant <anonymous-3439> = <C-function-pointer>;
define constant <anonymous-3440> = <C-function-pointer>;
@@ -297,25 +386,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-subtype <_GdkRegion> (<C-void*>) end;
-define constant <GdkRegion> = <_GdkRegion>;
+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 <_GdkEventExpose> (<C-void*>) end;
-define constant <GdkEventExpose> = <_GdkEventExpose>;
+define C-pointer-type <GdkEventExpose> => <_GdkEventExpose>;
-define C-subtype <_GdkEventNoExpose> (<C-void*>) end;
-define constant <GdkEventNoExpose> = <_GdkEventNoExpose>;
+define C-struct <_GdkEventNoExpose>
+ slot GdkEventNoExpose-type :: <GdkEventType>;
+ slot GdkEventNoExpose-window :: <GdkWindow>;
+ slot GdkEventNoExpose-send-event :: <C-signed-char>;
+end;
+
+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>;
@@ -341,20 +456,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-struct <_GdkDeviceKey>
+ slot GdkDeviceKey-keyval :: <C-unsigned-int>;
+ slot GdkDeviceKey-modifiers :: <GdkModifierType>;
+end;
-define C-subtype <_GdkDeviceKey> (<C-void*>) end;
-define constant <GdkDeviceKey> = <_GdkDeviceKey>;
+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;
@@ -362,11 +514,36 @@
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>;
+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;
@@ -381,36 +558,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>;
@@ -421,8 +665,16 @@
define C-pointer-type <long*> => <C-signed-long>;
define constant <long<@5>> = <long*>;
define C-subtype <anonymous-2397> (<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-2397>;
+end;
+
+define C-pointer-type <GdkEventClient> => <_GdkEventClient>;
define constant <GdkDragProtocol> = <C-int>;
define constant $GDK-DRAG-PROTO-MOTIF = 0;
@@ -433,8 +685,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;
@@ -449,8 +706,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;
@@ -461,19 +727,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>;
@@ -517,14 +805,28 @@
define constant <anonymous-2425> = <C-function-pointer>;
define constant <anonymous-2426> = <C-function-pointer>;
define constant <anonymous-2427> = <C-function-pointer>;
-define C-subtype <_GdkDisplayPointerHooks> (<C-void*>) end;
-define constant <GdkDisplayPointerHooks> = <_GdkDisplayPointerHooks>;
+define C-struct <_GdkDisplayPointerHooks>
+ slot GdkDisplayPointerHooks-get-pointer :: <anonymous-2425>;
+ slot GdkDisplayPointerHooks-window-get-pointer :: <anonymous-2426>;
+ slot GdkDisplayPointerHooks-window-at-pointer :: <anonymous-2427>;
+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-3487> = <C-function-pointer>;
define constant <anonymous-3488> = <C-function-pointer>;
@@ -630,8 +932,12 @@
define constant $ATK-ROLE-REDUNDANT-OBJECT = 84;
define constant $ATK-ROLE-LAST-DEFINED = 85;
-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>;
@@ -658,8 +964,82 @@
define constant <anonymous-3505> = <C-function-pointer>;
define constant <anonymous-3506> = <C-function-pointer>;
define constant <anonymous-3507> = <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-3439>;
+ slot GtkWidgetClass-show :: <anonymous-3440>;
+ slot GtkWidgetClass-show-all :: <anonymous-3441>;
+ slot GtkWidgetClass-hide :: <anonymous-3442>;
+ slot GtkWidgetClass-hide-all :: <anonymous-3443>;
+ slot GtkWidgetClass-map :: <anonymous-3444>;
+ slot GtkWidgetClass-unmap :: <anonymous-3445>;
+ slot GtkWidgetClass-realize :: <anonymous-3446>;
+ slot GtkWidgetClass-unrealize :: <anonymous-3447>;
+ slot GtkWidgetClass-size-request :: <anonymous-3448>;
+ slot GtkWidgetClass-size-allocate :: <anonymous-3449>;
+ slot GtkWidgetClass-state-changed :: <anonymous-3450>;
+ slot GtkWidgetClass-parent-set :: <anonymous-3451>;
+ slot GtkWidgetClass-hierarchy-changed :: <anonymous-3452>;
+ slot GtkWidgetClass-style-set :: <anonymous-3453>;
+ slot GtkWidgetClass-direction-changed :: <anonymous-3454>;
+ slot GtkWidgetClass-grab-notify :: <anonymous-3455>;
+ slot GtkWidgetClass-child-notify :: <anonymous-3456>;
+ slot GtkWidgetClass-mnemonic-activate :: <anonymous-3457>;
+ slot GtkWidgetClass-grab-focus :: <anonymous-3458>;
+ slot GtkWidgetClass-focus :: <anonymous-3459>;
+ slot GtkWidgetClass-event :: <anonymous-3460>;
+ slot GtkWidgetClass-button-press-event :: <anonymous-3461>;
+ slot GtkWidgetClass-button-release-event :: <anonymous-3462>;
+ slot GtkWidgetClass-scroll-event :: <anonymous-3463>;
+ slot GtkWidgetClass-motion-notify-event :: <anonymous-3464>;
+ slot GtkWidgetClass-delete-event :: <anonymous-3465>;
+ slot GtkWidgetClass-destroy-event :: <anonymous-3466>;
+ slot GtkWidgetClass-expose-event :: <anonymous-3467>;
+ slot GtkWidgetClass-key-press-event :: <anonymous-3468>;
+ slot GtkWidgetClass-key-release-event :: <anonymous-3469>;
+ slot GtkWidgetClass-enter-notify-event :: <anonymous-3470>;
+ slot GtkWidgetClass-leave-notify-event :: <anonymous-3471>;
+ slot GtkWidgetClass-configure-event :: <anonymous-3472>;
+ slot GtkWidgetClass-focus-in-event :: <anonymous-3473>;
+ slot GtkWidgetClass-focus-out-event :: <anonymous-3474>;
+ slot GtkWidgetClass-map-event :: <anonymous-3475>;
+ slot GtkWidgetClass-unmap-event :: <anonymous-3476>;
+ slot GtkWidgetClass-property-notify-event :: <anonymous-3477>;
+ slot GtkWidgetClass-selection-clear-event :: <anonymous-3478>;
+ slot GtkWidgetClass-selection-request-event :: <anonymous-3479>;
+ slot GtkWidgetClass-selection-notify-event :: <anonymous-3480>;
+ slot GtkWidgetClass-proximity-in-event :: <anonymous-3481>;
+ slot GtkWidgetClass-proximity-out-event :: <anonymous-3482>;
+ slot GtkWidgetClass-visibility-notify-event :: <anonymous-3483>;
+ slot GtkWidgetClass-client-event :: <anonymous-3484>;
+ slot GtkWidgetClass-no-expose-event :: <anonymous-3485>;
+ slot GtkWidgetClass-window-state-event :: <anonymous-3486>;
+ slot GtkWidgetClass-selection-get :: <anonymous-3487>;
+ slot GtkWidgetClass-selection-received :: <anonymous-3488>;
+ slot GtkWidgetClass-drag-begin :: <anonymous-3489>;
+ slot GtkWidgetClass-drag-end :: <anonymous-3490>;
+ slot GtkWidgetClass-drag-data-get :: <anonymous-3491>;
+ slot GtkWidgetClass-drag-data-delete :: <anonymous-3492>;
+ slot GtkWidgetClass-drag-leave :: <anonymous-3493>;
+ slot GtkWidgetClass-drag-motion :: <anonymous-3494>;
+ slot GtkWidgetClass-drag-drop :: <anonymous-3495>;
+ slot GtkWidgetClass-drag-data-received :: <anonymous-3496>;
+ slot GtkWidgetClass-popup-menu :: <anonymous-3497>;
+ slot GtkWidgetClass-show-help :: <anonymous-3498>;
+ slot GtkWidgetClass-get-accessible :: <anonymous-3499>;
+ slot GtkWidgetClass-screen-changed :: <anonymous-3500>;
+ slot GtkWidgetClass-can-activate-accel :: <anonymous-3501>;
+ slot GtkWidgetClass-grab-broken-event :: <anonymous-3502>;
+ slot GtkWidgetClass-_gtk-reserved3 :: <anonymous-3503>;
+ slot GtkWidgetClass-_gtk-reserved4 :: <anonymous-3504>;
+ slot GtkWidgetClass-_gtk-reserved5 :: <anonymous-3505>;
+ slot GtkWidgetClass-_gtk-reserved6 :: <anonymous-3506>;
+ slot GtkWidgetClass-_gtk-reserved7 :: <anonymous-3507>;
+end;
+
+define C-pointer-type <GtkWidgetClass> => <_GtkWidgetClass>;
define constant <anonymous-3654> = <C-function-pointer>;
define constant <anonymous-3655> = <C-function-pointer>;
@@ -677,11 +1057,30 @@
define constant <anonymous-3664> = <C-function-pointer>;
define constant <anonymous-3665> = <C-function-pointer>;
define constant <anonymous-3666> = <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-3654>;
+ slot GtkContainerClass-remove :: <anonymous-3655>;
+ slot GtkContainerClass-check-resize :: <anonymous-3656>;
+ slot GtkContainerClass-forall :: <anonymous-3657>;
+ slot GtkContainerClass-set-focus-child :: <anonymous-3658>;
+ slot GtkContainerClass-child-type :: <anonymous-3659>;
+ slot GtkContainerClass-composite-name :: <anonymous-3660>;
+ slot GtkContainerClass-set-child-property :: <anonymous-3661>;
+ slot GtkContainerClass-get-child-property :: <anonymous-3662>;
+ slot GtkContainerClass-_gtk-reserved1 :: <anonymous-3663>;
+ slot GtkContainerClass-_gtk-reserved2 :: <anonymous-3664>;
+ slot GtkContainerClass-_gtk-reserved3 :: <anonymous-3665>;
+ slot GtkContainerClass-_gtk-reserved4 :: <anonymous-3666>;
+end;
+
+define C-pointer-type <GtkContainerClass> => <_GtkContainerClass>;
-define C-subtype <_GtkBinClass> (<C-void*>) end;
-define constant <GtkBinClass> = <_GtkBinClass>;
+define C-struct <_GtkBinClass>
+ slot GtkBinClass-parent-class :: <_GtkContainerClass>;
+end;
+
+define C-pointer-type <GtkBinClass> => <_GtkBinClass>;
define constant <anonymous-3728> = <C-function-pointer>;
define constant <anonymous-3729> = <C-function-pointer>;
@@ -693,15 +1092,35 @@
define constant <anonymous-3735> = <C-function-pointer>;
define constant <anonymous-3736> = <C-function-pointer>;
define constant <anonymous-3737> = <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-3728>;
+ slot GtkWindowClass-frame-event :: <anonymous-3729>;
+ slot GtkWindowClass-activate-focus :: <anonymous-3730>;
+ slot GtkWindowClass-activate-default :: <anonymous-3731>;
+ slot GtkWindowClass-move-focus :: <anonymous-3732>;
+ slot GtkWindowClass-keys-changed :: <anonymous-3733>;
+ slot GtkWindowClass-_gtk-reserved1 :: <anonymous-3734>;
+ slot GtkWindowClass-_gtk-reserved2 :: <anonymous-3735>;
+ slot GtkWindowClass-_gtk-reserved3 :: <anonymous-3736>;
+ slot GtkWindowClass-_gtk-reserved4 :: <anonymous-3737>;
+end;
+
+define C-pointer-type <GtkWindowClass> => <_GtkWindowClass>;
define constant <anonymous-3738> = <C-function-pointer>;
define constant <anonymous-3739> = <C-function-pointer>;
define constant <anonymous-3740> = <C-function-pointer>;
define constant <anonymous-3741> = <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-3738>;
+ slot GtkWindowGroupClass-_gtk-reserved2 :: <anonymous-3739>;
+ slot GtkWindowGroupClass-_gtk-reserved3 :: <anonymous-3740>;
+ slot GtkWindowGroupClass-_gtk-reserved4 :: <anonymous-3741>;
+end;
+
+define C-pointer-type <GtkWindowGroupClass> => <_GtkWindowGroupClass>;
define C-function gtk-window-get-type
result res :: <GType>;
@@ -749,23 +1168,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-1464> = <C-function-pointer>;
define constant <anonymous-1452> = <C-function-pointer>;
define constant <GClosureNotify> = <anonymous-1452>;
-define C-subtype <_GClosureNotifyData> (<C-void*>) end;
-define constant <GClosureNotifyData> = <_GClosureNotifyData>;
+define C-struct <_GClosureNotifyData>
+ slot GClosureNotifyData-data :: <C-void*>;
+ slot GClosureNotifyData-notify :: <anonymous-1452>;
+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-1464>;
+ 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>;
@@ -967,8 +1415,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;
@@ -1082,8 +1543,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
@@ -1423,13 +1889,28 @@
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 C-subtype <_GdkBitmap> (<_GdkDrawable>) end;
-define constant <GdkBitmap> = <_GdkDrawable>;
+define constant <GdkBitmap> = <_GdkBitmap>;
+
+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-subtype <_GtkWidgetShapeInfo> (<C-void*>) end;
-define constant <GtkWidgetShapeInfo> = <_GtkWidgetShapeInfo>;
+define C-pointer-type <GtkWidgetShapeInfo> => <_GtkWidgetShapeInfo>;
define C-subtype <_GtkClipboard> (<_GObject>) end;
define constant <GtkClipboard> = <_GtkClipboard>;
@@ -1925,11 +2406,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>;
@@ -2144,8 +2629,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-3209> = <C-function-pointer>;
define constant <GtkRcPropertyParser> = <anonymous-3209>;
@@ -2309,14 +2799,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-subtype <_AtkImplementor> (<C-void*>) end;
-define constant <AtkImplementor> = <_AtkImplementor>;
+define C-struct <_AtkImplementor>
+end;
+
+define C-pointer-type <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-3408> = <C-function-pointer>;
define C-subtype <_AtkImplementorIface> (<C-void*>) end;
@@ -2340,8 +2840,13 @@
define constant <anonymous-3394> = <C-function-pointer>;
define constant <anonymous-3395> = <C-function-pointer>;
define constant <anonymous-3396> = <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-3381> = <C-function-pointer>;
define constant <AtkPropertyChangeHandler> = <anonymous-3381>;
@@ -2360,8 +2865,38 @@
define constant <anonymous-3380> = <C-function-pointer>;
define constant <AtkFunction> = <anonymous-3380>;
-define C-subtype <_AtkObjectClass> (<C-void*>) end;
-define constant <AtkObjectClass> = <_AtkObjectClass>;
+define C-struct <_AtkObjectClass>
+ slot AtkObjectClass-parent :: <_GObjectClass>;
+ slot AtkObjectClass-get-name :: <anonymous-3382>;
+ slot AtkObjectClass-get-description :: <anonymous-3383>;
+ slot AtkObjectClass-get-parent :: <anonymous-3384>;
+ slot AtkObjectClass-get-n-children :: <anonymous-3385>;
+ slot AtkObjectClass-ref-child :: <anonymous-3386>;
+ slot AtkObjectClass-get-index-in-parent :: <anonymous-3387>;
+ slot AtkObjectClass-ref-relation-set :: <anonymous-3388>;
+ slot AtkObjectClass-get-role :: <anonymous-3389>;
+ slot AtkObjectClass-get-layer :: <anonymous-3390>;
+ slot AtkObjectClass-get-mdi-zorder :: <anonymous-3391>;
+ slot AtkObjectClass-ref-state-set :: <anonymous-3392>;
+ slot AtkObjectClass-set-name :: <anonymous-3393>;
+ slot AtkObjectClass-set-description :: <anonymous-3394>;
+ slot AtkObjectClass-set-parent :: <anonymous-3395>;
+ slot AtkObjectClass-set-role :: <anonymous-3396>;
+ slot AtkObjectClass-connect-property-change-handler :: <anonymous-3397>;
+ slot AtkObjectClass-remove-property-change-handler :: <anonymous-3398>;
+ slot AtkObjectClass-initialize :: <anonymous-3399>;
+ slot AtkObjectClass-children-changed :: <anonymous-3400>;
+ slot AtkObjectClass-focus-event :: <anonymous-3401>;
+ slot AtkObjectClass-property-change :: <anonymous-3402>;
+ slot AtkObjectClass-state-change :: <anonymous-3403>;
+ slot AtkObjectClass-visible-data-changed :: <anonymous-3404>;
+ slot AtkObjectClass-active-descendant-changed :: <anonymous-3405>;
+ slot AtkObjectClass-get-attributes :: <anonymous-3406>;
+ slot AtkObjectClass-pad1 :: <anonymous-3380>;
+ slot AtkObjectClass-pad2 :: <anonymous-3380>;
+end;
+
+define C-pointer-type <AtkObjectClass> => <_AtkObjectClass>;
define C-function atk-object-get-type
result res :: <GType>;
@@ -2901,8 +3436,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-1307> = <C-function-pointer>;
define constant <GBaseInitFunc> = <anonymous-1307>;
@@ -2927,11 +3464,33 @@
define constant <anonymous-1321> = <C-function-pointer>;
define constant <anonymous-1322> = <C-function-pointer>;
define constant <anonymous-1323> = <C-function-pointer>;
-define C-subtype <_GTypeValueTable> (<C-void*>) end;
-define constant <GTypeValueTable> = <_GTypeValueTable>;
+define C-struct <_GTypeValueTable>
+ slot GTypeValueTable-value-init :: <anonymous-1318>;
+ slot GTypeValueTable-value-free :: <anonymous-1319>;
+ slot GTypeValueTable-value-copy :: <anonymous-1320>;
+ slot GTypeValueTable-value-peek-pointer :: <anonymous-1321>;
+ slot GTypeValueTable-collect-format :: <gchar*>;
+ slot GTypeValueTable-collect-value :: <anonymous-1322>;
+ slot GTypeValueTable-lcopy-format :: <gchar*>;
+ slot GTypeValueTable-lcopy-value :: <anonymous-1323>;
+end;
+
+define C-pointer-type <GTypeValueTable> => <_GTypeValueTable>;
+
+define C-struct <_GTypeInfo>
+ slot GTypeInfo-class-size :: <C-unsigned-short>;
+ slot GTypeInfo-base-init :: <anonymous-1307>;
+ slot GTypeInfo-base-finalize :: <anonymous-1308>;
+ slot GTypeInfo-class-init :: <anonymous-1309>;
+ slot GTypeInfo-class-finalize :: <anonymous-1310>;
+ 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-1311>;
+ 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;
@@ -2939,8 +3498,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-1312> = <C-function-pointer>;
define constant <GInterfaceInitFunc> = <anonymous-1312>;
@@ -2948,11 +3510,22 @@
define constant <anonymous-1313> = <C-function-pointer>;
define constant <GInterfaceFinalizeFunc> = <anonymous-1313>;
-define C-subtype <_GInterfaceInfo> (<C-void*>) end;
-define constant <GInterfaceInfo> = <_GInterfaceInfo>;
+define C-struct <_GInterfaceInfo>
+ slot GInterfaceInfo-interface-init :: <anonymous-1312>;
+ slot GInterfaceInfo-interface-finalize :: <anonymous-1313>;
+ slot GInterfaceInfo-interface-data :: <C-void*>;
+end;
+
+define C-pointer-type <GInterfaceInfo> => <_GInterfaceInfo>;
+
+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-subtype <_GTypeQuery> (<C-void*>) end;
-define constant <GTypeQuery> = <_GTypeQuery>;
+define C-pointer-type <GTypeQuery> => <_GTypeQuery>;
define constant <GTypeDebugFlags> = <C-int>;
define constant $G-TYPE-DEBUG-NONE = 0;
@@ -3461,8 +4034,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*>;
@@ -3587,9 +4164,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*>;
@@ -3665,24 +4245,37 @@
define constant <anonymous-182> = <C-function-pointer>;
define constant <GTranslateFunc> = <anonymous-182>;
-define C-subtype <anonymous-191> (<C-void*>) end;
+define C-struct <anonymous-191>
+ bitfield slot nonymous-191-mantissa-low :: <C-int>, width: 32;
+ bitfield slot nonymous-191-mantissa-high :: <C-int>, width: 20;
+ bitfield slot nonymous-191-biased-exponent :: <C-int>, width: 11;
+ bitfield slot nonymous-191-sign :: <C-int>, width: 1;
+end;
+
define C-subtype <_GDoubleIEEE754> (<C-void*>) end;
define constant <GDoubleIEEE754> = <_GDoubleIEEE754>;
-define C-subtype <anonymous-186> (<C-void*>) end;
+define C-struct <anonymous-186>
+ bitfield slot nonymous-186-mantissa :: <C-int>, width: 23;
+ bitfield slot nonymous-186-biased-exponent :: <C-int>, width: 8;
+ bitfield slot nonymous-186-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;
define constant $G-MAXUINT16 = 65535;
-//define constant $G-MAXUINT32 = #ex00000000FFFFFFFF;
-//define constant $G-MAXINT64 = #ex7FFFFFFFFFFFFFFF;
define constant $G-LITTLE-ENDIAN = 1234;
@@ -3698,11 +4291,17 @@
define constant <gssize> = <C-signed-int>;
-define C-subtype <_GMutex> (<C-void*>) end;
+define C-struct <_GMutex>
+end;
+
define constant <char<@24>> = <char*>;
define C-subtype <anonymous-173> (<C-void*>) end;
-define C-subtype <_GStaticMutex> (<C-void*>) end;
-define constant <GStaticMutex> = <_GStaticMutex>;
+define C-struct <_GStaticMutex>
+ slot GStaticMutex-runtime-mutex :: <_GMutex>;
+ slot GStaticMutex-static-mutex :: <anonymous-173>;
+end;
+
+define C-pointer-type <GStaticMutex> => <_GStaticMutex>;
define constant <char<@4>> = <char*>;
define C-subtype <_GSystemThread> (<C-void*>) end;
@@ -3716,17 +4315,11 @@
define constant $G-MAXUSHORT = 65535;
-//define constant $G-MININT = #exFFFFFFFF80000000;
-//define constant $G-MAXINT = #ex000000007FFFFFFF;
-//define constant $G-MAXUINT = #ex00000000FFFFFFFF;
-//define constant $G-MINLONG = #exFFFFFFFF80000000;
-//define constant $G-MAXLONG = #ex000000007FFFFFFF;
-//define constant $G-MAXULONG = #ex00000000FFFFFFFF;
define constant $G-GINT16-MODIFIER = "h";
@@ -3760,7 +4353,6 @@
define constant $G-GSIZE-FORMAT = "u";
-//define constant $G-MAXSIZE = #ex00000000FFFFFFFF;
define constant $GLIB-MAJOR-VERSION = 2;
@@ -3812,17 +4404,11 @@
define constant $USHRT-MAX = 65535;
-//define constant $INT-MIN = #exFFFFFFFF80000000;
-//define constant $INT-MAX = #ex000000007FFFFFFF;
-//define constant $UINT-MAX = #ex00000000FFFFFFFF;
-//define constant $LONG-MAX = #ex000000007FFFFFFF;
-//define constant $LONG-MIN = #exFFFFFFFF80000000;
-//define constant $ULONG-MAX = #ex00000000FFFFFFFF;
define constant $_BITS-POSIX2-LIM-H = 1;
@@ -3932,7 +4518,6 @@
define constant $_POSIX-CLOCKRES-MIN = 20000000;
-//define constant $SSIZE-MAX = #ex000000007FFFFFFF;
define constant $_POSIX-THREAD-KEYS-MAX = 128;
@@ -3952,7 +4537,6 @@
define constant $TIMER-MAX = 256;
-//define constant $DELAYTIMER-MAX = #ex000000007FFFFFFF;
define constant $TTY-NAME-MAX = 32;
@@ -4032,8 +4616,6 @@
define constant <__ptr-t> = <C-void*>;
-//define constant <__long-double-t> = <C-extended>;
-
define constant $G-GNUC-FUNCTION = "";
define constant $G-GNUC-PRETTY-FUNCTION = "";
@@ -4614,8 +5196,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-1256> = <C-function-pointer>;
define constant <GTraverseFunc> = <anonymous-1256>;
@@ -4732,9 +5316,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;
@@ -4945,8 +5536,16 @@
define constant <anonymous-351> = <C-function-pointer>;
define constant <anonymous-352> = <C-function-pointer>;
define constant <anonymous-353> = <C-function-pointer>;
-define C-subtype <_GMemVTable> (<C-void*>) end;
-define constant <GMemVTable> = <_GMemVTable>;
+define C-struct <_GMemVTable>
+ slot GMemVTable-malloc :: <anonymous-348>;
+ slot GMemVTable-realloc :: <anonymous-349>;
+ slot GMemVTable-free :: <anonymous-350>;
+ slot GMemVTable-calloc :: <anonymous-351>;
+ slot GMemVTable-try-malloc :: <anonymous-352>;
+ slot GMemVTable-try-realloc :: <anonymous-353>;
+end;
+
+define C-pointer-type <GMemVTable> => <_GMemVTable>;
define C-function g-malloc
input parameter arg1 :: <gulong>;
@@ -5007,11 +5606,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-subtype <_GMemChunk> (<C-void*>) end;
-define constant <GMemChunk> = <_GMemChunk>;
+define C-struct <_GMemChunk>
+end;
+
+define C-pointer-type <GMemChunk> => <_GMemChunk>;
define C-function g-mem-chunk-new
input parameter arg1 :: <gchar*>;
@@ -5146,8 +5749,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>;
@@ -5200,8 +5805,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-178>;
+ 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>;
@@ -5305,19 +5915,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-253>;
+ 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-255> = <C-function-pointer>;
define constant <anonymous-256> = <C-function-pointer>;
@@ -5340,8 +5963,31 @@
define constant <anonymous-273> = <C-function-pointer>;
define constant <anonymous-274> = <C-function-pointer>;
define constant <anonymous-275> = <C-function-pointer>;
-define C-subtype <_GThreadFunctions> (<C-void*>) end;
-define constant <GThreadFunctions> = <_GThreadFunctions>;
+define C-struct <_GThreadFunctions>
+ slot GThreadFunctions-mutex-new :: <anonymous-255>;
+ slot GThreadFunctions-mutex-lock :: <anonymous-256>;
+ slot GThreadFunctions-mutex-trylock :: <anonymous-257>;
+ slot GThreadFunctions-mutex-unlock :: <anonymous-258>;
+ slot GThreadFunctions-mutex-free :: <anonymous-259>;
+ slot GThreadFunctions-cond-new :: <anonymous-260>;
+ slot GThreadFunctions-cond-signal :: <anonymous-261>;
+ slot GThreadFunctions-cond-broadcast :: <anonymous-262>;
+ slot GThreadFunctions-cond-wait :: <anonymous-263>;
+ slot GThreadFunctions-cond-timed-wait :: <anonymous-264>;
+ slot GThreadFunctions-cond-free :: <anonymous-265>;
+ slot GThreadFunctions-private-new :: <anonymous-266>;
+ slot GThreadFunctions-private-get :: <anonymous-267>;
+ slot GThreadFunctions-private-set :: <anonymous-268>;
+ slot GThreadFunctions-thread-create :: <anonymous-269>;
+ slot GThreadFunctions-thread-yield :: <anonymous-270>;
+ slot GThreadFunctions-thread-join :: <anonymous-271>;
+ slot GThreadFunctions-thread-exit :: <anonymous-272>;
+ slot GThreadFunctions-thread-set-priority :: <anonymous-273>;
+ slot GThreadFunctions-thread-self :: <anonymous-274>;
+ slot GThreadFunctions-thread-equal :: <anonymous-275>;
+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"*/
@@ -5420,8 +6066,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 :: <_GStaticMutex>;
+ 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>;
@@ -5461,8 +6112,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 :: <_GStaticMutex>;
+ 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>;
@@ -5517,8 +6177,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>;
@@ -5528,7 +6192,6 @@
c-name: "g_once_impl";
end;
-//define constant $G-MUTEX-DEBUG-MAGIC = #ex00000000F8E18AD7;
define C-function g-atomic-int-exchange-and-add
input parameter arg1 :: <gint*>;
@@ -5583,8 +6246,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>;
@@ -5802,6 +6467,13 @@
c-name: "g_string_append_printf";
end;
+define C-function g-string-append-c-inline
+ input parameter arg1 :: <GString>;
+ input parameter arg2 :: <gchar>;
+ result res :: <GString>;
+ c-name: "g_string_append_c_inline";
+end;
+
define C-function g-string-down
input parameter arg1 :: <GString>;
result res :: <GString>;
@@ -6510,8 +7182,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;
@@ -6542,15 +7243,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-1122> = <C-function-pointer>;
define constant <GScannerMsgFunc> = <anonymous-1122>;
-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-1122>;
+end;
+
define constant <GErrorType> = <C-int>;
define constant $G-ERR-UNKNOWN = 0;
define constant $G-ERR-UNEXP-EOF = 1;
@@ -6950,11 +7676,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>;
@@ -7028,8 +7759,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>;
@@ -7130,8 +7863,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>;
@@ -7594,8 +8332,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*>;
@@ -7638,11 +8378,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-struct <_GOptionGroup>
+end;
-define C-subtype <_GOptionGroup> (<C-void*>) end;
-define constant <GOptionGroup> = <_GOptionGroup>;
+define C-pointer-type <GOptionGroup> => <_GOptionGroup>;
define constant <GOptionArg> = <C-int>;
define constant $G-OPTION-ARG-NONE = 0;
@@ -7653,8 +8397,17 @@
define constant $G-OPTION-ARG-STRING-ARRAY = 5;
define constant $G-OPTION-ARG-FILENAME-ARRAY = 6;
-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;
@@ -7943,16 +8696,25 @@
define constant <GMarkupParseFlags> = <C-int>;
define constant $G-MARKUP-DO-NOT-USE-THIS-UNSUPPORTED-FLAG = 1;
-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-959> = <C-function-pointer>;
define constant <anonymous-960> = <C-function-pointer>;
define constant <anonymous-961> = <C-function-pointer>;
define constant <anonymous-962> = <C-function-pointer>;
define constant <anonymous-963> = <C-function-pointer>;
-define C-subtype <_GMarkupParser> (<C-void*>) end;
-define constant <GMarkupParser> = <_GMarkupParser>;
+define C-struct <_GMarkupParser>
+ slot GMarkupParser-start-element :: <anonymous-959>;
+ slot GMarkupParser-end-element :: <anonymous-960>;
+ slot GMarkupParser-text :: <anonymous-961>;
+ slot GMarkupParser-passthrough :: <anonymous-962>;
+ slot GMarkupParser-error :: <anonymous-963>;
+end;
+
+define C-pointer-type <GMarkupParser> => <_GMarkupParser>;
define C-function g-markup-parse-context-new
input parameter arg1 :: <GMarkupParser>;
@@ -8017,8 +8779,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*>;
@@ -8045,23 +8809,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-struct <_GMainLoop>
+end;
-define C-subtype <_GMainLoop> (<C-void*>) end;
-define constant <GMainLoop> = <_GMainLoop>;
+define C-pointer-type <GMainLoop> => <_GMainLoop>;
define constant <anonymous-647> = <C-function-pointer>;
define constant <anonymous-648> = <C-function-pointer>;
-define constant <GSource> = <_GSource>;
+define C-pointer-type <GSource> => <_GSource>;
define constant <anonymous-645> = <C-function-pointer>;
define constant <GSourceFunc> = <anonymous-645>;
define C-pointer-type <GSourceFunc*> => <GSourceFunc>;
define constant <anonymous-649> = <C-function-pointer>;
-define C-subtype <_GSourceCallbackFuncs> (<C-void*>) end;
-define constant <GSourceCallbackFuncs> = <_GSourceCallbackFuncs>;
+define C-struct <_GSourceCallbackFuncs>
+ slot GSourceCallbackFuncs-ref :: <anonymous-647>;
+ slot GSourceCallbackFuncs-unref :: <anonymous-648>;
+ slot GSourceCallbackFuncs-get :: <anonymous-649>;
+end;
+
+define C-pointer-type <GSourceCallbackFuncs> => <_GSourceCallbackFuncs>;
define constant <anonymous-651> = <C-function-pointer>;
define constant <anonymous-652> = <C-function-pointer>;
@@ -8070,15 +8843,43 @@
define constant <anonymous-650> = <C-function-pointer>;
define constant <GSourceDummyMarshal> = <anonymous-650>;
-define C-subtype <_GSourceFuncs> (<C-void*>) end;
-define constant <GSourceFuncs> = <_GSourceFuncs>;
+define C-struct <_GSourceFuncs>
+ slot GSourceFuncs-prepare :: <anonymous-651>;
+ slot GSourceFuncs-check :: <anonymous-652>;
+ slot GSourceFuncs-dispatch :: <anonymous-653>;
+ slot GSourceFuncs-finalize :: <anonymous-654>;
+ slot GSourceFuncs-closure-callback :: <anonymous-645>;
+ slot GSourceFuncs-closure-marshal :: <anonymous-650>;
+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-646> = <C-function-pointer>;
define constant <GChildWatchFunc> = <anonymous-646>;
-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-655> = <C-function-pointer>;
define constant <GPollFunc> = <anonymous-655>;
@@ -8494,8 +9295,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;
@@ -8809,7 +9612,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-868> = <C-function-pointer>;
define constant <anonymous-869> = <C-function-pointer>;
@@ -8842,14 +9645,48 @@
define constant <anonymous-874> = <C-function-pointer>;
define constant <anonymous-875> = <C-function-pointer>;
-define C-subtype <_GIOFuncs> (<C-void*>) end;
-define constant <GIOFuncs> = <_GIOFuncs>;
+define C-struct <_GIOFuncs>
+ slot GIOFuncs-io-read :: <anonymous-868>;
+ slot GIOFuncs-io-write :: <anonymous-869>;
+ slot GIOFuncs-io-seek :: <anonymous-870>;
+ slot GIOFuncs-io-close :: <anonymous-871>;
+ slot GIOFuncs-io-create-watch :: <anonymous-872>;
+ slot GIOFuncs-io-free :: <anonymous-873>;
+ slot GIOFuncs-io-set-flags :: <anonymous-874>;
+ slot GIOFuncs-io-get-flags :: <anonymous-875>;
+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-unsigned-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>;
+ array slot GIOChannel-partial-write-buf :: <gchar>, length: 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;
@@ -9300,16 +10137,35 @@
c-name: "g_uri_list_extract_uris";
end;
-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-177>;
+end;
-define C-subtype <_GHook> (<C-void*>) end;
-define constant <GHookList> = <_GHookList>;
+define C-pointer-type <GHookList> => <_GHookList>;
define constant <anonymous-589> = <C-function-pointer>;
define constant <GHookFinalizeFunc> = <anonymous-589>;
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-589>;
+ array slot GHookList-dummy :: <gpointer>, length: 2;
+end;
+
define constant <anonymous-583> = <C-function-pointer>;
define constant <GHookCompareFunc> = <anonymous-583>;
@@ -9619,8 +10475,10 @@
c-name: "g_mkdir_with_parents";
end;
-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
input parameter arg1 :: <gchar*>;
@@ -9652,8 +10510,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;
@@ -9960,7 +10826,20 @@
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>;
+ slot m-tm-gmtoff :: <C-signed-long>;
+ slot m-tm-zone :: <char*>;
+end;
+
define C-function g-date-to-struct-tm
input parameter arg1 :: <GDate>;
input parameter arg2 :: <tm>;
@@ -10029,10 +10908,65 @@
define constant <timer-t> = <__timer-t>;
-define C-subtype <timespec> (<C-void*>) end;
-define C-subtype <itimerspec> (<C-void*>) end;
-define C-subtype <sigevent> (<C-void*>) end;
+define C-struct <timespec>
+ slot imespec-tv-sec :: <C-signed-long>;
+ slot imespec-tv-nsec :: <C-signed-long>;
+end;
+
+define C-struct <itimerspec>
+ slot timerspec-it-interval :: <timespec>;
+ slot timerspec-it-value :: <timespec>;
+end;
+
+define C-struct <sigevent>
+end;
+
+define C-function clock
+ result res :: <clock-t>;
+ c-name: "clock";
+end;
+
define C-pointer-type <time-t*> => <time-t>;
+define C-function time
+ input parameter arg1 :: <time-t*>;
+ result res :: <time-t>;
+ c-name: "time";
+end;
+
+define C-function difftime
+ input parameter arg1 :: <time-t>;
+ input parameter arg2 :: <time-t>;
+ result res :: <C-double>;
+ c-name: "difftime";
+end;
+
+define C-function mktime
+ input parameter arg1 :: <tm>;
+ result res :: <time-t>;
+ c-name: "mktime";
+end;
+
+define C-function strftime
+ input parameter arg1 :: <char*>;
+ input parameter arg2 :: <size-t>;
+ input parameter arg3 :: <char*>;
+ input parameter arg4 :: <tm>;
+ result res :: <size-t>;
+ c-name: "strftime";
+end;
+
+define C-function gmtime
+ input parameter arg1 :: <time-t*>;
+ result res :: <tm>;
+ c-name: "gmtime";
+end;
+
+define C-function localtime
+ input parameter arg1 :: <time-t*>;
+ result res :: <tm>;
+ c-name: "localtime";
+end;
+
define C-function gmtime-r
input parameter arg1 :: <time-t*>;
input parameter arg2 :: <tm>;
@@ -10047,6 +10981,18 @@
c-name: "localtime_r";
end;
+define C-function asctime
+ input parameter arg1 :: <tm>;
+ result res :: <char*>;
+ c-name: "asctime";
+end;
+
+define C-function ctime
+ input parameter arg1 :: <time-t*>;
+ result res :: <char*>;
+ c-name: "ctime";
+end;
+
define C-function asctime-r
input parameter arg1 :: <tm>;
input parameter arg2 :: <char*>;
@@ -10066,6 +11012,10 @@
/* Ignoring declaration for {instance of <variable-declaration>} "__daylight"*/
/* Ignoring declaration for {instance of <variable-declaration>} "__timezone"*/
/* Ignoring declaration for {instance of <variable-declaration>} "tzname"*/
+define C-function tzset
+ c-name: "tzset";
+end;
+
/* Ignoring declaration for {instance of <variable-declaration>} "daylight"*/
/* Ignoring declaration for {instance of <variable-declaration>} "timezone"*/
define C-function stime
@@ -10098,6 +11048,28 @@
result res :: <C-signed-int>;
c-name: "nanosleep";
end;
+
+define C-function clock-getres
+ input parameter arg1 :: <clockid-t>;
+ input parameter arg2 :: <timespec>;
+ result res :: <C-signed-int>;
+ c-name: "clock_getres";
+end;
+
+define C-function clock-gettime
+ input parameter arg1 :: <clockid-t>;
+ input parameter arg2 :: <timespec>;
+ result res :: <C-signed-int>;
+ c-name: "clock_gettime";
+end;
+
+define C-function clock-settime
+ input parameter arg1 :: <clockid-t>;
+ input parameter arg2 :: <timespec>;
+ result res :: <C-signed-int>;
+ c-name: "clock_settime";
+end;
+
define C-pointer-type <timer-t*> => <timer-t>;
define C-function timer-create
input parameter arg1 :: <clockid-t>;
@@ -10168,10 +11140,16 @@
define constant <__uint32-t> = <C-unsigned-int>;
define constant <long<@2>> = <long*>;
-define C-subtype <__quad-t> (<C-void*>) end;
+define C-struct <__quad-t>
+ array slot _quad_t-__val :: <C-signed-long>, length: 2;
+end;
+
define C-pointer-type <__u-long*> => <__u-long>;
define constant <__u-long<@2>> = <__u-long*>;
-define C-subtype <__u-quad-t> (<C-void*>) end;
+define C-struct <__u-quad-t>
+ array slot _u_quad_t-__val :: <__u-long>, length: 2;
+end;
+
define constant <__dev-t> = <__u-quad-t>;
define constant <__uid-t> = <C-unsigned-int>;
@@ -10194,7 +11172,10 @@
define C-pointer-type <int*> => <C-signed-int>;
define constant <int<@2>> = <int*>;
-define C-subtype <__fsid-t> (<C-void*>) end;
+define C-struct <__fsid-t>
+ array slot _fsid_t-__val :: <C-signed-int>, length: 2;
+end;
+
define constant <__rlim-t> = <C-unsigned-long>;
define constant <__rlim64-t> = <__u-quad-t>;
@@ -10357,8 +11338,15 @@
define constant <anonymous-410> = <C-function-pointer>;
define constant <GCompletionStrncmpFunc> = <anonymous-410>;
-define C-subtype <_GCompletion> (<C-void*>) end;
-define constant <GCompletion> = <_GCompletion>;
+define C-struct <_GCompletion>
+ slot GCompletion-items :: <GList>;
+ slot GCompletion-func :: <anonymous-409>;
+ slot GCompletion-prefix :: <gchar*>;
+ slot GCompletion-cache :: <GList>;
+ slot GCompletion-strncmp-func :: <anonymous-410>;
+end;
+
+define C-pointer-type <GCompletion> => <_GCompletion>;
define C-function g-completion-new
input parameter arg1 :: <GCompletionFunc>;
@@ -10410,8 +11398,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-400> = <C-function-pointer>;
define constant <GCacheNewFunc> = <anonymous-400>;
@@ -10476,8 +11466,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>;
@@ -10608,8 +11600,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>;
@@ -10863,10 +11859,21 @@
c-name: "g_byte_array_sort_with_data";
end;
+define C-function alloca
+ input parameter arg1 :: <size-t>;
+ result res :: <C-void*>;
+ c-name: "alloca";
+end;
+
define constant $_ALLOCA-H = 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>;
@@ -10948,8 +11955,15 @@
define constant <anonymous-1649> = <C-function-pointer>;
define constant <GTypePluginCompleteInterfaceInfo> = <anonymous-1649>;
-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-1646>;
+ slot GTypePluginClass-unuse-plugin :: <anonymous-1647>;
+ slot GTypePluginClass-complete-type-info :: <anonymous-1648>;
+ slot GTypePluginClass-complete-interface-info :: <anonymous-1649>;
+end;
+
+define C-pointer-type <GTypePluginClass> => <_GTypePluginClass>;
define C-function g-type-plugin-get-type
result res :: <GType>;
@@ -10991,8 +12005,17 @@
define constant <anonymous-1635> = <C-function-pointer>;
define constant <anonymous-1636> = <C-function-pointer>;
define constant <anonymous-1637> = <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-1632>;
+ slot GTypeModuleClass-unload :: <anonymous-1633>;
+ slot GTypeModuleClass-reserved1 :: <anonymous-1634>;
+ slot GTypeModuleClass-reserved2 :: <anonymous-1635>;
+ slot GTypeModuleClass-reserved3 :: <anonymous-1636>;
+ slot GTypeModuleClass-reserved4 :: <anonymous-1637>;
+end;
+
+define C-pointer-type <GTypeModuleClass> => <_GTypeModuleClass>;
define C-function g-type-module-get-type
result res :: <GType>;
@@ -11034,8 +12057,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>;
@@ -11045,8 +12073,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>;
@@ -11056,11 +12089,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>;
@@ -11156,9 +12202,11 @@
c-name: "g_flags_complete_type_info";
end;
-define constant <GInitiallyUnowned> = <_GObject>;
+define C-subtype <_GInitiallyUnowned> (<_GObject>) end;
+
+define constant <GInitiallyUnowned> = <_GInitiallyUnowned>;
-define constant <GInitiallyUnownedClass> = <_GObjectClass>;
+define C-pointer-type <GInitiallyUnownedClass> => <_GObjectClass>;
define constant <anonymous-1540> = <C-function-pointer>;
define constant <GObjectGetPropertyFunc> = <anonymous-1540>;
@@ -11232,8 +12280,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>;
@@ -11544,11 +12596,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-subtype <_GSignalInvocationHint> (<C-void*>) end;
-define constant <GSignalInvocationHint> = <_GSignalInvocationHint>;
+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-pointer-type <GSignalInvocationHint> => <_GSignalInvocationHint>;
define constant <anonymous-1453> = <C-function-pointer>;
define constant <GClosureMarshal> = <anonymous-1453>;
@@ -12066,11 +13132,22 @@
define constant <anonymous-1413> = <C-function-pointer>;
define constant <anonymous-1414> = <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-1411>;
+ slot GParamSpecClass-value-set-default :: <anonymous-1412>;
+ slot GParamSpecClass-value-validate :: <anonymous-1413>;
+ slot GParamSpecClass-values-cmp :: <anonymous-1414>;
+ array slot GParamSpecClass-dummy :: <gpointer>, length: 4;
+end;
+
+define C-pointer-type <GParamSpecClass> => <_GParamSpecClass>;
-define C-subtype <_GParamSpecPool> (<C-void*>) end;
-define constant <GParamSpecPool> = <_GParamSpecPool>;
+define C-struct <_GParamSpecPool>
+end;
+
+define C-pointer-type <GParamSpecPool> => <_GParamSpecPool>;
define C-function g-param-spec-ref
input parameter arg1 :: <GParamSpec>;
@@ -12219,8 +13296,18 @@
define constant <anonymous-1439> = <C-function-pointer>;
define constant <anonymous-1440> = <C-function-pointer>;
define constant <anonymous-1441> = <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-1437>;
+ slot GParamSpecTypeInfo-value-type :: <C-unsigned-long>;
+ slot GParamSpecTypeInfo-finalize :: <anonymous-1438>;
+ slot GParamSpecTypeInfo-value-set-default :: <anonymous-1439>;
+ slot GParamSpecTypeInfo-value-validate :: <anonymous-1440>;
+ slot GParamSpecTypeInfo-values-cmp :: <anonymous-1441>;
+end;
+
+define C-pointer-type <GParamSpecTypeInfo> => <_GParamSpecTypeInfo>;
define C-function g-param-type-register-static
input parameter arg1 :: <gchar*>;
@@ -12288,8 +13375,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>;
@@ -12417,71 +13508,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-subtype <_GParamSpecUChar> (<C-void*>) end;
-define constant <GParamSpecUChar> = <_GParamSpecUChar>;
+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-subtype <_GParamSpecBoolean> (<C-void*>) end;
-define constant <GParamSpecBoolean> = <_GParamSpecBoolean>;
+define C-pointer-type <GParamSpecEnum> => <_GParamSpecEnum>;
-define C-subtype <_GParamSpecInt> (<C-void*>) end;
-define constant <GParamSpecInt> = <_GParamSpecInt>;
+define C-struct <_GParamSpecFlags>
+ slot GParamSpecFlags-parent-instance :: <_GParamSpec>;
+ slot GParamSpecFlags-flags-class :: <GFlagsClass>;
+ slot GParamSpecFlags-default-value :: <C-unsigned-int>;
+end;
+
+define C-pointer-type <GParamSpecFlags> => <_GParamSpecFlags>;
+
+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 <_GParamSpecUInt> (<C-void*>) end;
-define constant <GParamSpecUInt> = <_GParamSpecUInt>;
+define C-pointer-type <GParamSpecFloat> => <_GParamSpecFloat>;
-define C-subtype <_GParamSpecLong> (<C-void*>) end;
-define constant <GParamSpecLong> = <_GParamSpecLong>;
+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-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*>;
@@ -12822,11 +14027,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-subtype <_GtkSettingsValue> (<C-void*>) end;
-define constant <GtkSettingsValue> = <_GtkSettingsValue>;
+define C-struct <_GtkSettingsValue>
+ slot GtkSettingsValue-origin :: <gchar*>;
+ slot GtkSettingsValue-value :: <_GValue>;
+end;
+
+define C-pointer-type <GtkSettingsValue> => <_GtkSettingsValue>;
define C-function gtk-settings-get-type
result res :: <GType>;
@@ -12937,8 +14149,19 @@
define constant <anonymous-3318> = <C-function-pointer>;
define constant <anonymous-3319> = <C-function-pointer>;
define constant <anonymous-3320> = <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-3313>;
+ slot GtkRcStyleClass-parse :: <anonymous-3314>;
+ slot GtkRcStyleClass-merge :: <anonymous-3315>;
+ slot GtkRcStyleClass-create-style :: <anonymous-3316>;
+ slot GtkRcStyleClass-_gtk-reserved1 :: <anonymous-3317>;
+ slot GtkRcStyleClass-_gtk-reserved2 :: <anonymous-3318>;
+ slot GtkRcStyleClass-_gtk-reserved3 :: <anonymous-3319>;
+ slot GtkRcStyleClass-_gtk-reserved4 :: <anonymous-3320>;
+end;
+
+define C-pointer-type <GtkRcStyleClass> => <_GtkRcStyleClass>;
define C-function gtk-rc-add-default-file
input parameter arg1 :: <gchar*>;
@@ -13151,8 +14374,14 @@
c-name: "gtk_rc_parse_priority";
end;
-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-3210> = <C-function-pointer>;
define constant <anonymous-3211> = <C-function-pointer>;
@@ -13160,8 +14389,10 @@
define constant <anonymous-3213> = <C-function-pointer>;
define constant <anonymous-3214> = <C-function-pointer>;
define constant <anonymous-3215> = <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-3216> = <C-function-pointer>;
define constant <anonymous-3217> = <C-function-pointer>;
@@ -13174,8 +14405,12 @@
define constant $GTK-SHADOW-ETCHED-OUT = 4;
define constant <anonymous-3219> = <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-3220> = <C-function-pointer>;
define constant <GtkArrowType> = <C-int>;
@@ -13229,17 +14464,70 @@
define constant <anonymous-3247> = <C-function-pointer>;
define constant <anonymous-3248> = <C-function-pointer>;
define constant <anonymous-3249> = <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-3210>;
+ slot GtkStyleClass-unrealize :: <anonymous-3211>;
+ slot GtkStyleClass-copy :: <anonymous-3212>;
+ slot GtkStyleClass-clone :: <anonymous-3213>;
+ slot GtkStyleClass-init-from-rc :: <anonymous-3214>;
+ slot GtkStyleClass-set-background :: <anonymous-3215>;
+ slot GtkStyleClass-render-icon :: <anonymous-3216>;
+ slot GtkStyleClass-draw-hline :: <anonymous-3217>;
+ slot GtkStyleClass-draw-vline :: <anonymous-3218>;
+ slot GtkStyleClass-draw-shadow :: <anonymous-3219>;
+ slot GtkStyleClass-draw-polygon :: <anonymous-3220>;
+ slot GtkStyleClass-draw-arrow :: <anonymous-3221>;
+ slot GtkStyleClass-draw-diamond :: <anonymous-3222>;
+ slot GtkStyleClass-draw-string :: <anonymous-3223>;
+ slot GtkStyleClass-draw-box :: <anonymous-3224>;
+ slot GtkStyleClass-draw-flat-box :: <anonymous-3225>;
+ slot GtkStyleClass-draw-check :: <anonymous-3226>;
+ slot GtkStyleClass-draw-option :: <anonymous-3227>;
+ slot GtkStyleClass-draw-tab :: <anonymous-3228>;
+ slot GtkStyleClass-draw-shadow-gap :: <anonymous-3229>;
+ slot GtkStyleClass-draw-box-gap :: <anonymous-3230>;
+ slot GtkStyleClass-draw-extension :: <anonymous-3231>;
+ slot GtkStyleClass-draw-focus :: <anonymous-3232>;
+ slot GtkStyleClass-draw-slider :: <anonymous-3233>;
+ slot GtkStyleClass-draw-handle :: <anonymous-3234>;
+ slot GtkStyleClass-draw-expander :: <anonymous-3235>;
+ slot GtkStyleClass-draw-layout :: <anonymous-3236>;
+ slot GtkStyleClass-draw-resize-grip :: <anonymous-3237>;
+ slot GtkStyleClass-_gtk-reserved1 :: <anonymous-3238>;
+ slot GtkStyleClass-_gtk-reserved2 :: <anonymous-3239>;
+ slot GtkStyleClass-_gtk-reserved3 :: <anonymous-3240>;
+ slot GtkStyleClass-_gtk-reserved4 :: <anonymous-3241>;
+ slot GtkStyleClass-_gtk-reserved5 :: <anonymous-3242>;
+ slot GtkStyleClass-_gtk-reserved6 :: <anonymous-3243>;
+ slot GtkStyleClass-_gtk-reserved7 :: <anonymous-3244>;
+ slot GtkStyleClass-_gtk-reserved8 :: <anonymous-3245>;
+ slot GtkStyleClass-_gtk-reserved9 :: <anonymous-3246>;
+ slot GtkStyleClass-_gtk-reserved10 :: <anonymous-3247>;
+ slot GtkStyleClass-_gtk-reserved11 :: <anonymous-3248>;
+ slot GtkStyleClass-_gtk-reserved12 :: <anonymous-3249>;
+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>;
@@ -13926,14 +15214,31 @@
c-name: "gtk_draw_insertion_cursor";
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-pointer-type <PangoEngineLang> => <_PangoEngineLang>;
-define C-subtype <_PangoEngineLang> (<C-void*>) end;
-define constant <PangoEngineLang> = <_PangoEngineLang>;
+define C-struct <_PangoEngineShape>
+end;
-define C-subtype <_PangoEngineShape> (<C-void*>) end;
-define constant <PangoEngineShape> = <_PangoEngineShape>;
+define C-pointer-type <PangoEngineShape> => <_PangoEngineShape>;
define C-subtype <_PangoFont> (<_GObject>) end;
define constant <PangoFont> = <_PangoFont>;
@@ -13941,14 +15246,30 @@
define C-subtype <_PangoFontMap> (<_GObject>) end;
define constant <PangoFontMap> = <_PangoFontMap>;
-define C-subtype <_PangoMatrix> (<C-void*>) end;
-define constant <PangoMatrix> =