diff --git a/ChangeLog b/ChangeLog index b090455242..5e461a36a0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-0 b/ChangeLog.pre-2-0 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-0 +++ b/ChangeLog.pre-2-0 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-10 b/ChangeLog.pre-2-10 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-10 +++ b/ChangeLog.pre-2-10 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-2 b/ChangeLog.pre-2-2 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-2 +++ b/ChangeLog.pre-2-2 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-4 b/ChangeLog.pre-2-4 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-4 +++ b/ChangeLog.pre-2-4 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-6 b/ChangeLog.pre-2-6 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-6 +++ b/ChangeLog.pre-2-6 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/ChangeLog.pre-2-8 b/ChangeLog.pre-2-8 index b090455242..5e461a36a0 100644 --- a/ChangeLog.pre-2-8 +++ b/ChangeLog.pre-2-8 @@ -1,3 +1,14 @@ +Mon Jun 8 02:52:37 1998 Tim Janik + + * gdk/gdkprivate.h: + * gdk/gdktypes.h: + * gtk/gtkprivate.h: + * gtk/gtkwidget.h: + * gtk/gtkobject.h: wrapped enum definitions with glib macros. + + * reworked enum value array generation code. gtk.defs is a generated + file now. + Sun Jun 7 14:34:31 1998 Tim Janik * gtk/gtkitemfactory.c (gtk_item_factory_create_menu_entries): feature diff --git a/gdk/gdkprivate.h b/gdk/gdkprivate.h index fcfca025bf..66cf7a5f60 100644 --- a/gdk/gdkprivate.h +++ b/gdk/gdkprivate.h @@ -204,12 +204,12 @@ struct _GdkRegionPrivate }; typedef enum { - GDK_DEBUG_MISC = 1<<0, - GDK_DEBUG_EVENTS = 1 << 1, - GDK_DEBUG_DND = 1<<2, - GDK_DEBUG_COLOR_CONTEXT = 1<<3, - GDK_DEBUG_XIM = 1<<4 -} GdkDebugFlag; + G_NV (GDK_DEBUG_MISC, misc, 1 << 0), + G_NV (GDK_DEBUG_EVENTS, events, 1 << 1), + G_NV (GDK_DEBUG_DND, dnd, 1 << 2), + G_NV (GDK_DEBUG_COLOR_CONTEXT,color-context, 1 << 3), + G_NV (GDK_DEBUG_XIM, xim, 1 << 4) +} G_FLAGS (GdkDebugFlag); void gdk_window_init (void); void gdk_visual_init (void); diff --git a/gdk/gdktypes.h b/gdk/gdktypes.h index f1b9a40681..acf8e189e4 100644 --- a/gdk/gdktypes.h +++ b/gdk/gdktypes.h @@ -35,6 +35,7 @@ #ifdef __cplusplus extern "C" { +#pragma } #endif /* __cplusplus */ @@ -115,14 +116,14 @@ typedef void* GdkIM; */ typedef enum { - GDK_WINDOW_ROOT, - GDK_WINDOW_TOPLEVEL, - GDK_WINDOW_CHILD, - GDK_WINDOW_DIALOG, - GDK_WINDOW_TEMP, - GDK_WINDOW_PIXMAP, - GDK_WINDOW_FOREIGN -} GdkWindowType; + G_SV (GDK_WINDOW_ROOT, root), + G_SV (GDK_WINDOW_TOPLEVEL, toplevel), + G_SV (GDK_WINDOW_CHILD, child), + G_SV (GDK_WINDOW_DIALOG, dialog), + G_SV (GDK_WINDOW_TEMP, temp), + G_SV (GDK_WINDOW_PIXMAP, pixmap), + G_SV (GDK_WINDOW_FOREIGN, foreign) +} G_ENUM (GdkWindowType); /* Classes of windows. * InputOutput: Almost every window should be of this type. Such windows @@ -135,9 +136,9 @@ typedef enum */ typedef enum { - GDK_INPUT_OUTPUT, - GDK_INPUT_ONLY -} GdkWindowClass; + G_SV (GDK_INPUT_OUTPUT, input-output), + G_SV (GDK_INPUT_ONLY, input-only) +} G_ENUM (GdkWindowClass); /* Types of images. * Normal: Normal X image type. These are slow as they involve passing @@ -151,10 +152,10 @@ typedef enum */ typedef enum { - GDK_IMAGE_NORMAL, - GDK_IMAGE_SHARED, - GDK_IMAGE_FASTEST -} GdkImageType; + G_SV (GDK_IMAGE_NORMAL, normal), + G_SV (GDK_IMAGE_SHARED, shared), + G_SV (GDK_IMAGE_FASTEST, fastest) +} G_ENUM (GdkImageType); /* Types of visuals. * StaticGray: @@ -166,13 +167,13 @@ typedef enum */ typedef enum { - GDK_VISUAL_STATIC_GRAY, - GDK_VISUAL_GRAYSCALE, - GDK_VISUAL_STATIC_COLOR, - GDK_VISUAL_PSEUDO_COLOR, - GDK_VISUAL_TRUE_COLOR, - GDK_VISUAL_DIRECT_COLOR -} GdkVisualType; + G_SV (GDK_VISUAL_STATIC_GRAY, static-gray), + G_SV (GDK_VISUAL_GRAYSCALE, grayscale), + G_SV (GDK_VISUAL_STATIC_COLOR, static-color), + G_SV (GDK_VISUAL_PSEUDO_COLOR, pseudo-color), + G_SV (GDK_VISUAL_TRUE_COLOR, true-color), + G_SV (GDK_VISUAL_DIRECT_COLOR, direct-color) +} G_ENUM (GdkVisualType); /* Types of font. * GDK_FONT_FONT: the font is an XFontStruct. @@ -180,9 +181,9 @@ typedef enum */ typedef enum { - GDK_FONT_FONT, - GDK_FONT_FONTSET -} GdkFontType; + G_SV (GDK_FONT_FONT, font), + G_SV (GDK_FONT_FONTSET, fontset) +} G_ENUM (GdkFontType); /* Window attribute mask values. * GDK_WA_TITLE: The "title" field is valid. @@ -194,24 +195,24 @@ typedef enum */ typedef enum { - GDK_WA_TITLE = 1 << 1, - GDK_WA_X = 1 << 2, - GDK_WA_Y = 1 << 3, - GDK_WA_CURSOR = 1 << 4, - GDK_WA_COLORMAP = 1 << 5, - GDK_WA_VISUAL = 1 << 6, - GDK_WA_WMCLASS = 1 << 7, - GDK_WA_NOREDIR = 1 << 8 -} GdkWindowAttributesType; + G_NV (GDK_WA_TITLE, title, 1 << 1), + G_NV (GDK_WA_X, x, 1 << 2), + G_NV (GDK_WA_Y, y, 1 << 3), + G_NV (GDK_WA_CURSOR, cursor, 1 << 4), + G_NV (GDK_WA_COLORMAP, colormap, 1 << 5), + G_NV (GDK_WA_VISUAL, visual, 1 << 6), + G_NV (GDK_WA_WMCLASS, wmclass, 1 << 7), + G_NV (GDK_WA_NOREDIR, noredir, 1 << 8) +} G_FLAGS (GdkWindowAttributesType); /* Size restriction enumeration. */ typedef enum { - GDK_HINT_POS = 1 << 0, - GDK_HINT_MIN_SIZE = 1 << 1, - GDK_HINT_MAX_SIZE = 1 << 2 -} GdkWindowHints; + G_NV (GDK_HINT_POS, pos, 1 << 0), + G_NV (GDK_HINT_MIN_SIZE, min-size, 1 << 1), + G_NV (GDK_HINT_MAX_SIZE, max-size, 1 << 2) +} G_FLAGS (GdkWindowHints); /* GC function types. * Copy: Overwrites destination pixels with the source pixels. @@ -220,10 +221,10 @@ typedef enum */ typedef enum { - GDK_COPY, - GDK_INVERT, - GDK_XOR -} GdkFunction; + G_SV (GDK_COPY, copy), + G_SV (GDK_INVERT, invert), + G_SV (GDK_XOR, xor) +} G_ENUM (GdkFunction); /* GC fill types. * Solid: @@ -233,11 +234,11 @@ typedef enum */ typedef enum { - GDK_SOLID, - GDK_TILED, - GDK_STIPPLED, - GDK_OPAQUE_STIPPLED -} GdkFill; + G_SV (GDK_SOLID, solid), + G_SV (GDK_TILED, tiled), + G_SV (GDK_STIPPLED, stippled), + G_SV (GDK_OPAQUE_STIPPLED, opaque-stippled) +} G_ENUM (GdkFill); /* GC fill rule for polygons * EvenOddRule @@ -245,9 +246,9 @@ typedef enum */ typedef enum { - GDK_EVEN_ODD_RULE, - GDK_WINDING_RULE -} GdkFillRule; + G_SV (GDK_EVEN_ODD_RULE, even-odd-rule), + G_SV (GDK_WINDING_RULE, winding-rule) +} G_ENUM (GdkFillRule); /* GC line styles * Solid: @@ -256,10 +257,10 @@ typedef enum */ typedef enum { - GDK_LINE_SOLID, - GDK_LINE_ON_OFF_DASH, - GDK_LINE_DOUBLE_DASH -} GdkLineStyle; + G_SV (GDK_LINE_SOLID, solid), + G_SV (GDK_LINE_ON_OFF_DASH, on-off-dash), + G_SV (GDK_LINE_DOUBLE_DASH, double-dash) +} G_ENUM (GdkLineStyle); /* GC cap styles * CapNotLast: @@ -269,11 +270,11 @@ typedef enum */ typedef enum { - GDK_CAP_NOT_LAST, - GDK_CAP_BUTT, - GDK_CAP_ROUND, - GDK_CAP_PROJECTING -} GdkCapStyle; + G_SV (GDK_CAP_NOT_LAST, not-last), + G_SV (GDK_CAP_BUTT, butt), + G_SV (GDK_CAP_ROUND, round), + G_SV (GDK_CAP_PROJECTING, projecting) +} G_ENUM (GdkCapStyle); /* GC join styles * JoinMiter: @@ -282,10 +283,10 @@ typedef enum */ typedef enum { - GDK_JOIN_MITER, - GDK_JOIN_ROUND, - GDK_JOIN_BEVEL -} GdkJoinStyle; + G_SV (GDK_JOIN_MITER, miter), + G_SV (GDK_JOIN_ROUND, round), + G_SV (GDK_JOIN_BEVEL, bevel) +} G_ENUM (GdkJoinStyle); /* Cursor types. */ @@ -297,16 +298,18 @@ typedef enum } GdkCursorType; typedef enum { - GDK_FILTER_CONTINUE, /* Event not handled, continue processesing */ - GDK_FILTER_TRANSLATE, /* Translated event stored */ - GDK_FILTER_REMOVE /* Terminate processing, removing event */ -} GdkFilterReturn; + G_SV (GDK_FILTER_CONTINUE, continue), /* Event not handled, + * continue processesing */ + G_SV (GDK_FILTER_TRANSLATE, translate), /* Translated event stored */ + G_SV (GDK_FILTER_REMOVE, remove) /* Terminate processing, + * removing event */ +} G_ENUM (GdkFilterReturn); typedef enum { - GDK_VISIBILITY_UNOBSCURED, - GDK_VISIBILITY_PARTIAL, - GDK_VISIBILITY_FULLY_OBSCURED -} GdkVisibilityState; + G_SV (GDK_VISIBILITY_UNOBSCURED, unobscured), + G_SV (GDK_VISIBILITY_PARTIAL, partial), + G_SV (GDK_VISIBILITY_FULLY_OBSCURED, fully-obscured) +} G_ENUM (GdkVisibilityState); /* Event types. * Nothing: No event occurred. @@ -332,67 +335,68 @@ typedef enum { */ typedef enum { - GDK_NOTHING = -1, - GDK_DELETE = 0, - GDK_DESTROY = 1, - GDK_EXPOSE = 2, - GDK_MOTION_NOTIFY = 3, - GDK_BUTTON_PRESS = 4, - GDK_2BUTTON_PRESS = 5, - GDK_3BUTTON_PRESS = 6, - GDK_BUTTON_RELEASE = 7, - GDK_KEY_PRESS = 8, - GDK_KEY_RELEASE = 9, - GDK_ENTER_NOTIFY = 10, - GDK_LEAVE_NOTIFY = 11, - GDK_FOCUS_CHANGE = 12, - GDK_CONFIGURE = 13, - GDK_MAP = 14, - GDK_UNMAP = 15, - GDK_PROPERTY_NOTIFY = 16, - GDK_SELECTION_CLEAR = 17, - GDK_SELECTION_REQUEST = 18, - GDK_SELECTION_NOTIFY = 19, - GDK_PROXIMITY_IN = 20, - GDK_PROXIMITY_OUT = 21, - GDK_DRAG_BEGIN = 22, - GDK_DRAG_REQUEST = 23, - GDK_DROP_ENTER = 24, - GDK_DROP_LEAVE = 25, - GDK_DROP_DATA_AVAIL = 26, - GDK_CLIENT_EVENT = 27, - GDK_VISIBILITY_NOTIFY = 28, - GDK_NO_EXPOSE = 29, - GDK_OTHER_EVENT = 9999 /* Deprecated, use filters instead */ -} GdkEventType; + G_NV (GDK_NOTHING, NOTHING, -1), + G_NV (GDK_DELETE, delete, 0), + G_NV (GDK_DESTROY, destroy, 1), + G_NV (GDK_EXPOSE, expose, 2), + G_NV (GDK_MOTION_NOTIFY, motion-notify, 3), + G_NV (GDK_BUTTON_PRESS, button-press, 4), + G_NV (GDK_2BUTTON_PRESS, 2button-press, 5), + G_NV (GDK_3BUTTON_PRESS, 3button-press, 6), + G_NV (GDK_BUTTON_RELEASE, button-release, 7), + G_NV (GDK_KEY_PRESS, key-press, 8), + G_NV (GDK_KEY_RELEASE, key-release, 9), + G_NV (GDK_ENTER_NOTIFY, enter-notify, 10), + G_NV (GDK_LEAVE_NOTIFY, leave-notify, 11), + G_NV (GDK_FOCUS_CHANGE, focus-change, 12), + G_NV (GDK_CONFIGURE, configure, 13), + G_NV (GDK_MAP, map, 14), + G_NV (GDK_UNMAP, unmap, 15), + G_NV (GDK_PROPERTY_NOTIFY, property-notify, 16), + G_NV (GDK_SELECTION_CLEAR, selection-clear, 17), + G_NV (GDK_SELECTION_REQUEST, selection-request,18), + G_NV (GDK_SELECTION_NOTIFY, selection-notify,19), + G_NV (GDK_PROXIMITY_IN, proximity-in, 20), + G_NV (GDK_PROXIMITY_OUT, proximity-out, 21), + G_NV (GDK_DRAG_BEGIN, drag-begin, 22), + G_NV (GDK_DRAG_REQUEST, drag-request, 23), + G_NV (GDK_DROP_ENTER, drop-enter, 24), + G_NV (GDK_DROP_LEAVE, drop-leave, 25), + G_NV (GDK_DROP_DATA_AVAIL, drop-data-avail, 26), + G_NV (GDK_CLIENT_EVENT, client-event, 27), + G_NV (GDK_VISIBILITY_NOTIFY, visibility-notify, 28), + G_NV (GDK_NO_EXPOSE, no-expose, 29), + G_NV (GDK_OTHER_EVENT, other-event, 9999) /* Deprecated, use + * filters instead */ +} G_ENUM (GdkEventType); /* Event masks. (Used to select what types of events a window * will receive). */ typedef enum { - GDK_EXPOSURE_MASK = 1 << 1, - GDK_POINTER_MOTION_MASK = 1 << 2, - GDK_POINTER_MOTION_HINT_MASK = 1 << 3, - GDK_BUTTON_MOTION_MASK = 1 << 4, - GDK_BUTTON1_MOTION_MASK = 1 << 5, - GDK_BUTTON2_MOTION_MASK = 1 << 6, - GDK_BUTTON3_MOTION_MASK = 1 << 7, - GDK_BUTTON_PRESS_MASK = 1 << 8, - GDK_BUTTON_RELEASE_MASK = 1 << 9, - GDK_KEY_PRESS_MASK = 1 << 10, - GDK_KEY_RELEASE_MASK = 1 << 11, - GDK_ENTER_NOTIFY_MASK = 1 << 12, - GDK_LEAVE_NOTIFY_MASK = 1 << 13, - GDK_FOCUS_CHANGE_MASK = 1 << 14, - GDK_STRUCTURE_MASK = 1 << 15, - GDK_PROPERTY_CHANGE_MASK = 1 << 16, - GDK_VISIBILITY_NOTIFY_MASK = 1 << 17, - GDK_PROXIMITY_IN_MASK = 1 << 18, - GDK_PROXIMITY_OUT_MASK = 1 << 19, - GDK_SUBSTRUCTURE_MASK = 1 << 20, - GDK_ALL_EVENTS_MASK = 0x0FFFFF -} GdkEventMask; + G_NV (GDK_EXPOSURE_MASK, exposure-mask, 1 << 1), + G_NV (GDK_POINTER_MOTION_MASK, pointer-motion-mask, 1 << 2), + G_NV (GDK_POINTER_MOTION_HINT_MASK, pointer-motion-hint-mask, 1 << 3), + G_NV (GDK_BUTTON_MOTION_MASK, button-motion-mask, 1 << 4), + G_NV (GDK_BUTTON1_MOTION_MASK, button1-motion-mask, 1 << 5), + G_NV (GDK_BUTTON2_MOTION_MASK, button2-motion-mask, 1 << 6), + G_NV (GDK_BUTTON3_MOTION_MASK, button3-motion-mask, 1 << 7), + G_NV (GDK_BUTTON_PRESS_MASK, button-press-mask, 1 << 8), + G_NV (GDK_BUTTON_RELEASE_MASK, button-release-mask, 1 << 9), + G_NV (GDK_KEY_PRESS_MASK, key-press-mask, 1 << 10), + G_NV (GDK_KEY_RELEASE_MASK, key-release-mask, 1 << 11), + G_NV (GDK_ENTER_NOTIFY_MASK, enter-notify-mask, 1 << 12), + G_NV (GDK_LEAVE_NOTIFY_MASK, leave-notify-mask, 1 << 13), + G_NV (GDK_FOCUS_CHANGE_MASK, focus-change-mask, 1 << 14), + G_NV (GDK_STRUCTURE_MASK, structure-mask, 1 << 15), + G_NV (GDK_PROPERTY_CHANGE_MASK, property-change-mask, 1 << 16), + G_NV (GDK_VISIBILITY_NOTIFY_MASK, visibility-notify-mask, 1 << 17), + G_NV (GDK_PROXIMITY_IN_MASK, proximity-in-mask, 1 << 18), + G_NV (GDK_PROXIMITY_OUT_MASK, proximity-out-mask, 1 << 19), + G_NV (GDK_SUBSTRUCTURE_MASK, substructure-mask, 1 << 20), + G_NV (GDK_ALL_EVENTS_MASK, all-events-mask, 0x0FFFFF) +} G_FLAGS (GdkEventMask); /* Types of enter/leave notifications. * Ancestor: @@ -404,13 +408,13 @@ typedef enum */ typedef enum { - GDK_NOTIFY_ANCESTOR = 0, - GDK_NOTIFY_VIRTUAL = 1, - GDK_NOTIFY_INFERIOR = 2, - GDK_NOTIFY_NONLINEAR = 3, - GDK_NOTIFY_NONLINEAR_VIRTUAL = 4, - GDK_NOTIFY_UNKNOWN = 5 -} GdkNotifyType; + G_NV (GDK_NOTIFY_ANCESTOR, ancestor, 0), + G_NV (GDK_NOTIFY_VIRTUAL, virtual, 1), + G_NV (GDK_NOTIFY_INFERIOR, inferior, 2), + G_NV (GDK_NOTIFY_NONLINEAR, nonlinear, 3), + G_NV (GDK_NOTIFY_NONLINEAR_VIRTUAL, nonlinear-virtual, 4), + G_NV (GDK_NOTIFY_UNKNOWN, unknown, 5) +} G_ENUM (GdkNotifyType); /* Enter/leave event modes. * NotifyNormal @@ -419,177 +423,177 @@ typedef enum */ typedef enum { - GDK_CROSSING_NORMAL, - GDK_CROSSING_GRAB, - GDK_CROSSING_UNGRAB -} GdkCrossingMode; + G_SV (GDK_CROSSING_NORMAL, crossing-normal), + G_SV (GDK_CROSSING_GRAB, crossing-grab), + G_SV (GDK_CROSSING_UNGRAB, crossing-ungrab) +} G_ENUM (GdkCrossingMode); /* Types of modifiers. */ typedef enum { - GDK_SHIFT_MASK = 1 << 0, - GDK_LOCK_MASK = 1 << 1, - GDK_CONTROL_MASK = 1 << 2, - GDK_MOD1_MASK = 1 << 3, - GDK_MOD2_MASK = 1 << 4, - GDK_MOD3_MASK = 1 << 5, - GDK_MOD4_MASK = 1 << 6, - GDK_MOD5_MASK = 1 << 7, - GDK_BUTTON1_MASK = 1 << 8, - GDK_BUTTON2_MASK = 1 << 9, - GDK_BUTTON3_MASK = 1 << 10, - GDK_BUTTON4_MASK = 1 << 11, - GDK_BUTTON5_MASK = 1 << 12, - GDK_AFTER_MASK = 1 << 13, - GDK_MODIFIER_MASK = 0x3fff -} GdkModifierType; + G_NV (GDK_SHIFT_MASK, shift-mask, 1 << 0), + G_NV (GDK_LOCK_MASK, lock-mask, 1 << 1), + G_NV (GDK_CONTROL_MASK, control-mask, 1 << 2), + G_NV (GDK_MOD1_MASK, mod1-mask, 1 << 3), + G_NV (GDK_MOD2_MASK, mod2-mask, 1 << 4), + G_NV (GDK_MOD3_MASK, mod3-mask, 1 << 5), + G_NV (GDK_MOD4_MASK, mod4-mask, 1 << 6), + G_NV (GDK_MOD5_MASK, mod5-mask, 1 << 7), + G_NV (GDK_BUTTON1_MASK, button1-mask, 1 << 8), + G_NV (GDK_BUTTON2_MASK, button2-mask, 1 << 9), + G_NV (GDK_BUTTON3_MASK, button3-mask, 1 << 10), + G_NV (GDK_BUTTON4_MASK, button4-mask, 1 << 11), + G_NV (GDK_BUTTON5_MASK, button5-mask, 1 << 12), + G_NV (GDK_AFTER_MASK, after-mask, 1 << 13), + G_NV (GDK_MODIFIER_MASK, modifier-mask, 0x3fff) +} G_FLAGS (GdkModifierType); typedef enum { - GDK_CLIP_BY_CHILDREN = 0, - GDK_INCLUDE_INFERIORS = 1 -} GdkSubwindowMode; + G_NV (GDK_CLIP_BY_CHILDREN, clip-by-children, 0), + G_NV (GDK_INCLUDE_INFERIORS, include-inferiors, 1) +} G_ENUM (GdkSubwindowMode); typedef enum { - GDK_INPUT_READ = 1 << 0, - GDK_INPUT_WRITE = 1 << 1, - GDK_INPUT_EXCEPTION = 1 << 2 -} GdkInputCondition; + G_NV (GDK_INPUT_READ, read, 1 << 0), + G_NV (GDK_INPUT_WRITE, write, 1 << 1), + G_NV (GDK_INPUT_EXCEPTION, exception, 1 << 2) +} G_FLAGS (GdkInputCondition); typedef enum { - GDK_OK = 0, - GDK_ERROR = -1, - GDK_ERROR_PARAM = -2, - GDK_ERROR_FILE = -3, - GDK_ERROR_MEM = -4 -} GdkStatus; + G_NV (GDK_OK, ok, 0), + G_NV (GDK_ERROR, error, -1), + G_NV (GDK_ERROR_PARAM, error-param, -2), + G_NV (GDK_ERROR_FILE, error-file, -3), + G_NV (GDK_ERROR_MEM, error-mem, -4) +} G_ENUM (GdkStatus); typedef enum { - GDK_LSB_FIRST, - GDK_MSB_FIRST -} GdkByteOrder; + G_SV (GDK_LSB_FIRST, lsb-first), + G_SV (GDK_MSB_FIRST, msb-first) +} G_ENUM (GdkByteOrder); typedef enum { - GDK_GC_FOREGROUND = 1 << 0, - GDK_GC_BACKGROUND = 1 << 1, - GDK_GC_FONT = 1 << 2, - GDK_GC_FUNCTION = 1 << 3, - GDK_GC_FILL = 1 << 4, - GDK_GC_TILE = 1 << 5, - GDK_GC_STIPPLE = 1 << 6, - GDK_GC_CLIP_MASK = 1 << 7, - GDK_GC_SUBWINDOW = 1 << 8, - GDK_GC_TS_X_ORIGIN = 1 << 9, - GDK_GC_TS_Y_ORIGIN = 1 << 10, - GDK_GC_CLIP_X_ORIGIN = 1 << 11, - GDK_GC_CLIP_Y_ORIGIN = 1 << 12, - GDK_GC_EXPOSURES = 1 << 13, - GDK_GC_LINE_WIDTH = 1 << 14, - GDK_GC_LINE_STYLE = 1 << 15, - GDK_GC_CAP_STYLE = 1 << 16, - GDK_GC_JOIN_STYLE = 1 << 17 -} GdkGCValuesMask; + G_NV (GDK_GC_FOREGROUND, foreground, 1 << 0), + G_NV (GDK_GC_BACKGROUND, background, 1 << 1), + G_NV (GDK_GC_FONT, font, 1 << 2), + G_NV (GDK_GC_FUNCTION, function, 1 << 3), + G_NV (GDK_GC_FILL, fill, 1 << 4), + G_NV (GDK_GC_TILE, tile, 1 << 5), + G_NV (GDK_GC_STIPPLE, stipple, 1 << 6), + G_NV (GDK_GC_CLIP_MASK, clip-mask, 1 << 7), + G_NV (GDK_GC_SUBWINDOW, subwindow, 1 << 8), + G_NV (GDK_GC_TS_X_ORIGIN, ts-x-origin, 1 << 9), + G_NV (GDK_GC_TS_Y_ORIGIN, ts-y-origin, 1 << 10), + G_NV (GDK_GC_CLIP_X_ORIGIN, clip-x-origin, 1 << 11), + G_NV (GDK_GC_CLIP_Y_ORIGIN, clip-y-origin, 1 << 12), + G_NV (GDK_GC_EXPOSURES, exposures, 1 << 13), + G_NV (GDK_GC_LINE_WIDTH, line-width, 1 << 14), + G_NV (GDK_GC_LINE_STYLE, line-style, 1 << 15), + G_NV (GDK_GC_CAP_STYLE, cap-style, 1 << 16), + G_NV (GDK_GC_JOIN_STYLE, join-style, 1 << 17) +} G_FLAGS (GdkGCValuesMask); typedef enum { - GDK_SELECTION_PRIMARY = 1, - GDK_SELECTION_SECONDARY = 2 -} GdkSelection; + G_NV (GDK_SELECTION_PRIMARY, primary, 1), + G_NV (GDK_SELECTION_SECONDARY, secondary, 2) +} G_ENUM (GdkSelection); typedef enum { - GDK_PROPERTY_NEW_VALUE, - GDK_PROPERTY_DELETE -} GdkPropertyState; + G_SV (GDK_PROPERTY_NEW_VALUE, new-value), + G_SV (GDK_PROPERTY_DELETE, delete) +} G_ENUM (GdkPropertyState); typedef enum { - GDK_PROP_MODE_REPLACE, - GDK_PROP_MODE_PREPEND, - GDK_PROP_MODE_APPEND -} GdkPropMode; + G_SV (GDK_PROP_MODE_REPLACE, replace), + G_SV (GDK_PROP_MODE_PREPEND, prepend), + G_SV (GDK_PROP_MODE_APPEND, append) +} G_ENUM (GdkPropMode); /* These definitions are for version 1 of the OffiX D&D protocol, taken from */ typedef enum { - GDK_DNDTYPE_NOTDND = -1, - GDK_DNDTYPE_UNKNOWN = 0, - GDK_DNDTYPE_RAWDATA = 1, - GDK_DNDTYPE_FILE = 2, - GDK_DNDTYPE_FILES = 3, - GDK_DNDTYPE_TEXT = 4, - GDK_DNDTYPE_DIR = 5, - GDK_DNDTYPE_LINK = 6, - GDK_DNDTYPE_EXE = 7, - GDK_DNDTYPE_URL = 8, - GDK_DNDTYPE_MIME = 9, - GDK_DNDTYPE_END = 10 -} GdkDndType; + G_NV (GDK_DNDTYPE_NOTDND, NOTDND, -1), + G_NV (GDK_DNDTYPE_UNKNOWN, UNKNOWN, 0), + G_NV (GDK_DNDTYPE_RAWDATA, RAWDATA, 1), + G_NV (GDK_DNDTYPE_FILE, FILE, 2), + G_NV (GDK_DNDTYPE_FILES, FILES, 3), + G_NV (GDK_DNDTYPE_TEXT, text, 4), + G_NV (GDK_DNDTYPE_DIR, dir, 5), + G_NV (GDK_DNDTYPE_LINK, link, 6), + G_NV (GDK_DNDTYPE_EXE, exe, 7), + G_NV (GDK_DNDTYPE_URL, url, 8), + G_NV (GDK_DNDTYPE_MIME, mime, 9), + G_NV (GDK_DNDTYPE_END, end, 10) +} G_ENUM (GdkDndType); /* Enums for XInput support */ typedef enum { - GDK_SOURCE_MOUSE, - GDK_SOURCE_PEN, - GDK_SOURCE_ERASER, - GDK_SOURCE_CURSOR -} GdkInputSource; + G_SV (GDK_SOURCE_MOUSE, mouse), + G_SV (GDK_SOURCE_PEN, pen), + G_SV (GDK_SOURCE_ERASER, eraser), + G_SV (GDK_SOURCE_CURSOR, cursor) +} G_ENUM (GdkInputSource); typedef enum { - GDK_MODE_DISABLED, - GDK_MODE_SCREEN, - GDK_MODE_WINDOW -} GdkInputMode; + G_SV (GDK_MODE_DISABLED, disabled), + G_SV (GDK_MODE_SCREEN, screen), + G_SV (GDK_MODE_WINDOW, window) +} G_ENUM (GdkInputMode); typedef enum { - GDK_AXIS_IGNORE, - GDK_AXIS_X, - GDK_AXIS_Y, - GDK_AXIS_PRESSURE, - GDK_AXIS_XTILT, - GDK_AXIS_YTILT, - GDK_AXIS_LAST -} GdkAxisUse; + G_SV (GDK_AXIS_IGNORE, ignore), + G_SV (GDK_AXIS_X, x), + G_SV (GDK_AXIS_Y, y), + G_SV (GDK_AXIS_PRESSURE, pressure), + G_SV (GDK_AXIS_XTILT, xtilt), + G_SV (GDK_AXIS_YTILT, ytilt), + G_SV (GDK_AXIS_LAST, last) +} G_ENUM (GdkAxisUse); /* The next two types define enums for predefined atoms relating - to selections. In general, one will need to use gdk_intern_atom */ + * to selections. In general, one will need to use gdk_intern_atom + */ +typedef enum +{ + G_NV (GDK_TARGET_BITMAP, bitmap, 5), + G_NV (GDK_TARGET_COLORMAP, colormap, 7), + G_NV (GDK_TARGET_DRAWABLE, drawable, 17), + G_NV (GDK_TARGET_PIXMAP, pixmap, 20), + G_NV (GDK_TARGET_STRING, string, 31) +} G_ENUM (GdkTarget); typedef enum { - GDK_TARGET_BITMAP = 5, - GDK_TARGET_COLORMAP = 7, - GDK_TARGET_DRAWABLE = 17, - GDK_TARGET_PIXMAP = 20, - GDK_TARGET_STRING = 31 -} GdkTarget; + G_NV (GDK_SELECTION_TYPE_ATOM, atom, 4), + G_NV (GDK_SELECTION_TYPE_BITMAP, bitmap, 5), + G_NV (GDK_SELECTION_TYPE_COLORMAP, colormap, 7), + G_NV (GDK_SELECTION_TYPE_DRAWABLE, drawable, 17), + G_NV (GDK_SELECTION_TYPE_INTEGER, integer, 19), + G_NV (GDK_SELECTION_TYPE_PIXMAP, pixmap, 20), + G_NV (GDK_SELECTION_TYPE_WINDOW, window, 33), + G_NV (GDK_SELECTION_TYPE_STRING, string, 31) +} G_ENUM (GdkSelectionType); typedef enum { - GDK_SELECTION_TYPE_ATOM = 4, - GDK_SELECTION_TYPE_BITMAP = 5, - GDK_SELECTION_TYPE_COLORMAP = 7, - GDK_SELECTION_TYPE_DRAWABLE = 17, - GDK_SELECTION_TYPE_INTEGER = 19, - GDK_SELECTION_TYPE_PIXMAP = 20, - GDK_SELECTION_TYPE_WINDOW = 33, - GDK_SELECTION_TYPE_STRING = 31 -} GdkSelectionType; - -typedef enum -{ - GDK_EXTENSION_EVENTS_NONE, - GDK_EXTENSION_EVENTS_ALL, - GDK_EXTENSION_EVENTS_CURSOR -} GdkExtensionMode; + G_SV (GDK_EXTENSION_EVENTS_NONE, none), + G_SV (GDK_EXTENSION_EVENTS_ALL, all), + G_SV (GDK_EXTENSION_EVENTS_CURSOR, cursor) +} G_ENUM (GdkExtensionMode); typedef enum { @@ -611,24 +615,24 @@ typedef enum */ typedef enum { - GDK_DECOR_ALL = 1 << 0, - GDK_DECOR_BORDER = 1 << 1, - GDK_DECOR_RESIZEH = 1 << 2, - GDK_DECOR_TITLE = 1 << 3, - GDK_DECOR_MENU = 1 << 4, - GDK_DECOR_MINIMIZE = 1 << 5, - GDK_DECOR_MAXIMIZE = 1 << 6 -} GdkWMDecoration; + G_NV (GDK_DECOR_ALL, all, 1 << 0), + G_NV (GDK_DECOR_BORDER, border, 1 << 1), + G_NV (GDK_DECOR_RESIZEH, resizeh, 1 << 2), + G_NV (GDK_DECOR_TITLE, title, 1 << 3), + G_NV (GDK_DECOR_MENU, menu, 1 << 4), + G_NV (GDK_DECOR_MINIMIZE, minimize, 1 << 5), + G_NV (GDK_DECOR_MAXIMIZE, maximize, 1 << 6) +} G_FLAGS (GdkWMDecoration); typedef enum { - GDK_FUNC_ALL = 1 << 0, - GDK_FUNC_RESIZE = 1 << 1, - GDK_FUNC_MOVE = 1 << 2, - GDK_FUNC_MINIMIZE = 1 << 3, - GDK_FUNC_MAXIMIZE = 1 << 4, - GDK_FUNC_CLOSE = 1 << 5 -} GdkWMFunction; + G_NV (GDK_FUNC_ALL, all, 1 << 0), + G_NV (GDK_FUNC_RESIZE, resize, 1 << 1), + G_NV (GDK_FUNC_MOVE, move, 1 << 2), + G_NV (GDK_FUNC_MINIMIZE, minimize, 1 << 3), + G_NV (GDK_FUNC_MAXIMIZE, maximize, 1 << 4), + G_NV (GDK_FUNC_CLOSE, close, 1 << 5) +} G_FLAGS (GdkWMFunction); #define GdkIMPreeditMask \ ( GdkIMPreeditArea | GdkIMPreeditCallbacks | \ @@ -657,13 +661,13 @@ typedef void (*GdkDestroyNotify) (gpointer data); typedef enum { - GDK_CC_MODE_UNDEFINED, - GDK_CC_MODE_BW, - GDK_CC_MODE_STD_CMAP, - GDK_CC_MODE_TRUE, - GDK_CC_MODE_MY_GRAY, - GDK_CC_MODE_PALETTE -} GdkColorContextMode; + G_SV (GDK_CC_MODE_UNDEFINED, undefined), + G_SV (GDK_CC_MODE_BW, bw), + G_SV (GDK_CC_MODE_STD_CMAP, std-cmap), + G_SV (GDK_CC_MODE_TRUE, true), + G_SV (GDK_CC_MODE_MY_GRAY, my-gray), + G_SV (GDK_CC_MODE_PALETTE, palette) +} G_ENUM (GdkColorContextMode); /* Types of overlapping between a rectangle and a region * GDK_OVERLAP_RECTANGLE_IN: rectangle is in region @@ -673,10 +677,10 @@ typedef enum typedef enum { - GDK_OVERLAP_RECTANGLE_IN, - GDK_OVERLAP_RECTANGLE_OUT, - GDK_OVERLAP_RECTANGLE_PART -} GdkOverlapType; + G_SV (GDK_OVERLAP_RECTANGLE_IN, in), + G_SV (GDK_OVERLAP_RECTANGLE_OUT, out), + G_SV (GDK_OVERLAP_RECTANGLE_PART, part) +} G_ENUM (GdkOverlapType); /* The color type. * A color consists of red, green and blue values in the @@ -698,7 +702,7 @@ struct _GdkColor */ struct _GdkColormap { - gint size; + gint size; GdkColor *colors; }; @@ -721,15 +725,15 @@ struct _GdkVisual GdkByteOrder byte_order; gint colormap_size; gint bits_per_rgb; - + guint32 red_mask; gint red_shift; gint red_prec; - + guint32 green_mask; gint green_shift; gint green_prec; - + guint32 blue_mask; gint blue_shift; gint blue_prec; @@ -843,47 +847,47 @@ struct _GdkColorContext { GdkVisual *visual; GdkColormap *colormap; - + gint num_colors; /* available no. of colors in colormap */ gint max_colors; /* maximum no. of colors */ gint num_allocated; /* no. of allocated colors */ - + GdkColorContextMode mode; gint need_to_free_colormap; GdkAtom std_cmap_atom; - + gulong *clut; /* color look-up table */ GdkColor *cmap; /* colormap */ - + GHashTable *color_hash; /* hash table of allocated colors */ GdkColor *palette; /* preallocated palette */ gint num_palette; /* size of palette */ - + GdkColorContextDither *fast_dither; /* fast dither matrix */ - + struct { gint red; gint green; gint blue; } shifts; - + struct { gulong red; gulong green; gulong blue; } masks; - + struct { gint red; gint green; gint blue; } bits; - + gulong max_entry; - + gulong black_pixel; gulong white_pixel; }; @@ -1098,7 +1102,7 @@ struct _GdkEventDragRequest guint8 isdrop; /* This gdk event can be generated by a couple of X events - this lets the app know whether the drop really occurred or we just set the data */ - + GdkPoint drop_coords; gchar *data_type; guint32 timestamp; diff --git a/glib/ChangeLog b/glib/ChangeLog index 69584b0afc..1c8b0d827c 100644 --- a/glib/ChangeLog +++ b/glib/ChangeLog @@ -1,3 +1,8 @@ +Mon Jun 8 01:06:47 1998 Tim Janik + + * glib.h: added enum-helper macros for code generation. + added G_BREAKPOINT(). + Sat Jun 6 14:09:22 PDT 1998 Manish Singh * gmem.c: commented out MEM_PROFILE and MEM_CHECK, causing weird diff --git a/glib/glib.h b/glib/glib.h index 343de406ad..8fe9536beb 100644 --- a/glib/glib.h +++ b/glib/glib.h @@ -117,6 +117,23 @@ #undef CLAMP #define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) + +/* Provide simple enum value macro wrappers that ease automated enum value + * stringification code. + */ +#if !defined (G_CODE_GENERATION) +#define G_ENUM( EnumerationName ) EnumerationName +#define G_FLAGS( EnumerationName ) EnumerationName +#define G_NV( VALUE_NAME , value_nick, VALUE) VALUE_NAME = (VALUE) +#define G_SV( VALUE_NAME, value_nick ) VALUE_NAME +#else /* G_CODE_GENERATION */ +#define G_ENUM( EnumerationName ) G_ENUM_E + EnumerationName + +#define G_FLAGS( EnumerationName ) G_ENUM_F + EnumerationName + +#define G_NV( VALUE_NAME , value_nick, VALUE) G_ENUM_V + VALUE_NAME + value_nick + +#define G_SV( VALUE_NAME, value_nick ) G_ENUM_V + VALUE_NAME + value_nick + +#endif /* G_CODE_GENERATION */ + + /* Provide simple macro statement wrappers (adapted from Pearl): * G_STMT_START { statements; } G_STMT_END; * can be used as a single statement, as in diff --git a/gtk/Makefile.am b/gtk/Makefile.am index c7e4f3c8ea..673d8ce909 100644 --- a/gtk/Makefile.am +++ b/gtk/Makefile.am @@ -202,19 +202,38 @@ gtkinclude_HEADERS = \ gtkwindow.h \ gtktypebuiltins.h +auto-files: + make $(srcdir)/gtk.defs + make $(srcdir)/gtktypebuiltins1.c + make $(srcdir)/gtktypebuiltins2.c + make $(srcdir)/gtktypebuiltins.h + +$(srcdir)/gtk.defs: @MAINT@ + $(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \ + awk -f $(srcdir)/makeenums.awk - defs > $@ + cat $(srcdir)/gtk-boxed.defs >> $@ + +$(srcdir)/gtktypebuiltins1.c: @MAINT@ + $(COMPILE) -E -DG_CODE_GENERATION $(srcdir)/makeenums.h $(CFLAGS) | \ + awk -f $(srcdir)/makeenums.awk - arrays > $@ + +$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el + $(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el id $< $@ + $(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el $(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el idmac $< $@ -$(srcdir)/gtktypebuiltins.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/gentypeinfo.el - $(SHELL) $(srcdir)/runelisp $(srcdir)/gentypeinfo.el id $< $@ - -$(srcdir)/gtkenumvalues.c: @MAINT@ $(srcdir)/gtk.defs $(srcdir)/makeenums.awk - awk -f makeenums.awk $(srcdir)/gtk.defs > $@ - # special remake rules -$(srcdir)/gtktypeutils.h: @MAINT@ $(srcdir)/gtktypebuiltins.h -$(srcdir)/gtktypeutils.c: @MAINT@ $(srcdir)/gtktypebuiltins.c -$(srcdir)/gtktypeutils.c: @MAINT@ $(srcdir)/gtkenumvalues.c +$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.awk +$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/makeenums.h +$(srcdir)/gtk.defs: @MAINT@ $(srcdir)/gtk-boxed.defs +$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/gtk.defs +$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.awk +$(srcdir)/gtktypebuiltins1.c: @MAINT@ $(srcdir)/makeenums.h +$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gtk.defs +$(srcdir)/gtktypebuiltins2.c: @MAINT@ $(srcdir)/gentypeinfo.el +$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gtk.defs +$(srcdir)/gtktypebuiltins.h: @MAINT@ $(srcdir)/gentypeinfo.el libgtk_1_1_la_LDFLAGS = -version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) @@ -223,13 +242,15 @@ EXTRA_DIST = \ line-wrap.xbm \ testgtkrc \ testgtkrc2 \ - gtk.defs \ gtkfeatures.h.in \ + makeenums.awk \ + makeenums.h \ runelisp \ gentypeinfo.el \ - makeenums.awk \ - gtktypebuiltins.c \ - gtkenumvalues.c \ + gtktypebuiltins1.c \ + gtktypebuiltins2.c \ + gtk-boxed.defs \ + gtk.defs \ test.xpm \ marble.xpm \ 3DRings.xpm \ diff --git a/gtk/gtk-boxed.defs b/gtk/gtk-boxed.defs new file mode 100644 index 0000000000..4132be1764 --- /dev/null +++ b/gtk/gtk-boxed.defs @@ -0,0 +1,1516 @@ +;; -*- scheme -*- + + +;;; +;;; manual portion from gtk-boxed.defs +;;; + + + +;;; Gtk boxed types + +(define-boxed GtkAccelGroup + gtk_accel_group_ref + gtk_accel_group_unref) + +(define-boxed GtkStyle + gtk_style_ref + gtk_style_unref) + +;;; Gdk boxed types + + ;(define-boxed GdkPoint + ; gdk_point_copy + ; gdk_point_destroy) + +(define-boxed GdkColormap + gdk_colormap_ref + gdk_colormap_unref) + +(define-boxed GdkVisual + gdk_visual_ref + gdk_visual_unref) + +(define-boxed GdkFont + gdk_font_ref + gdk_font_unref) + +(define-boxed GdkWindow + gdk_window_ref + gdk_window_unref) + +(define-boxed GdkEvent + gdk_event_copy + gdk_event_free + "sizeof(GdkEvent)") + +(define-boxed GdkColor + gdk_color_copy + gdk_color_free + "sizeof(GdkColor)") + +(define-func gtk_style_get_white_interp + GdkColor + ((GtkStyle style))) + +;;; Functions + +;; Gdk + +(define-func gdk_font_load + GdkFont + ((string name))) + +;; main + +(define-func gtk_exit + none + ((int code (= "0")))) + +(define-func gtk_main + none + ()) + +(define-func gtk_main_quit + none + ()) + +(define-func gtk_main_iteration + bool + ()) + +(define-func gtk_timeout_add_interp + int + ((int interval) + (callback function))) + +(define-func gtk_timeout_remove + none + ((int tag))) + +(define-func gtk_idle_add_interp + int + ((callback function))) + +(define-func gtk_idle_remove + none + ((int tag))) + +(define-func gtk_input_add_interp + int + ((int source) + (GdkInputCondition condition) + (callback callback))) + +(define-func gtk_input_remove + none + ((int tag))) + +(define-func gtk_rc_parse + none + ((string file))) + +(define-func g_mem_chunk_info + none + ()) + +;; GtkObject + +(define-func gtk_object_destroy + none + ((GtkObject object))) + +;; Signals + +(define-func gtk_signal_connect_interp + int + ((GtkObject object) + (string name) + (callback func) + (bool after (= "0")))) + +;; GtkWidget + +(define-object GtkWidget (GtkObject) + (fields + (GtkStyle style))) + +(define-func gtk_grab_add + none + ((GtkWidget widget))) + +(define-func gtk_grab_remove + none + ((GtkWidget widget))) + +(define-func GTK_WIDGET_STATE + GtkStateType + ((GtkWidget widget))) + +(define-func GTK_WIDGET_FLAGS + GtkWidgetFlags + ((GtkWidget widget))) + +(define-func GTK_WIDGET_SET_FLAGS + none + ((GtkWidget widget) + (GtkWidgetFlags flags))) + +(define-func GTK_WIDGET_UNSET_FLAGS + none + ((GtkWidget widget) + (GtkWidgetFlags flags))) + +(define-func gtk_widget_destroy + none + ((GtkWidget widget))) + +(define-func gtk_widget_unparent + none + ((GtkWidget widget))) + +(define-func gtk_widget_show + none + ((GtkWidget widget))) + +(define-func gtk_widget_hide + none + ((GtkWidget widget))) + +(define-func gtk_widget_map + none + ((GtkWidget widget))) + +(define-func gtk_widget_unmap + none + ((GtkWidget widget))) + +(define-func gtk_widget_realize + none + ((GtkWidget widget))) + +(define-func gtk_widget_unrealize + none + ((GtkWidget widget))) + +(define-func gtk_widget_add_accelerator + none + ((GtkWidget widget) + (string accel_signal) + (GtkAccelGroup accel_group) + (guint accel_key) + (guint accel_mods) + (GtkAccelFlags accel_flags))) + +(define-func gtk_widget_remove_accelerator + none + ((GtkWidget widget) + (GtkAccelGroup accel_group) + (guint accel_key) + (guint accel_mods))) + +(define-func gtk_widget_event + bool + ((GtkWidget widget) + (GdkEvent event))) + +(define-func gtk_widget_activate + none + ((GtkWidget widget))) + +(define-func gtk_widget_reparent + none + ((GtkWidget widget) + (GtkWidget new_parent))) + +(define-func gtk_widget_popup + none + ((GtkWidget widget) + (int x) + (int y))) + +(define-func gtk_widget_basic + bool + ((GtkWidget widget))) + +(define-func gtk_widget_grab_focus + none + ((GtkWidget widget))) + +(define-func gtk_widget_grab_default + none + ((GtkWidget widget))) + +(define-func gtk_widget_restore_state + none + ((GtkWidget widget))) + +(define-func gtk_widget_set_name + none + ((GtkWidget widget) + (string name))) + +(define-func gtk_widget_get_name + static_string + ((GtkWidget widget))) + +(define-func gtk_widget_set_state + none + ((GtkWidget widget) + (GtkStateType state))) + +(define-func gtk_widget_set_sensitive + none + ((GtkWidget widget) + (bool sensitive))) + +(define-func gtk_widget_set_style + none + ((GtkWidget widget) + (GtkStyle style))) + +(define-func gtk_widget_set_uposition + none + ((GtkWidget widget) + (int x) + (int y))) + +(define-func gtk_widget_set_usize + none + ((GtkWidget widget) + (int height) + (int width))) + +(define-func gtk_widget_set_events + none + ((GtkWidget widget) + (GdkEventMask events))) + +(define-func gtk_widget_set_extension_events + none + ((GtkWidget widget) + (GdkEventMask events))) + +(define-func gtk_widget_get_toplevel + GtkWidget + ((GtkWidget widget))) + + ;(define-func gtk_widget_get_ancestor + ; GtkWidget + ; ((GtkWidget widget) + ; (GtkType type))) + +(define-func gtk_widget_get_colormap + GdkColormap + ((GtkWidget widget))) + +(define-func gtk_widget_get_visual + GdkVisual + ((GtkWidget widget))) + +(define-func gtk_widget_get_style + GtkStyle + ((GtkWidget widget))) + +(define-func gtk_widget_get_events + GdkEventMask + ((GtkWidget widget))) + +(define-func gtk_widget_get_extension_events + GdkEventMask + ((GtkWidget widget))) + +(define-func gtk_widget_push_colormap + none + ((GdkColormap cmap))) + +(define-func gtk_widget_push_visual + none + ((GdkVisual visual))) + +(define-func gtk_widget_push_style + none + ((GtkStyle style))) + +(define-func gtk_widget_pop_colormap + none + ()) + +(define-func gtk_widget_pop_visual + none + ()) + +(define-func gtk_widget_pop_style + none + ()) + +(define-func gtk_widget_set_default_colormap + none + ((GdkColormap cmap))) + +(define-func gtk_widget_set_default_visual + none + ((GdkVisual visual))) + +(define-func gtk_widget_set_default_style + none + ((GtkStyle style))) + +(define-func gtk_widget_get_default_colormap + GdkColormap + ()) + +(define-func gtk_widget_get_default_visual + GdkVisual + ()) + +(define-func gtk_widget_get_default_style + GtkStyle + ()) + +;;; Container + +(define-object GtkContainer (GtkWidget)) + +(define-func gtk_container_border_width + none + ((GtkContainer container) + (int border_width))) + +(define-func gtk_container_add + none + ((GtkContainer container) + (GtkWidget widget))) + +(define-func gtk_container_remove + none + ((GtkContainer container) + (GtkWidget widget))) + +(define-func gtk_container_disable_resize + none + ((GtkContainer container))) + +(define-func gtk_container_enable_resize + none + ((GtkContainer container))) + +(define-func gtk_container_block_resize + none + ((GtkContainer container))) + +(define-func gtk_container_unblock_resize + none + ((GtkContainer container))) + +(define-func gtk_container_need_resize + bool + ((GtkContainer container))) + +(define-func gtk_container_focus + GtkDirectionType + ((GtkContainer container) + (GtkDirectionType direction))) + +;;; Bin + +(define-object GtkBin (GtkContainer)) + +;;; Window + +(define-object GtkWindow (GtkBin)) + +(define-func gtk_window_new + GtkWidget + ((GtkWindowType type))) + +(define-func gtk_window_set_title + none + ((GtkWindow window) + (string title))) + +(define-func gtk_window_set_focus + none + ((GtkWindow window) + (GtkWidget focus))) + +(define-func gtk_window_set_default + none + ((GtkWindow window) + (GtkWidget default))) + +(define-func gtk_window_set_policy + none + ((GtkWindow window) + (bool allow_shrink) + (bool allow_grow) + (bool auto_shrink))) + +(define-func gtk_window_add_accel_group + none + ((GtkWindow window) + (GtkAccelGroup accel_group))) + +(define-func gtk_window_remove_accel_group + none + ((GtkWindow window) + (GtkAccelGroup accel_group))) + +(define-func gtk_window_position + none + ((GtkWindow window) + (GtkWindowPosition position))) + +;;; Box + +(define-object GtkBox (GtkContainer)) + +(define-func gtk_box_pack_start + none + ((GtkBox box) + (GtkWidget child) + (bool expand (= "TRUE")) + (bool fill (= "TRUE")) + (int padding (= "0")))) + +(define-func gtk_box_pack_end + none + ((GtkBox box) + (GtkWidget child) + (bool expand (= "TRUE")) + (bool fill (= "TRUE")) + (int padding (= "0")))) + +(define-func gtk_box_pack_start_defaults + none + ((GtkBox box) + (GtkWidget child))) + +(define-func gtk_box_pack_end_defaults + none + ((GtkBox box) + (GtkWidget child))) + +(define-func gtk_box_set_homogeneous + none + ((GtkBox box) + (bool homogenous))) + +(define-func gtk_box_set_spacing + none + ((GtkBox box) + (int spacing))) + +;;; Table + +(define-object GtkTable (GtkContainer)) + +(define-func gtk_table_new + GtkWidget + ((int rows) + (int columns) + (bool homogenous))) + +(define-func gtk_table_attach + none + ((GtkTable table) + (GtkWidget child) + (int left_attach) + (int right_attach) + (int top_attach) + (int bottom_attach) + (GtkAttachOptions xoptions (= "GTK_EXPAND|GTK_FILL")) + (GtkAttachOptions yoptions (= "GTK_EXPAND|GTK_FILL")) + (int xpadding (= "0")) + (int ypadding (= "0")))) + +(define-func gtk_table_attach_defaults + none + ((GtkTable table) + (GtkWidget child) + (int left_attach) + (int right_attach) + (int top_attach) + (int bottom_attach))) + +(define-func gtk_table_set_row_spacing + none + ((GtkTable table) + (int row) + (int spacing))) + +(define-func gtk_table_set_col_spacing + none + ((GtkTable table) + (int column) + (int spacing))) + +(define-func gtk_table_set_row_spacings + none + ((GtkTable table) + (int spacing))) + +(define-func gtk_table_set_col_spacings + none + ((GtkTable table) + (int spacing))) + +;;; Button + +(define-object GtkButton (GtkContainer)) + +(define-func gtk_button_new + GtkWidget + ()) + +(define-func gtk_button_new_with_label + GtkWidget + ((string label))) + +(define-func gtk_button_pressed + none + ((GtkButton button))) + +(define-func gtk_button_released + none + ((GtkButton button))) + +(define-func gtk_button_clicked + none + ((GtkButton button))) + +(define-func gtk_button_enter + none + ((GtkButton button))) + +(define-func gtk_button_leave + none + ((GtkButton button))) + +;;; ToggleButton + +(define-object GtkToggleButton (GtkButton)) + +(define-func gtk_toggle_button_new + GtkWidget + ()) + +(define-func gtk_toggle_button_new_with_label + GtkWidget + ((string label))) + +(define-func gtk_toggle_button_set_mode + none + ((GtkToggleButton toggle_button) + (bool draw_indicator))) + +(define-func gtk_toggle_button_set_state + none + ((GtkToggleButton toggle_button) + (bool state))) + +(define-func gtk_toggle_button_toggled + none + ((GtkToggleButton toggle_button))) + +;;; CheckButton + +(define-object GtkCheckButton (GtkToggleButton)) + +(define-func gtk_check_button_new + GtkWidget + ()) + +(define-func gtk_check_button_new_with_label + GtkWidget + ((string label))) + +;;; RadioButton + +(define-object GtkRadioButton (GtkCheckButton)) + +(define-func gtk_radio_button_new_interp + GtkWidget + ((GtkRadioButton group (null-ok)))) + +(define-func gtk_radio_button_new_with_label_interp + GtkWidget + ((GtkRadioButton group (null-ok)) + (string label))) + +;;; Misc + +(define-object GtkMisc (GkWidget)) + +(define-func gtk_misc_set_alignment + none + ((GtkMisc misc) + (float xalign) + (float yalign))) + +(define-func gtk_misc_set_padding + none + ((GtkMisc misc) + (int xpad) + (int ypad))) + +;;; Label + +(define-object GtkLabel (GtkMisc)) + +(define-func gtk_label_new + GtkWidget + ((string str))) + +(define-func gtk_label_set + none + ((GtkLabel label) + (string str))) + +(define-func gtk_label_get_interp + static_string + ((GtkLabel label))) + +;; VBox + +(define-object GtkVBox (GtkBox)) + +(define-func gtk_vbox_new + GtkWidget + ((bool homogenous) + (int spacing))) + +;; HBox + +(define-object GtkHBox (GtkBox)) + +(define-func gtk_hbox_new + GtkWidget + ((bool homogenous) + (int spacing))) + +;; Separator + +(define-object GtkSeparator (GtkWidget)) + +;; HSeparator + +(define-object GtkHSeparator (GtkSeparator)) + +(define-func gtk_hseparator_new + GtkWidget + ()) + +;; VSeparator + +(define-object GtkVSeparator (GtkSeparator)) + +(define-func gtk_vseparator_new + GtkWidget + ()) + +;; Frame + +(define-object GtkFrame (GtkBin)) + +(define-func gtk_frame_new + GtkWidget + ((string label (null-ok)))) + +(define-func gtk_frame_set_label + none + ((GtkFrame frame) + (string label))) + +(define-func gtk_frame_set_label_align + none + ((GtkFrame frame) + (float xalign) + (float yalign))) + +(define-func gtk_frame_set_shadow_type + none + ((GtkFrame frame) + (GtkShadowType type))) + +;; Progress Bar + +(define-object GtkProgressBar (GtkWidget) + (fields + (float percentage))) + +(define-func gtk_progress_bar_new + GtkWidget + ()) + +(define-func gtk_progress_bar_update + none + ((GtkProgressBar progress_bar) + (float percentage))) + + ;(define-func gtk_progress_bar_percentage + ; float + ; ((GtkProgressBar progress_bar))) + +;; Tooltips + +(define-object GtkTooltips (GtkData)) + +(define-func gtk_tooltips_new + GtkTooltips + ()) + +(define-func gtk_tooltips_destroy + none + ((GtkTooltips tooltips))) + +(define-func gtk_tooltips_enable + none + ((GtkTooltips tooltips))) + +(define-func gtk_tooltips_disable + none + ((GtkTooltips tooltips))) + +(define-func gtk_tooltips_set_delay + none + ((GtkTooltips tooltips) + (int delay))) + +(define-func gtk_tooltips_set_tips + none + ((GtkTooltips tooltips) + (GtkWidget widget) + (string tips_text (null-ok)))) + +(define-func gtk_tooltips_set_colors + none + ((GtkTooltips tooltips) + (GdkColor background) + (GdkColor foreground))) + +;; MenuShell + +(define-object GtkMenuShell (GtkContainer)) + +(define-func gtk_menu_shell_append + none + ((GtkMenuShell menu_shell) + (GtkWidget child))) + +(define-func gtk_menu_shell_prepend + none + ((GtkMenuShell menu_shell) + (GtkWidget child))) + +(define-func gtk_menu_shell_insert + none + ((GtkMenuShell menu_shell) + (GtkWidget child) + (int position))) + +(define-func gtk_menu_shell_deactivate + none + ((GtkMenuShell menu_shell))) + +;; MenuBar + +(define-object GtkMenuBar (GtkMenuShell)) + +(define-func gtk_menu_bar_new + GtkWidget + ()) + +(define-func gtk_menu_bar_append + none + ((GtkMenuBar menu_bar) + (GtkWidget child))) + +(define-func gtk_menu_bar_prepend + none + ((GtkMenuBar menu_bar) + (GtkWidget child))) + +(define-func gtk_menu_bar_insert + none + ((GtkMenuBar menu_bar) + (GtkWidget child) + (int position))) + +;; Menu + +(define-object GtkMenu (GtkMenuShell)) + +(define-func gtk_menu_new + GtkWidget + ()) + +(define-func gtk_menu_append + none + ((GtkMenu menu) + (GtkWidget child))) + +(define-func gtk_menu_prepend + none + ((GtkMenu menu) + (GtkWidget child))) + +(define-func gtk_menu_insert + none + ((GtkMenu menu) + (GtkWidget child) + (int position))) + +(define-func gtk_menu_popup_interp + none + ((GtkMenu menu) + (GtkWidget parent_menu_shell) + (GtkWidget parent_menu_item) + (int button) + (int activate_time))) + +(define-func gtk_menu_popdown + none + ((GtkMenu menu))) + +(define-func gtk_menu_get_active + GtkWidget + ((GtkMenu menu))) + +(define-func gtk_menu_set_active + none + ((GtkMenu menu) + (int index))) + +(define-func gtk_menu_set_accel_group + none + ((GtkMenu menu) + (GtkAccelGroup accel_group))) + + +;; Item + +(define-object GtkItem (GtkBin)) + +(define-func gtk_item_select + none + ((GtkItem item))) + +(define-func gtk_item_deselect + none + ((GtkItem item))) + +(define-func gtk_item_toggle + none + ((GtkItem item))) + +;; MenuItem + +(define-object GtkMenuItem (GtkItem)) + +(define-func gtk_menu_item_new + GtkWidget + ()) + +(define-func gtk_menu_item_new_with_label + GtkWidget + ((string label))) + +(define-func gtk_menu_item_set_submenu + none + ((GtkMenuItem menu_item) + (GtkWidget submenu))) + +(define-func gtk_menu_item_set_placement + none + ((GtkMenuItem menu_item) + (GtkSubmenuPlacement placement))) + +(define-func gtk_menu_item_configure + none + ((GtkMenuItem menu_item) + (bool show_toggle_indicator) + (bool show_submenu_indicator))) + +(define-func gtk_menu_item_select + none + ((GtkMenuItem menu_item))) + +(define-func gtk_menu_item_deselect + none + ((GtkMenuItem menu_item))) + +(define-func gtk_menu_item_activate + none + ((GtkMenuItem menu_item))) + +;; CheckMenuItem + +(define-object GtkCheckMenuItem (GtkMenuItem)) + +(define-func gtk_check_menu_item_new + GtkWidget + ()) + +(define-func gtk_check_menu_item_new_with_label + GtkWidget + ((string label))) + +(define-func gtk_check_menu_item_set_state + none + ((GtkCheckMenuItem check_menu_item) + (bool state))) + +(define-func gtk_check_menu_item_toggled + none + ((GtkCheckMenuItem check_menu_item))) + +;; RadioMenuItem + +(define-object GtkRadioMenuItem (GtkCheckMenuItem)) + +(define-func gtk_radio_menu_item_new_interp + GtkWidget + ((GtkRadioMenuItem group (null-ok)))) + +(define-func gtk_radio_menu_item_new_with_label_interp + GtkWidget + ((GtkRadioMenuItem group (null-ok)) + (string label))) + +;; OptionMenu + +(define-object GtkOptionMenu (GtkButton)) + +(define-func gtk_option_menu_new + GtkWidget + ()) + +(define-func gtk_option_menu_get_menu + GtkWidget + ((GtkOptionMenu option_menu))) + +(define-func gtk_option_menu_set_menu + none + ((GtkOptionMenu option_menu) + (GtkWidget menu))) + +(define-func gtk_option_menu_remove_menu + none + ((GtkOptionMenu option_menu))) + +(define-func gtk_option_menu_set_history + none + ((GtkOptionMenu option_menu) + (int index))) + +;; Pixmaps + +(define-object GtkPixmap (GtkMisc)) + +(define-func gtk_pixmap_new_interp + GtkWidget + ((string xpm_file) + (GtkWidget intended_parent))) + +;; Data + +(define-object GtkData (GtkObject)) + +;; Adjustment + +(define-object GtkAdjustment (GtkData)) + +(define-func gtk_adjustment_new + GtkObject + ((float value) + (float lower) + (float upper) + (float step_increment) + (float page_increment) + (float page_size))) + +;; ScrolledWidow + +(define-object GtkScrolledWindow (GtkContainer)) + +(define-func gtk_scrolled_window_new + GtkWidget + ((GtkAdjustment hadjustment (null-ok) (= "NULL")) + (GtkAdjustment vadjustment (null-ok) (= "NULL")))) + +(define-func gtk_scrolled_window_get_hadjustment + GtkAdjustment + ((GtkScrolledWindow scrolled_window))) + +(define-func gtk_scrolled_window_get_vadjustment + GtkAdjustment + ((GtkScrolledWindow scrolled_window))) + +(define-func gtk_scrolled_window_set_policy + none + ((GtkScrolledWindow scrolled_window) + (GtkPolicyType hscrollbar_policy) + (GtkPolicyType vscrollbar_policy))) + +;; ListItem + +(define-object GtkListItem (GtkItem)) + +(define-func gtk_list_item_new + GtkWidget + ()) + +(define-func gtk_list_item_new_with_label + GtkWidget + ((string label))) + +(define-func gtk_list_item_select + none + ((GtkListItem list_item))) + +(define-func gtk_list_item_deselect + none + ((GtkListItem list_item))) + +;; List + +(define-object GtkList (GtkContainer)) + +(define-func gtk_list_new + GtkWidget + ()) + +(define-func gtk_list_append_item + none + ((GtkList list) + (GtkListItem item))) + +(define-func gtk_list_prepend_item + none + ((GtkList list) + (GtkListItem item))) + +;; XXX many missing + +(define-func gtk_list_clear_items + none + ((GtkList list) + (int start) + (int end))) + +(define-func gtk_list_select_item + none + ((GtkList list) + (int item))) + +(define-func gtk_list_unselect_item + none + ((GtkList list) + (int item))) + +(define-func gtk_list_select_child + none + ((GtkList list) + (GtkWidget child))) + +(define-func gtk_list_unselect_child + none + ((GtkList list) + (GtkWidget child))) + +(define-func gtk_list_child_position + int + ((GtkList list) + (GtkWidget child))) + +(define-func gtk_list_set_selection_mode + none + ((GtkList list) + (GtkSelectionMode mode))) + +;; Notebook + +(define-object GtkNotebook (GtkContainer) + (fields + (GtkPositionType tab_pos))) + +(define-func gtk_notebook_new + GtkWidget + ()) + +(define-func gtk_notebook_append_page + none + ((GtkNotebook notebook) + (GtkWidget child) + (GtkWidget tab_label))) + +(define-func gtk_notebook_prepend_page + none + ((GtkNotebook notebook) + (GtkWidget child) + (GtkWidget tab_label))) + +(define-func gtk_notebook_insert_page + none + ((GtkNotebook notebook) + (GtkWidget child) + (GtkWidget tab_label) + (int position))) + +(define-func gtk_notebook_remove_page + none + ((GtkNotebook notebook) + (int page_num))) + +(define-func gtk_notebook_current_page + int + ((GtkNotebook notebook))) + +(define-func gtk_notebook_set_page + none + ((GtkNotebook notebook) + (int page_num))) + +(define-func gtk_notebook_next_page + none + ((GtkNotebook notebook))) + +(define-func gtk_notebook_prev_page + none + ((GtkNotebook notebook))) + +(define-func gtk_notebook_set_tab_pos + none + ((GtkNotebook notebook) + (GtkPositionType pos))) + +(define-func gtk_notebook_set_show_tabs + none + ((GtkNotebook notebook) + (bool show_tabs))) + +(define-func gtk_notebook_set_show_border + none + ((GtkNotebook notebook) + (bool show_border))) + +;; Entry + +(define-object GtkEntry (GtkWidget)) + +(define-func gtk_entry_new + GtkWidget + ()) + +(define-func gtk_entry_set_text + none + ((GtkEntry entry) + (string text))) + +(define-func gtk_entry_append_text + none + ((GtkEntry entry) + (string text))) + +(define-func gtk_entry_prepend_text + none + ((GtkEntry entry) + (string text))) + +(define-func gtk_entry_set_position + none + ((GtkEntry entry) + (int position))) + +(define-func gtk_entry_get_text + static_string + ((GtkEntry entry))) + +;; Text + +(define-object GtkText (GtkWidget)) + +(define-func gtk_text_new + GtkWidget + ((GtkAdjustment hadj (null-ok)) + (GtkAdjustment vadj (null-ok)))) + +(define-func gtk_text_set_editable + none + ((GtkText text) + (bool editable))) + +(define-func gtk_text_set_adjustments + none + ((GtkText text) + (GtkAdjustment hadj) + (GtkAdjustment vadj))) + +(define-func gtk_text_set_point + none + ((GtkText text) + (uint index))) + +(define-func gtk_text_get_point + uint + ((GtkText text))) + +(define-func gtk_text_get_length + uint + ((GtkText text))) + +(define-func gtk_text_freeze + none + ((GtkText text))) + +(define-func gtk_text_thaw + none + ((GtkText text))) + +(define-func gtk_text_insert + none + ((GtkText text) + (GdkFont font (null-ok)) + (GdkColor fore (null-ok)) + (GdkColor back (null-ok)) + (string chars) + (int length))) + +(define-func gtk_text_backward_delete + none + ((GtkText text) + (uint nchars))) + +(define-func gtk_text_foreward_delete + none + ((GtkText text) + (uint nchars))) + +;; Alignment + +(define-object GtkAlignment (GtkBin)) + +(define-func gtk_alignment_new + GtkWidget + ((float xalign) + (float yalign) + (float xscale) + (float yscale))) + +(define-func gtk_alignment_set + none + ((GtkAlignment alignment) + (float xalign) + (float yalign) + (float xscale) + (float yscale))) + +;; Color + + ; XXX lots missing + +(define-func gdk_color_parse_interp + GdkColor + ((string spec))) + +;; Preview + +(define-object GtkPreview (GtkWidget)) + +;; XXX lots missing + +(define-func gtk_preview_set_install_cmap + none + ((bool install_cmap))) + +(define-func gtk_preview_set_reserved + none + ((int nreserved))) + +(define-func gtk_preview_get_visual + GdkVisual + ()) + +(define-func gtk_preview_get_cmap + GdkColormap + ()) + +;; ColorSelectionDialog + +(define-object GtkColorSelectionDialog (GtkWindow) + (fields + (GtkWidget colorsel) + (GtkWidget main_vbox) + (GtkWidget ok_button) + (GtkWidget reset_button) + (GtkWidget cancel_button) + (GtkWidget help_button))) + +(define-func gtk_color_selection_dialog_new + GtkWidget + ((string title))) + +;; ColorSelection + +(define-object GtkColorSelection (GtkVBox)) + +(define-func gtk_color_selection_new + GtkWidget + ()) + +(define-func gtk_color_selection_set_update_policy + none + ((GtkColorSelection colorsel) + (GtkUpdateType policy))) + +(define-func gtk_color_selection_set_opacity + none + ((GtkColorSelection colorsel) + (bool use_opacity))) + +;; Range + +(define-object GtkRange (GtkWidget)) + +(define-func gtk_range_get_adjustment + GtkAdjustment + ((GtkRange range))) + +(define-func gtk_range_set_update_policy + none + ((GtkRange range) + (GtkUpdateType policy))) + +(define-func gtk_range_set_adjustment + none + ((GtkRange range) + (GtkAdjustment adjustment))) + +;; Scale + +(define-object GtkScale (GtkRange)) + +(define-func gtk_scale_set_digits + none + ((GtkScale scale) + (bool digits))) + +(define-func gtk_scale_set_draw_value + none + ((GtkScale scale) + (bool draw_value))) + +(define-func gtk_scale_set_value_pos + none + ((GtkScale scale) + (GtkPositionType pos))) + +;; HScale + +(define-object GtkHScale (GtkScale)) + +(define-func gtk_hscale_new + GtkWidget + ((GtkAdjustment adjustment))) + +;; VScale + +(define-object GtkVScale (GtkScale)) + +(define-func gtk_vscale_new + GtkWidget + ((GtkAdjustment adjustment))) + +;; Scrollbar + +(define-object GtkScrollbar (GtkRange)) + +;; HScrollbar + +(define-object GtkHScrollbar (GtkScrollbar)) + +(define-func gtk_hscrollbar_new + GtkWidget + ((GtkAdjustment adjustment))) + +;; VScrollbar + +(define-object GtkVScrollbar (GtkScrollbar)) + +(define-func gtk_vscrollbar_new + GtkWidget + ((GtkAdjustment adjustment))) + +;; Dialog + +(define-object GtkDialog (GtkWindow) + (fields + (GtkWidget vbox) + (GtkWidget action_area))) + +(define-func gtk_dialog_new + GtkWidget + ()) + +;; Paned + +(define-object GtkPaned (GtkContainer)) + +(define-func gtk_paned_add1 + none + ((GtkPaned paned) + (GtkWidget child))) + +(define-func gtk_paned_add2 + none + ((GtkPaned paned) + (GtkWidget child))) + +(define-func gtk_paned_handle_size + none + ((GtkPaned paned) + (int size))) + +(define-func gtk_paned_gutter_size + none + ((GtkPaned paned) + (int size))) + +;; HPaned + +(define-object GtkHPaned (GtkPaned)) + +(define-func gtk_hpaned_new + GtkWidget + ()) + +;; VPaned + +(define-object GtkVPaned (GtkPaned)) + +(define-func gtk_vpaned_new + GtkWidget + ()) + +;;; hack + +;(define-func panel_register_toy +; none +; ((gpointer panel) +; (GtkWidget applet) +; (string id) +; (string params) +; (int x) +; (int y) +; (int flags))) + +;(define-func panel_quit +; none +; ((gpointer panel))) + +;(define-func panel_new_applet +; none +; ((gpointer panel) +; (string applet) +; (string params))) diff --git a/gtk/gtk.defs b/gtk/gtk.defs index 7e635269d6..2942601176 100644 --- a/gtk/gtk.defs +++ b/gtk/gtk.defs @@ -1,249 +1,5 @@ -;; -*- scheme -*- +;; generated by makeenums.awk ; -*- scheme -*- -;;; Gtk enums from gtkenums.h - -(define-flags GtkAccelFlags - (visible GTK_ACCEL_VISIBLE) - (signal-visible GTK_ACCEL_SIGNAL_VISIBLE) - (locked GTK_ACCEL_LOCKED) - (mask GTK_ACCEL_MASK)) - -(define-enum GtkArrowType - (up GTK_ARROW_UP) - (down GTK_ARROW_DOWN) - (left GTK_ARROW_LEFT) - (right GTK_ARROW_RIGHT)) - -(define-flags GtkAttachOptions - (expand GTK_EXPAND) - (shrink GTK_SHRINK) - (fill GTK_FILL)) - -(define-enum GtkButtonBoxStyle - (default GTK_BUTTONBOX_DEFAULT_STYLE) - (spread GTK_BUTTONBOX_SPREAD) - (edge GTK_BUTTONBOX_EDGE) - (start GTK_BUTTONBOX_START) - (end GTK_BUTTONBOX_END)) - -(define-enum GtkDirectionType - (tab-forward GTK_DIR_TAB_FORWARD) - (tab-backward GTK_DIR_TAB_BACKWARD) - (up GTK_DIR_UP) - (down GTK_DIR_DOWN) - (left GTK_DIR_LEFT) - (right GTK_DIR_RIGHT)) - -(define-enum GtkJustification - (left GTK_JUSTIFY_LEFT) - (right GTK_JUSTIFY_RIGHT) - (center GTK_JUSTIFY_CENTER) - (fill GTK_JUSTIFY_FILL)) - -(define-enum GtkMatchType - (all GTK_MATCH_ALL) - (all-tail GTK_MATCH_ALL_TAIL) - (head GTK_MATCH_HEAD) - (tail GTK_MATCH_TAIL) - (exact GTK_MATCH_EXACT) - (last GTK_MATCH_LAST)) - -(define-enum GtkMenuFactoryType - (menu GTK_MENU_FACTORY_MENU) - (menu-bar GTK_MENU_FACTORY_MENU_BAR) - (option-menu GTK_MENU_FACTORY_OPTION_MENU)) - -(define-enum GtkMetricType - (pixels GTK_PIXELS) - (inches GTK_INCHES) - (centimeters GTK_CENTIMETERS)) - -(define-enum GtkOrientation - (horizontal GTK_ORIENTATION_HORIZONTAL) - (vertical GTK_ORIENTATION_VERTICAL)) - -(define-enum GtkPackType - (start GTK_PACK_START) - (end GTK_PACK_END)) - -(define-enum GtkPathPriorityType - (lowest GTK_PATH_PRIO_LOWEST) - (gtk GTK_PATH_PRIO_GTK) - (application GTK_PATH_PRIO_APPLICATION) - (rc GTK_PATH_PRIO_RC) - (highest GTK_PATH_PRIO_HIGHEST) - (mask GTK_PATH_PRIO_MASK)) - -(define-enum GtkPathType - (widget GTK_PATH_WIDGET) - (widget-class GTK_PATH_WIDGET_CLASS) - (class GTK_PATH_CLASS)) - -(define-enum GtkPolicyType - (always GTK_POLICY_ALWAYS) - (automatic GTK_POLICY_AUTOMATIC)) - -(define-enum GtkPositionType - (left GTK_POS_LEFT) - (right GTK_POS_RIGHT) - (top GTK_POS_TOP) - (bottom GTK_POS_BOTTOM)) - -(define-enum GtkPreviewType - (color GTK_PREVIEW_COLOR) - (grayscale GTK_PREVIEW_GRAYSCALE)) - -(define-enum GtkReliefStyle - (normal GTK_RELIEF_NORMAL) - (none GTK_RELIEF_NONE)) - -(define-enum GtkScrollType - (none GTK_SCROLL_NONE) - (step-backward GTK_SCROLL_STEP_BACKWARD) - (step-forward GTK_SCROLL_STEP_FORWARD) - (page-backward GTK_SCROLL_PAGE_BACKWARD) - (page-forward GTK_SCROLL_PAGE_FORWARD) - (jump GTK_SCROLL_JUMP)) - -(define-enum GtkSelectionMode - (single GTK_SELECTION_SINGLE) - (browse GTK_SELECTION_BROWSE) - (multiple GTK_SELECTION_MULTIPLE) - (extended GTK_SELECTION_EXTENDED)) - -(define-enum GtkShadowType - (none GTK_SHADOW_NONE) - (in GTK_SHADOW_IN) - (out GTK_SHADOW_OUT) - (etched-in GTK_SHADOW_ETCHED_IN) - (etched-out GTK_SHADOW_ETCHED_OUT)) - -(define-flags GtkSignalRunType - (first GTK_RUN_FIRST) - (last GTK_RUN_LAST) - (both GTK_RUN_BOTH) - (mask GTK_RUN_MASK) - (no-recurse GTK_RUN_NO_RECURSE)) - -(define-enum GtkStateType - (normal GTK_STATE_NORMAL) - (active GTK_STATE_ACTIVE) - (prelight GTK_STATE_PRELIGHT) - (selected GTK_STATE_SELECTED) - (insensitive GTK_STATE_INSENSITIVE)) - -(define-enum GtkSubmenuDirection - (left GTK_DIRECTION_LEFT) - (right GTK_DIRECTION_RIGHT)) - -(define-enum GtkSubmenuPlacement - (top-bottom GTK_TOP_BOTTOM) - (left-right GTK_LEFT_RIGHT)) - -(define-enum GtkToolbarStyle - (icons GTK_TOOLBAR_ICONS) - (text GTK_TOOLBAR_TEXT) - (both GTK_TOOLBAR_BOTH)) - -(define-enum GtkTroughType - (none GTK_TROUGH_NONE) - (start GTK_TROUGH_START) - (end GTK_TROUGH_END) - (jump GTK_TROUGH_JUMP)) - -(define-enum GtkUpdateType - (continuous GTK_UPDATE_CONTINUOUS) - (discontinuous GTK_UPDATE_DISCONTINUOUS) - (delayed GTK_UPDATE_DELAYED)) - -(define-enum GtkVisibility - (none GTK_VISIBILITY_NONE) - (discontinuous GTK_UPDATE_DISCONTINUOUS) - (delayed GTK_UPDATE_DELAYED)) - -(define-enum GtkWindowPosition - (none GTK_WIN_POS_NONE) - (center GTK_WIN_POS_CENTER) - (mouse GTK_WIN_POS_MOUSE)) - -(define-enum GtkWindowType - (toplevel GTK_WINDOW_TOPLEVEL) - (dialog GTK_WINDOW_DIALOG) - (popup GTK_WINDOW_POPUP)) - -;;; Gtk enums from gtkobject.h - -(define-flags GtkObjectFlags - (destroyed GTK_DESTROYED) - (floating GTK_FLOATING) - (connected GTK_CONNECTED) - (object-flag-last GTK_OBJECT_FLAG_LAST)) - -(define-flags GtkArgFlags - (readable GTK_ARG_READABLE) - (writable GTK_ARG_WRITABLE) - (construct GTK_ARG_CONSTRUCT) - (mask GTK_ARG_MASK) - (readwrite GTK_ARG_READWRITE)) - -;;; Gtk enums from gtkwidget.h - -(define-flags GtkWidgetFlags - (toplevel GTK_TOPLEVEL) - (no-window GTK_NO_WINDOW) - (realized GTK_REALIZED) - (mapped GTK_MAPPED) - (visible GTK_VISIBLE) - (sensitive GTK_SENSITIVE) - (parent-sensitive GTK_PARENT_SENSITIVE) - (can-focus GTK_CAN_FOCUS) - (has-focus GTK_HAS_FOCUS) - (can-default GTK_CAN_DEFAULT) - (has-default GTK_HAS_DEFAULT) - (has-grab GTK_HAS_GRAB) - (rc-style GTK_RC_STYLE) - (basic GTK_BASIC)) - -;;; Gtk enums from gtkprivate.h - -(define-flags GtkPrivateFlags - (user-style PRIVATE_GTK_USER_STYLE) - (redraw-pending PRIVATE_GTK_REDRAW_PENDING) - (resize-pending PRIVATE_GTK_RESIZE_PENDING) - (resize-needed PRIVATE_GTK_RESIZE_NEEDED) - (leave-pending PRIVATE_GTK_LEAVE_PENDING) - (has-shape-mask PRIVATE_GTK_HAS_SHAPE_MASK) - (in-reparent PRIVATE_GTK_IN_REPARENT)) - -(define-enum GtkCurveType - (linear GTK_CURVE_TYPE_LINEAR) - (spline GTK_CURVE_TYPE_SPLINE) - (free GTK_CURVE_TYPE_FREE)) - -(define-enum GtkFundamentalType - (invalid GTK_TYPE_INVALID) - (none GTK_TYPE_NONE) - (char GTK_TYPE_CHAR) - (bool GTK_TYPE_BOOL) - (int GTK_TYPE_INT) - (uint GTK_TYPE_UINT) - (long GTK_TYPE_LONG) - (ulong GTK_TYPE_ULONG) - (float GTK_TYPE_FLOAT) - (double GTK_TYPE_DOUBLE) - (string GTK_TYPE_STRING) - (enum GTK_TYPE_ENUM) - (flags GTK_TYPE_FLAGS) - (boxed GTK_TYPE_BOXED) - (foreign GTK_TYPE_FOREIGN) - (callback GTK_TYPE_CALLBACK) - (args GTK_TYPE_ARGS) - (pointer GTK_TYPE_POINTER) - (signal GTK_TYPE_SIGNAL) - (c-callback GTK_TYPE_C_CALLBACK) - (object GTK_TYPE_OBJECT)) - -;;; Gdk enums (define-enum GdkWindowType (root GDK_WINDOW_ROOT) @@ -251,7 +7,8 @@ (child GDK_WINDOW_CHILD) (dialog GDK_WINDOW_DIALOG) (temp GDK_WINDOW_TEMP) - (pixmap GDK_WINDOW_PIXMAP)) + (pixmap GDK_WINDOW_PIXMAP) + (foreign GDK_WINDOW_FOREIGN)) (define-enum GdkWindowClass (input-output GDK_INPUT_OUTPUT) @@ -270,13 +27,19 @@ (true-color GDK_VISUAL_TRUE_COLOR) (direct-color GDK_VISUAL_DIRECT_COLOR)) +(define-enum GdkFontType + (font GDK_FONT_FONT) + (fontset GDK_FONT_FONTSET)) + (define-flags GdkWindowAttributesType (title GDK_WA_TITLE) (x GDK_WA_X) (y GDK_WA_Y) (cursor GDK_WA_CURSOR) (colormap GDK_WA_COLORMAP) - (visual GDK_WA_VISUAL)) + (visual GDK_WA_VISUAL) + (wmclass GDK_WA_WMCLASS) + (noredir GDK_WA_NOREDIR)) (define-flags GdkWindowHints (pos GDK_HINT_POS) @@ -294,6 +57,10 @@ (stippled GDK_STIPPLED) (opaque-stippled GDK_OPAQUE_STIPPLED)) +(define-enum GdkFillRule + (even-odd-rule GDK_EVEN_ODD_RULE) + (winding-rule GDK_WINDING_RULE)) + (define-enum GdkLineStyle (solid GDK_LINE_SOLID) (on-off-dash GDK_LINE_ON_OFF_DASH) @@ -310,8 +77,15 @@ (round GDK_JOIN_ROUND) (bevel GDK_JOIN_BEVEL)) -(define-enum GdkCursorType - (cursor GDK_LAST_CURSOR)) +(define-enum GdkFilterReturn + (continue GDK_FILTER_CONTINUE) + (translate GDK_FILTER_TRANSLATE) + (remove GDK_FILTER_REMOVE)) + +(define-enum GdkVisibilityState + (unobscured GDK_VISIBILITY_UNOBSCURED) + (partial GDK_VISIBILITY_PARTIAL) + (fully-obscured GDK_VISIBILITY_FULLY_OBSCURED)) (define-enum GdkEventType (nothing GDK_NOTHING) @@ -378,7 +152,7 @@ (nonlinear-virtual GDK_NOTIFY_NONLINEAR_VIRTUAL) (unknown GDK_NOTIFY_UNKNOWN)) -(define-flags GdkCrossingMode +(define-enum GdkCrossingMode (crossing-normal GDK_CROSSING_NORMAL) (crossing-grab GDK_CROSSING_GRAB) (crossing-ungrab GDK_CROSSING_UNGRAB)) @@ -453,6 +227,349 @@ (prepend GDK_PROP_MODE_PREPEND) (append GDK_PROP_MODE_APPEND)) +(define-enum GdkDndType + (notdnd GDK_DNDTYPE_NOTDND) + (unknown GDK_DNDTYPE_UNKNOWN) + (rawdata GDK_DNDTYPE_RAWDATA) + (file GDK_DNDTYPE_FILE) + (files GDK_DNDTYPE_FILES) + (text GDK_DNDTYPE_TEXT) + (dir GDK_DNDTYPE_DIR) + (link GDK_DNDTYPE_LINK) + (exe GDK_DNDTYPE_EXE) + (url GDK_DNDTYPE_URL) + (mime GDK_DNDTYPE_MIME) + (end GDK_DNDTYPE_END)) + +(define-enum GdkInputSource + (mouse GDK_SOURCE_MOUSE) + (pen GDK_SOURCE_PEN) + (eraser GDK_SOURCE_ERASER) + (cursor GDK_SOURCE_CURSOR)) + +(define-enum GdkInputMode + (disabled GDK_MODE_DISABLED) + (screen GDK_MODE_SCREEN) + (window GDK_MODE_WINDOW)) + +(define-enum GdkAxisUse + (ignore GDK_AXIS_IGNORE) + (x GDK_AXIS_X) + (y GDK_AXIS_Y) + (pressure GDK_AXIS_PRESSURE) + (xtilt GDK_AXIS_XTILT) + (ytilt GDK_AXIS_YTILT) + (last GDK_AXIS_LAST)) + +(define-enum GdkTarget + (bitmap GDK_TARGET_BITMAP) + (colormap GDK_TARGET_COLORMAP) + (drawable GDK_TARGET_DRAWABLE) + (pixmap GDK_TARGET_PIXMAP) + (string GDK_TARGET_STRING)) + +(define-enum GdkSelectionType + (atom GDK_SELECTION_TYPE_ATOM) + (bitmap GDK_SELECTION_TYPE_BITMAP) + (colormap GDK_SELECTION_TYPE_COLORMAP) + (drawable GDK_SELECTION_TYPE_DRAWABLE) + (integer GDK_SELECTION_TYPE_INTEGER) + (pixmap GDK_SELECTION_TYPE_PIXMAP) + (window GDK_SELECTION_TYPE_WINDOW) + (string GDK_SELECTION_TYPE_STRING)) + +(define-enum GdkExtensionMode + (none GDK_EXTENSION_EVENTS_NONE) + (all GDK_EXTENSION_EVENTS_ALL) + (cursor GDK_EXTENSION_EVENTS_CURSOR)) + +(define-flags GdkWMDecoration + (all GDK_DECOR_ALL) + (border GDK_DECOR_BORDER) + (resizeh GDK_DECOR_RESIZEH) + (title GDK_DECOR_TITLE) + (menu GDK_DECOR_MENU) + (minimize GDK_DECOR_MINIMIZE) + (maximize GDK_DECOR_MAXIMIZE)) + +(define-flags GdkWMFunction + (all GDK_FUNC_ALL) + (resize GDK_FUNC_RESIZE) + (move GDK_FUNC_MOVE) + (minimize GDK_FUNC_MINIMIZE) + (maximize GDK_FUNC_MAXIMIZE) + (close GDK_FUNC_CLOSE)) + +(define-enum GdkColorContextMode + (undefined GDK_CC_MODE_UNDEFINED) + (bw GDK_CC_MODE_BW) + (std-cmap GDK_CC_MODE_STD_CMAP) + (true GDK_CC_MODE_TRUE) + (my-gray GDK_CC_MODE_MY_GRAY) + (palette GDK_CC_MODE_PALETTE)) + +(define-enum GdkOverlapType + (in GDK_OVERLAP_RECTANGLE_IN) + (out GDK_OVERLAP_RECTANGLE_OUT) + (part GDK_OVERLAP_RECTANGLE_PART)) + +(define-flags GtkAccelFlags + (visible GTK_ACCEL_VISIBLE) + (signal-visible GTK_ACCEL_SIGNAL_VISIBLE) + (locked GTK_ACCEL_LOCKED) + (mask GTK_ACCEL_MASK)) + +(define-enum GtkArrowType + (up GTK_ARROW_UP) + (down GTK_ARROW_DOWN) + (left GTK_ARROW_LEFT) + (right GTK_ARROW_RIGHT)) + +(define-flags GtkAttachOptions + (expand GTK_EXPAND) + (shrink GTK_SHRINK) + (fill GTK_FILL)) + +(define-enum GtkButtonBoxStyle + (default GTK_BUTTONBOX_DEFAULT_STYLE) + (spread GTK_BUTTONBOX_SPREAD) + (edge GTK_BUTTONBOX_EDGE) + (start GTK_BUTTONBOX_START) + (end GTK_BUTTONBOX_END)) + +(define-enum GtkCurveType + (linear GTK_CURVE_TYPE_LINEAR) + (spline GTK_CURVE_TYPE_SPLINE) + (free GTK_CURVE_TYPE_FREE)) + +(define-enum GtkDirectionType + (tab-forward GTK_DIR_TAB_FORWARD) + (tab-backward GTK_DIR_TAB_BACKWARD) + (up GTK_DIR_UP) + (down GTK_DIR_DOWN) + (left GTK_DIR_LEFT) + (right GTK_DIR_RIGHT)) + +(define-enum GtkJustification + (left GTK_JUSTIFY_LEFT) + (right GTK_JUSTIFY_RIGHT) + (center GTK_JUSTIFY_CENTER) + (fill GTK_JUSTIFY_FILL)) + +(define-enum GtkMatchType + (all GTK_MATCH_ALL) + (all-tail GTK_MATCH_ALL_TAIL) + (head GTK_MATCH_HEAD) + (tail GTK_MATCH_TAIL) + (exact GTK_MATCH_EXACT) + (last GTK_MATCH_LAST)) + +(define-enum GtkMenuFactoryType + (menu GTK_MENU_FACTORY_MENU) + (menu-bar GTK_MENU_FACTORY_MENU_BAR) + (option-menu GTK_MENU_FACTORY_OPTION_MENU)) + +(define-enum GtkMetricType + (pixels GTK_PIXELS) + (inches GTK_INCHES) + (centimeters GTK_CENTIMETERS)) + +(define-enum GtkOrientation + (horizontal GTK_ORIENTATION_HORIZONTAL) + (vertical GTK_ORIENTATION_VERTICAL)) + +(define-enum GtkPackType + (start GTK_PACK_START) + (end GTK_PACK_END)) + +(define-enum GtkPathPriorityType + (lowest GTK_PATH_PRIO_LOWEST) + (gtk GTK_PATH_PRIO_GTK) + (application GTK_PATH_PRIO_APPLICATION) + (rc GTK_PATH_PRIO_RC) + (highest GTK_PATH_PRIO_HIGHEST) + (mask GTK_PATH_PRIO_MASK)) + +(define-enum GtkPathType + (widget GTK_PATH_WIDGET) + (widget-class GTK_PATH_WIDGET_CLASS) + (class GTK_PATH_CLASS)) + +(define-enum GtkPolicyType + (always GTK_POLICY_ALWAYS) + (automatic GTK_POLICY_AUTOMATIC)) + +(define-enum GtkPositionType + (left GTK_POS_LEFT) + (right GTK_POS_RIGHT) + (top GTK_POS_TOP) + (bottom GTK_POS_BOTTOM)) + +(define-enum GtkPreviewType + (color GTK_PREVIEW_COLOR) + (grayscale GTK_PREVIEW_GRAYSCALE) + (greyscale GTK_PREVIEW_GREYSCALE)) + +(define-enum GtkReliefStyle + (normal GTK_RELIEF_NORMAL) + (none GTK_RELIEF_NONE)) + +(define-enum GtkScrollType + (none GTK_SCROLL_NONE) + (step-backward GTK_SCROLL_STEP_BACKWARD) + (step-forward GTK_SCROLL_STEP_FORWARD) + (page-backward GTK_SCROLL_PAGE_BACKWARD) + (page-forward GTK_SCROLL_PAGE_FORWARD) + (jump GTK_SCROLL_JUMP)) + +(define-enum GtkSelectionMode + (single GTK_SELECTION_SINGLE) + (browse GTK_SELECTION_BROWSE) + (multiple GTK_SELECTION_MULTIPLE) + (extended GTK_SELECTION_EXTENDED)) + +(define-enum GtkShadowType + (none GTK_SHADOW_NONE) + (in GTK_SHADOW_IN) + (out GTK_SHADOW_OUT) + (etched-in GTK_SHADOW_ETCHED_IN) + (etched-out GTK_SHADOW_ETCHED_OUT)) + +(define-flags GtkSignalRunType + (first GTK_RUN_FIRST) + (last GTK_RUN_LAST) + (both GTK_RUN_BOTH) + (mask GTK_RUN_MASK) + (no-recurse GTK_RUN_NO_RECURSE)) + +(define-enum GtkStateType + (normal GTK_STATE_NORMAL) + (active GTK_STATE_ACTIVE) + (prelight GTK_STATE_PRELIGHT) + (selected GTK_STATE_SELECTED) + (insensitive GTK_STATE_INSENSITIVE)) + +(define-enum GtkSubmenuDirection + (left GTK_DIRECTION_LEFT) + (right GTK_DIRECTION_RIGHT)) + +(define-enum GtkSubmenuPlacement + (top-bottom GTK_TOP_BOTTOM) + (left-right GTK_LEFT_RIGHT)) + +(define-enum GtkToolbarStyle + (icons GTK_TOOLBAR_ICONS) + (text GTK_TOOLBAR_TEXT) + (both GTK_TOOLBAR_BOTH)) + +(define-enum GtkTroughType + (none GTK_TROUGH_NONE) + (start GTK_TROUGH_START) + (end GTK_TROUGH_END) + (jump GTK_TROUGH_JUMP)) + +(define-enum GtkUpdateType + (continuous GTK_UPDATE_CONTINUOUS) + (discontinuous GTK_UPDATE_DISCONTINUOUS) + (delayed GTK_UPDATE_DELAYED)) + +(define-enum GtkVisibility + (none GTK_VISIBILITY_NONE) + (partial GTK_VISIBILITY_PARTIAL) + (full GTK_VISIBILITY_FULL)) + +(define-enum GtkWindowPosition + (none GTK_WIN_POS_NONE) + (center GTK_WIN_POS_CENTER) + (mouse GTK_WIN_POS_MOUSE)) + +(define-enum GtkWindowType + (toplevel GTK_WINDOW_TOPLEVEL) + (dialog GTK_WINDOW_DIALOG) + (popup GTK_WINDOW_POPUP)) + +(define-enum GtkFundamentalType + (invalid GTK_TYPE_INVALID) + (none GTK_TYPE_NONE) + (char GTK_TYPE_CHAR) + (bool GTK_TYPE_BOOL) + (int GTK_TYPE_INT) + (uint GTK_TYPE_UINT) + (long GTK_TYPE_LONG) + (ulong GTK_TYPE_ULONG) + (float GTK_TYPE_FLOAT) + (double GTK_TYPE_DOUBLE) + (string GTK_TYPE_STRING) + (enum GTK_TYPE_ENUM) + (flags GTK_TYPE_FLAGS) + (boxed GTK_TYPE_BOXED) + (foreign GTK_TYPE_FOREIGN) + (callback GTK_TYPE_CALLBACK) + (args GTK_TYPE_ARGS) + (pointer GTK_TYPE_POINTER) + (signal GTK_TYPE_SIGNAL) + (c-callback GTK_TYPE_C_CALLBACK) + (object GTK_TYPE_OBJECT)) + +(define-flags GtkDebugFlag + (objects GTK_DEBUG_OBJECTS) + (misc GTK_DEBUG_MISC) + (signals GTK_DEBUG_SIGNALS)) + +(define-flags GtkObjectFlags + (destroyed GTK_DESTROYED) + (floating GTK_FLOATING) + (connected GTK_CONNECTED) + (object-flag-last GTK_OBJECT_FLAG_LAST)) + +(define-flags GtkArgFlags + (readable GTK_ARG_READABLE) + (writable GTK_ARG_WRITABLE) + (construct GTK_ARG_CONSTRUCT) + (mask GTK_ARG_MASK) + (readwrite GTK_ARG_READWRITE)) + +(define-flags GtkWidgetFlags + (toplevel GTK_TOPLEVEL) + (no-window GTK_NO_WINDOW) + (realized GTK_REALIZED) + (mapped GTK_MAPPED) + (visible GTK_VISIBLE) + (sensitive GTK_SENSITIVE) + (parent-sensitive GTK_PARENT_SENSITIVE) + (can-focus GTK_CAN_FOCUS) + (has-focus GTK_HAS_FOCUS) + (can-default GTK_CAN_DEFAULT) + (has-default GTK_HAS_DEFAULT) + (has-grab GTK_HAS_GRAB) + (rc-style GTK_RC_STYLE) + (basic GTK_BASIC)) + +(define-flags GtkPrivateFlags + (user-style PRIVATE_GTK_USER_STYLE) + (redraw-pending PRIVATE_GTK_REDRAW_PENDING) + (resize-pending PRIVATE_GTK_RESIZE_PENDING) + (resize-needed PRIVATE_GTK_RESIZE_NEEDED) + (leave-pending PRIVATE_GTK_LEAVE_PENDING) + (has-shape-mask PRIVATE_GTK_HAS_SHAPE_MASK) + (in-reparent PRIVATE_GTK_IN_REPARENT)) + +(define-flags GdkDebugFlag + (misc GDK_DEBUG_MISC) + (events GDK_DEBUG_EVENTS) + (dnd GDK_DEBUG_DND) + (color-context GDK_DEBUG_COLOR_CONTEXT) + (xim GDK_DEBUG_XIM)) + +;; -*- scheme -*- + + +;;; +;;; manual portion from gtk-boxed.defs +;;; + + + ;;; Gtk boxed types (define-boxed GtkAccelGroup @@ -465,9 +582,9 @@ ;;; Gdk boxed types - ;(define-boxed GdkPoint - ; gdk_point_copy - ; gdk_point_destroy) + ;(define-boxed GdkPoint + ; gdk_point_copy + ; gdk_point_destroy) (define-boxed GdkColormap gdk_colormap_ref @@ -741,10 +858,10 @@ GtkWidget ((GtkWidget widget))) - ;(define-func gtk_widget_get_ancestor - ; GtkWidget - ; ((GtkWidget widget) - ; (GtkType type))) + ;(define-func gtk_widget_get_ancestor + ; GtkWidget + ; ((GtkWidget widget) + ; (GtkType type))) (define-func gtk_widget_get_colormap GdkColormap @@ -1194,9 +1311,9 @@ ((GtkProgressBar progress_bar) (float percentage))) - ;(define-func gtk_progress_bar_percentage - ; float - ; ((GtkProgressBar progress_bar))) + ;(define-func gtk_progress_bar_percentage + ; float + ; ((GtkProgressBar progress_bar))) ;; Tooltips @@ -1754,7 +1871,7 @@ ;; Color - ; XXX lots missing + ; XXX lots missing (define-func gdk_color_parse_interp GdkColor diff --git a/gtk/gtkcolorsel.c b/gtk/gtkcolorsel.c index 82435222e6..fd72793942 100644 --- a/gtk/gtkcolorsel.c +++ b/gtk/gtkcolorsel.c @@ -16,7 +16,10 @@ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ +#include +#include #include +#include #include "gtkcolorsel.h" #include "gtkhbbox.h" diff --git a/gtk/gtkcolorsel.h b/gtk/gtkcolorsel.h index 9646605fe9..449bc798ca 100644 --- a/gtk/gtkcolorsel.h +++ b/gtk/gtkcolorsel.h @@ -19,11 +19,6 @@ #ifndef __GTK_COLORSEL_H__ #define __GTK_COLORSEL_H__ -#include -#include -#include -#include - #include #include #include diff --git a/gtk/gtkdebug.h b/gtk/gtkdebug.h index c74553fbbe..dedcc0f6b5 100644 --- a/gtk/gtkdebug.h +++ b/gtk/gtkdebug.h @@ -24,10 +24,10 @@ extern "C" { #endif /* __cplusplus */ typedef enum { - GTK_DEBUG_OBJECTS = 1<<0, - GTK_DEBUG_MISC = 1<<1, - GTK_DEBUG_SIGNALS = 1<<2 -} GtkDebugFlag; + G_NV (GTK_DEBUG_OBJECTS, objects, 1 << 0), + G_NV (GTK_DEBUG_MISC, misc, 1 << 1), + G_NV (GTK_DEBUG_SIGNALS, signals, 1 << 2) +} G_FLAGS (GtkDebugFlag); #ifdef G_ENABLE_DEBUG diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h index 26d3b7a593..e8db3ff45a 100644 --- a/gtk/gtkenums.h +++ b/gtk/gtkenums.h @@ -19,288 +19,290 @@ #ifndef __GTK_ENUMS_H__ #define __GTK_ENUMS_H__ +#include + #ifdef __cplusplus extern "C" { #pragma } #endif /* __cplusplus */ -/* the enum definitions in this file are ordered alphabetically. - * this file *must* be kept in sync with gtk.defs - */ - -/* Accelerator flags */ typedef enum { - GTK_ACCEL_VISIBLE = 1 << 0 /* should the accelerator appear in - * the widget's display? - */, - GTK_ACCEL_SIGNAL_VISIBLE = 1 << 1 /* should the signal associated with - * this accelerator be also visible? - */, - GTK_ACCEL_LOCKED = 1 << 2 /* may the accelerator be removed - * again? - */, - GTK_ACCEL_MASK = 0x07 -} GtkAccelFlags; + /* should the accelerator appear in + * the widget's display? + */ + G_NV (GTK_ACCEL_VISIBLE, visible, 1 << 0), + /* should the signal associated with + * this accelerator be also visible? + */ + G_NV (GTK_ACCEL_SIGNAL_VISIBLE, signal-visible, 1 << 1), + /* may the accelerator be removed + * again? + */ + G_NV (GTK_ACCEL_LOCKED, locked, 1 << 2), + G_NV (GTK_ACCEL_MASK, mask, 0x07) +} G_FLAGS (GtkAccelFlags); + /* Arrow types */ typedef enum { - GTK_ARROW_UP, - GTK_ARROW_DOWN, - GTK_ARROW_LEFT, - GTK_ARROW_RIGHT -} GtkArrowType; + G_SV (GTK_ARROW_UP, up), + G_SV (GTK_ARROW_DOWN, down), + G_SV (GTK_ARROW_LEFT, left), + G_SV (GTK_ARROW_RIGHT, right), +} G_ENUM (GtkArrowType); /* Attach options (for tables) */ typedef enum { - GTK_EXPAND = 1 << 0, - GTK_SHRINK = 1 << 1, - GTK_FILL = 1 << 2 -} GtkAttachOptions; + G_NV (GTK_EXPAND, expand, 1 << 0), + G_NV (GTK_SHRINK, shrink, 1 << 1), + G_NV (GTK_FILL, fill, 1 << 2) +} G_FLAGS (GtkAttachOptions); /* button box styles */ typedef enum { - GTK_BUTTONBOX_DEFAULT_STYLE, - GTK_BUTTONBOX_SPREAD, - GTK_BUTTONBOX_EDGE, - GTK_BUTTONBOX_START, - GTK_BUTTONBOX_END -} GtkButtonBoxStyle; + G_SV (GTK_BUTTONBOX_DEFAULT_STYLE, default), + G_SV (GTK_BUTTONBOX_SPREAD, spread), + G_SV (GTK_BUTTONBOX_EDGE, edge), + G_SV (GTK_BUTTONBOX_START, start), + G_SV (GTK_BUTTONBOX_END, end), +} G_ENUM (GtkButtonBoxStyle); /* curve types */ typedef enum { - GTK_CURVE_TYPE_LINEAR, /* linear interpolation */ - GTK_CURVE_TYPE_SPLINE, /* spline interpolation */ - GTK_CURVE_TYPE_FREE /* free form curve */ -} GtkCurveType; + G_SV (GTK_CURVE_TYPE_LINEAR, linear) /* linear interpolation */, + G_SV (GTK_CURVE_TYPE_SPLINE, spline) /* spline interpolation */, + G_SV (GTK_CURVE_TYPE_FREE, free) /* free form curve */ +} G_ENUM (GtkCurveType); /* Focus movement types */ typedef enum { - GTK_DIR_TAB_FORWARD, - GTK_DIR_TAB_BACKWARD, - GTK_DIR_UP, - GTK_DIR_DOWN, - GTK_DIR_LEFT, - GTK_DIR_RIGHT -} GtkDirectionType; + G_SV (GTK_DIR_TAB_FORWARD, tab-forward), + G_SV (GTK_DIR_TAB_BACKWARD, tab-backward), + G_SV (GTK_DIR_UP, up), + G_SV (GTK_DIR_DOWN, down), + G_SV (GTK_DIR_LEFT, left), + G_SV (GTK_DIR_RIGHT, right) +} G_ENUM (GtkDirectionType); /* justification for label and maybe other widgets (text?) */ typedef enum { - GTK_JUSTIFY_LEFT, - GTK_JUSTIFY_RIGHT, - GTK_JUSTIFY_CENTER, - GTK_JUSTIFY_FILL -} GtkJustification; + G_SV (GTK_JUSTIFY_LEFT, left), + G_SV (GTK_JUSTIFY_RIGHT, right), + G_SV (GTK_JUSTIFY_CENTER, center), + G_SV (GTK_JUSTIFY_FILL, fill), +} G_ENUM (GtkJustification); /* GtkPatternSpec match types */ typedef enum { - GTK_MATCH_ALL /* "*A?A*" */, - GTK_MATCH_ALL_TAIL /* "*A?AA" */, - GTK_MATCH_HEAD /* "AAAA*" */, - GTK_MATCH_TAIL /* "*AAAA" */, - GTK_MATCH_EXACT /* "AAAAA" */, - GTK_MATCH_LAST -} GtkMatchType; + G_SV (GTK_MATCH_ALL, all) /* "*A?A*" */, + G_SV (GTK_MATCH_ALL_TAIL, all-tail) /* "*A?AA" */, + G_SV (GTK_MATCH_HEAD, head) /* "AAAA*" */, + G_SV (GTK_MATCH_TAIL, tail) /* "*AAAA" */, + G_SV (GTK_MATCH_EXACT, exact) /* "AAAAA" */, + G_SV (GTK_MATCH_LAST, last) +} G_ENUM (GtkMatchType); /* menu factory types (outdated) */ typedef enum { - GTK_MENU_FACTORY_MENU, - GTK_MENU_FACTORY_MENU_BAR, - GTK_MENU_FACTORY_OPTION_MENU -} GtkMenuFactoryType; + G_SV (GTK_MENU_FACTORY_MENU, menu), + G_SV (GTK_MENU_FACTORY_MENU_BAR, menu-bar), + G_SV (GTK_MENU_FACTORY_OPTION_MENU, option-menu) +} G_ENUM (GtkMenuFactoryType); /* gtk metrics */ typedef enum { - GTK_PIXELS, - GTK_INCHES, - GTK_CENTIMETERS -} GtkMetricType; + G_SV (GTK_PIXELS, pixels), + G_SV (GTK_INCHES, inches), + G_SV (GTK_CENTIMETERS, centimeters) +} G_ENUM (GtkMetricType); /* Orientation for toolbars, etc. */ typedef enum { - GTK_ORIENTATION_HORIZONTAL, - GTK_ORIENTATION_VERTICAL -} GtkOrientation; + G_SV (GTK_ORIENTATION_HORIZONTAL, horizontal), + G_SV (GTK_ORIENTATION_VERTICAL, vertical) +} G_ENUM (GtkOrientation); /* Packing types (for boxes) */ typedef enum { - GTK_PACK_START, - GTK_PACK_END -} GtkPackType; + G_SV (GTK_PACK_START, start), + G_SV (GTK_PACK_END, end) +} G_ENUM (GtkPackType); /* priorities for path lookups */ typedef enum { - GTK_PATH_PRIO_LOWEST = 0, - GTK_PATH_PRIO_GTK = 4, - GTK_PATH_PRIO_APPLICATION = 8, - GTK_PATH_PRIO_RC = 12, - GTK_PATH_PRIO_HIGHEST = 15, - GTK_PATH_PRIO_MASK = 0x0f -} GtkPathPriorityType; + G_NV (GTK_PATH_PRIO_LOWEST, lowest, 0), + G_NV (GTK_PATH_PRIO_GTK, gtk, 4), + G_NV (GTK_PATH_PRIO_APPLICATION, application, 8), + G_NV (GTK_PATH_PRIO_RC, rc, 12), + G_NV (GTK_PATH_PRIO_HIGHEST, highest, 15), + G_NV (GTK_PATH_PRIO_MASK, mask, 0x0f) +} G_ENUM (GtkPathPriorityType); /* widget path types */ typedef enum { - GTK_PATH_WIDGET, - GTK_PATH_WIDGET_CLASS, - GTK_PATH_CLASS -} GtkPathType; + G_SV (GTK_PATH_WIDGET, widget), + G_SV (GTK_PATH_WIDGET_CLASS, widget-class), + G_SV (GTK_PATH_CLASS, class) +} G_ENUM (GtkPathType); /* Scrollbar policy types (for scrolled windows) */ typedef enum { - GTK_POLICY_ALWAYS, - GTK_POLICY_AUTOMATIC -} GtkPolicyType; + G_SV (GTK_POLICY_ALWAYS, always), + G_SV (GTK_POLICY_AUTOMATIC, automatic) +} G_ENUM (GtkPolicyType); /* gtk position */ typedef enum { - GTK_POS_LEFT, - GTK_POS_RIGHT, - GTK_POS_TOP, - GTK_POS_BOTTOM -} GtkPositionType; + G_SV (GTK_POS_LEFT, left), + G_SV (GTK_POS_RIGHT, right), + G_SV (GTK_POS_TOP, top), + G_SV (GTK_POS_BOTTOM, bottom) +} G_ENUM (GtkPositionType); /* GtkPreview types */ typedef enum { - GTK_PREVIEW_COLOR, - GTK_PREVIEW_GRAYSCALE -} GtkPreviewType; + G_SV (GTK_PREVIEW_COLOR, color), + G_SV (GTK_PREVIEW_GRAYSCALE, grayscale), + G_NV (GTK_PREVIEW_GREYSCALE, greyscale, GTK_PREVIEW_GRAYSCALE) +} G_ENUM (GtkPreviewType); /* Style for buttons */ typedef enum { - GTK_RELIEF_NORMAL, - GTK_RELIEF_NONE -} GtkReliefStyle; + G_SV (GTK_RELIEF_NORMAL, normal), + G_SV (GTK_RELIEF_NONE, none) +} G_ENUM (GtkReliefStyle); /* scrolling types */ typedef enum { - GTK_SCROLL_NONE, - GTK_SCROLL_STEP_BACKWARD, - GTK_SCROLL_STEP_FORWARD, - GTK_SCROLL_PAGE_BACKWARD, - GTK_SCROLL_PAGE_FORWARD, - GTK_SCROLL_JUMP -} GtkScrollType; + G_SV (GTK_SCROLL_NONE, none), + G_SV (GTK_SCROLL_STEP_BACKWARD, step-backward), + G_SV (GTK_SCROLL_STEP_FORWARD, step-forward), + G_SV (GTK_SCROLL_PAGE_BACKWARD, page-backward), + G_SV (GTK_SCROLL_PAGE_FORWARD, page-forward), + G_SV (GTK_SCROLL_JUMP, jump) +} G_ENUM (GtkScrollType); /* list selection modes */ typedef enum { - GTK_SELECTION_SINGLE, - GTK_SELECTION_BROWSE, - GTK_SELECTION_MULTIPLE, - GTK_SELECTION_EXTENDED -} GtkSelectionMode; + G_SV (GTK_SELECTION_SINGLE, single), + G_SV (GTK_SELECTION_BROWSE, browse), + G_SV (GTK_SELECTION_MULTIPLE, multiple), + G_SV (GTK_SELECTION_EXTENDED, extended) +} G_ENUM (GtkSelectionMode); /* Shadow types */ typedef enum { - GTK_SHADOW_NONE, - GTK_SHADOW_IN, - GTK_SHADOW_OUT, - GTK_SHADOW_ETCHED_IN, - GTK_SHADOW_ETCHED_OUT -} GtkShadowType; + G_SV (GTK_SHADOW_NONE, none), + G_SV (GTK_SHADOW_IN, in), + G_SV (GTK_SHADOW_OUT, out), + G_SV (GTK_SHADOW_ETCHED_IN, etched-in), + G_SV (GTK_SHADOW_ETCHED_OUT, etched-out) +} G_ENUM (GtkShadowType); /* signal run types */ typedef enum { - GTK_RUN_FIRST = 0x1, - GTK_RUN_LAST = 0x2, - GTK_RUN_BOTH = 0x3, - GTK_RUN_MASK = 0xF, - GTK_RUN_NO_RECURSE = 0x10 -} GtkSignalRunType; + G_NV (GTK_RUN_FIRST, first, 0x1), + G_NV (GTK_RUN_LAST, last, 0x2), + G_NV (GTK_RUN_BOTH, both, 0x3), + G_NV (GTK_RUN_MASK, mask, 0xF), + G_NV (GTK_RUN_NO_RECURSE, no-recurse, 0x10) +} G_FLAGS (GtkSignalRunType); /* Widget states */ typedef enum { - GTK_STATE_NORMAL, - GTK_STATE_ACTIVE, - GTK_STATE_PRELIGHT, - GTK_STATE_SELECTED, - GTK_STATE_INSENSITIVE -} GtkStateType; + G_SV (GTK_STATE_NORMAL, normal), + G_SV (GTK_STATE_ACTIVE, active), + G_SV (GTK_STATE_PRELIGHT, prelight), + G_SV (GTK_STATE_SELECTED, selected), + G_SV (GTK_STATE_INSENSITIVE, insensitive) +} G_ENUM (GtkStateType); /* directions for submenus */ typedef enum { - GTK_DIRECTION_LEFT, - GTK_DIRECTION_RIGHT -} GtkSubmenuDirection; + G_SV (GTK_DIRECTION_LEFT, left), + G_SV (GTK_DIRECTION_RIGHT, right) +} G_ENUM (GtkSubmenuDirection); /* placement of submenus */ typedef enum { - GTK_TOP_BOTTOM, - GTK_LEFT_RIGHT -} GtkSubmenuPlacement; + G_SV (GTK_TOP_BOTTOM, top-bottom), + G_SV (GTK_LEFT_RIGHT, left-right) +} G_ENUM (GtkSubmenuPlacement); /* Style for toolbars */ typedef enum { - GTK_TOOLBAR_ICONS, - GTK_TOOLBAR_TEXT, - GTK_TOOLBAR_BOTH -} GtkToolbarStyle; + G_SV (GTK_TOOLBAR_ICONS, icons), + G_SV (GTK_TOOLBAR_TEXT, text), + G_SV (GTK_TOOLBAR_BOTH, both) +} G_ENUM (GtkToolbarStyle); /* trough types for GtkRange */ typedef enum { - GTK_TROUGH_NONE, - GTK_TROUGH_START, - GTK_TROUGH_END, - GTK_TROUGH_JUMP -} GtkTroughType; + G_SV (GTK_TROUGH_NONE, none), + G_SV (GTK_TROUGH_START, start), + G_SV (GTK_TROUGH_END, end), + G_SV (GTK_TROUGH_JUMP, jump) +} G_ENUM (GtkTroughType); /* Data update types (for ranges) */ typedef enum { - GTK_UPDATE_CONTINUOUS, - GTK_UPDATE_DISCONTINUOUS, - GTK_UPDATE_DELAYED -} GtkUpdateType; + G_SV (GTK_UPDATE_CONTINUOUS, continuous), + G_SV (GTK_UPDATE_DISCONTINUOUS, discontinuous), + G_SV (GTK_UPDATE_DELAYED, delayed) +} G_ENUM (GtkUpdateType); /* Generic visibility flags */ typedef enum { - GTK_VISIBILITY_NONE, - GTK_VISIBILITY_PARTIAL, - GTK_VISIBILITY_FULL -} GtkVisibility; + G_SV (GTK_VISIBILITY_NONE, none), + G_SV (GTK_VISIBILITY_PARTIAL, partial), + G_SV (GTK_VISIBILITY_FULL, full) +} G_ENUM (GtkVisibility); /* window position types */ typedef enum { - GTK_WIN_POS_NONE, - GTK_WIN_POS_CENTER, - GTK_WIN_POS_MOUSE -} GtkWindowPosition; + G_SV (GTK_WIN_POS_NONE, none), + G_SV (GTK_WIN_POS_CENTER, center), + G_SV (GTK_WIN_POS_MOUSE, mouse) +} G_ENUM (GtkWindowPosition); /* Window types */ typedef enum { - GTK_WINDOW_TOPLEVEL, - GTK_WINDOW_DIALOG, - GTK_WINDOW_POPUP -} GtkWindowType; + G_SV (GTK_WINDOW_TOPLEVEL, toplevel), + G_SV (GTK_WINDOW_DIALOG, dialog), + G_SV (GTK_WINDOW_POPUP, popup) +} G_ENUM (GtkWindowType); diff --git a/gtk/gtkobject.h b/gtk/gtkobject.h index aea23a9353..8749fb41cf 100644 --- a/gtk/gtkobject.h +++ b/gtk/gtkobject.h @@ -100,12 +100,12 @@ extern "C" { */ typedef enum { - GTK_DESTROYED = 1 << 0, - GTK_FLOATING = 1 << 1, - GTK_CONNECTED = 1 << 2, - GTK_RESERVED_2 = 1 << 3, - GTK_OBJECT_FLAG_LAST = GTK_RESERVED_2 -} GtkObjectFlags; + G_NV (GTK_DESTROYED, destroyed, 1 << 0), + G_NV (GTK_FLOATING, floating, 1 << 1), + G_NV (GTK_CONNECTED, connected, 1 << 2), + GTK_RESERVED_2, + G_NV (GTK_OBJECT_FLAG_LAST, object-flag-last, GTK_RESERVED_2) +} G_FLAGS (GtkObjectFlags); /* Macros for extracting the object_flags from GtkObject. */ @@ -123,14 +123,14 @@ typedef enum */ typedef enum { - GTK_ARG_READABLE = 1 << 0, - GTK_ARG_WRITABLE = 1 << 1, - GTK_ARG_CONSTRUCT = 1 << 2, - GTK_ARG_MASK = 0x03, + G_NV (GTK_ARG_READABLE, readable, 1 << 0), + G_NV (GTK_ARG_WRITABLE, writable, 1 << 1), + G_NV (GTK_ARG_CONSTRUCT, construct, 1 << 2), + G_NV (GTK_ARG_MASK, mask, 0x03), /* aliases */ - GTK_ARG_READWRITE = GTK_ARG_READABLE | GTK_ARG_WRITABLE -} GtkArgFlags; + G_NV (GTK_ARG_READWRITE, readwrite, GTK_ARG_READABLE | GTK_ARG_WRITABLE) +} G_FLAGS (GtkArgFlags); typedef struct _GtkObjectClass GtkObjectClass; diff --git a/gtk/gtkprivate.h b/gtk/gtkprivate.h index 664632bca3..d99274f251 100644 --- a/gtk/gtkprivate.h +++ b/gtk/gtkprivate.h @@ -26,6 +26,7 @@ #ifdef __cplusplus extern "C" { +#pragma } #endif /* __cplusplus */ @@ -34,14 +35,14 @@ extern "C" { */ typedef enum { - PRIVATE_GTK_USER_STYLE = 1 << 0, - PRIVATE_GTK_REDRAW_PENDING = 1 << 1, - PRIVATE_GTK_RESIZE_PENDING = 1 << 2, - PRIVATE_GTK_RESIZE_NEEDED = 1 << 3, - PRIVATE_GTK_LEAVE_PENDING = 1 << 4, - PRIVATE_GTK_HAS_SHAPE_MASK = 1 << 5, - PRIVATE_GTK_IN_REPARENT = 1 << 6 -} GtkPrivateFlags; + G_NV (PRIVATE_GTK_USER_STYLE, user-style, 1 << 0), + G_NV (PRIVATE_GTK_REDRAW_PENDING, redraw-pending, 1 << 1), + G_NV (PRIVATE_GTK_RESIZE_PENDING, resize-pending, 1 << 2), + G_NV (PRIVATE_GTK_RESIZE_NEEDED, resize-needed, 1 << 3), + G_NV (PRIVATE_GTK_LEAVE_PENDING, leave-pending, 1 << 4), + G_NV (PRIVATE_GTK_HAS_SHAPE_MASK, has-shape-mask, 1 << 5), + G_NV (PRIVATE_GTK_IN_REPARENT, in-reparent, 1 << 6) +} G_FLAGS (GtkPrivateFlags); /* Macros for extracting a widgets private_flags from GtkWidget. */ diff --git a/gtk/gtktypebuiltins.h b/gtk/gtktypebuiltins.h index a37e4aaa20..2c5b7db2c7 100644 --- a/gtk/gtktypebuiltins.h +++ b/gtk/gtktypebuiltins.h @@ -1,72 +1,88 @@ /* generated by gentypeinfo from "gtk.defs" */ -#define GTK_TYPE_ACCEL_FLAGS (gtk_type_builtins[0]) -#define GTK_TYPE_ARROW_TYPE (gtk_type_builtins[1]) -#define GTK_TYPE_ATTACH_OPTIONS (gtk_type_builtins[2]) -#define GTK_TYPE_BUTTON_BOX_STYLE (gtk_type_builtins[3]) -#define GTK_TYPE_DIRECTION_TYPE (gtk_type_builtins[4]) -#define GTK_TYPE_JUSTIFICATION (gtk_type_builtins[5]) -#define GTK_TYPE_MATCH_TYPE (gtk_type_builtins[6]) -#define GTK_TYPE_MENU_FACTORY_TYPE (gtk_type_builtins[7]) -#define GTK_TYPE_METRIC_TYPE (gtk_type_builtins[8]) -#define GTK_TYPE_ORIENTATION (gtk_type_builtins[9]) -#define GTK_TYPE_PACK_TYPE (gtk_type_builtins[10]) -#define GTK_TYPE_PATH_PRIORITY_TYPE (gtk_type_builtins[11]) -#define GTK_TYPE_PATH_TYPE (gtk_type_builtins[12]) -#define GTK_TYPE_POLICY_TYPE (gtk_type_builtins[13]) -#define GTK_TYPE_POSITION_TYPE (gtk_type_builtins[14]) -#define GTK_TYPE_PREVIEW_TYPE (gtk_type_builtins[15]) -#define GTK_TYPE_RELIEF_STYLE (gtk_type_builtins[16]) -#define GTK_TYPE_SCROLL_TYPE (gtk_type_builtins[17]) -#define GTK_TYPE_SELECTION_MODE (gtk_type_builtins[18]) -#define GTK_TYPE_SHADOW_TYPE (gtk_type_builtins[19]) -#define GTK_TYPE_SIGNAL_RUN_TYPE (gtk_type_builtins[20]) -#define GTK_TYPE_STATE_TYPE (gtk_type_builtins[21]) -#define GTK_TYPE_SUBMENU_DIRECTION (gtk_type_builtins[22]) -#define GTK_TYPE_SUBMENU_PLACEMENT (gtk_type_builtins[23]) -#define GTK_TYPE_TOOLBAR_STYLE (gtk_type_builtins[24]) -#define GTK_TYPE_TROUGH_TYPE (gtk_type_builtins[25]) -#define GTK_TYPE_UPDATE_TYPE (gtk_type_builtins[26]) -#define GTK_TYPE_VISIBILITY (gtk_type_builtins[27]) -#define GTK_TYPE_WINDOW_POSITION (gtk_type_builtins[28]) -#define GTK_TYPE_WINDOW_TYPE (gtk_type_builtins[29]) -#define GTK_TYPE_OBJECT_FLAGS (gtk_type_builtins[30]) -#define GTK_TYPE_ARG_FLAGS (gtk_type_builtins[31]) -#define GTK_TYPE_WIDGET_FLAGS (gtk_type_builtins[32]) -#define GTK_TYPE_PRIVATE_FLAGS (gtk_type_builtins[33]) -#define GTK_TYPE_CURVE_TYPE (gtk_type_builtins[34]) -#define GTK_TYPE_FUNDAMENTAL_TYPE (gtk_type_builtins[35]) -#define GTK_TYPE_GDK_WINDOW_TYPE (gtk_type_builtins[36]) -#define GTK_TYPE_GDK_WINDOW_CLASS (gtk_type_builtins[37]) -#define GTK_TYPE_GDK_IMAGE_TYPE (gtk_type_builtins[38]) -#define GTK_TYPE_GDK_VISUAL_TYPE (gtk_type_builtins[39]) -#define GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE (gtk_type_builtins[40]) -#define GTK_TYPE_GDK_WINDOW_HINTS (gtk_type_builtins[41]) -#define GTK_TYPE_GDK_FUNCTION (gtk_type_builtins[42]) -#define GTK_TYPE_GDK_FILL (gtk_type_builtins[43]) -#define GTK_TYPE_GDK_LINE_STYLE (gtk_type_builtins[44]) -#define GTK_TYPE_GDK_CAP_STYLE (gtk_type_builtins[45]) -#define GTK_TYPE_GDK_JOIN_STYLE (gtk_type_builtins[46]) -#define GTK_TYPE_GDK_CURSOR_TYPE (gtk_type_builtins[47]) -#define GTK_TYPE_GDK_EVENT_TYPE (gtk_type_builtins[48]) -#define GTK_TYPE_GDK_EVENT_MASK (gtk_type_builtins[49]) -#define GTK_TYPE_GDK_NOTIFY_TYPE (gtk_type_builtins[50]) -#define GTK_TYPE_GDK_CROSSING_MODE (gtk_type_builtins[51]) -#define GTK_TYPE_GDK_MODIFIER_TYPE (gtk_type_builtins[52]) -#define GTK_TYPE_GDK_SUBWINDOW_MODE (gtk_type_builtins[53]) -#define GTK_TYPE_GDK_INPUT_CONDITION (gtk_type_builtins[54]) -#define GTK_TYPE_GDK_STATUS (gtk_type_builtins[55]) -#define GTK_TYPE_GDK_BYTE_ORDER (gtk_type_builtins[56]) -#define GTK_TYPE_GDK_GCVALUES_MASK (gtk_type_builtins[57]) -#define GTK_TYPE_GDK_SELECTION (gtk_type_builtins[58]) -#define GTK_TYPE_GDK_PROPERTY_STATE (gtk_type_builtins[59]) -#define GTK_TYPE_GDK_PROP_MODE (gtk_type_builtins[60]) -#define GTK_TYPE_ACCEL_GROUP (gtk_type_builtins[61]) -#define GTK_TYPE_STYLE (gtk_type_builtins[62]) -#define GTK_TYPE_GDK_COLORMAP (gtk_type_builtins[63]) -#define GTK_TYPE_GDK_VISUAL (gtk_type_builtins[64]) -#define GTK_TYPE_GDK_FONT (gtk_type_builtins[65]) -#define GTK_TYPE_GDK_WINDOW (gtk_type_builtins[66]) -#define GTK_TYPE_GDK_EVENT (gtk_type_builtins[67]) -#define GTK_TYPE_GDK_COLOR (gtk_type_builtins[68]) -#define GTK_TYPE_NUM_BUILTINS 69 +#define GTK_TYPE_GDK_WINDOW_TYPE (gtk_type_builtins[0]) +#define GTK_TYPE_GDK_WINDOW_CLASS (gtk_type_builtins[1]) +#define GTK_TYPE_GDK_IMAGE_TYPE (gtk_type_builtins[2]) +#define GTK_TYPE_GDK_VISUAL_TYPE (gtk_type_builtins[3]) +#define GTK_TYPE_GDK_FONT_TYPE (gtk_type_builtins[4]) +#define GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE (gtk_type_builtins[5]) +#define GTK_TYPE_GDK_WINDOW_HINTS (gtk_type_builtins[6]) +#define GTK_TYPE_GDK_FUNCTION (gtk_type_builtins[7]) +#define GTK_TYPE_GDK_FILL (gtk_type_builtins[8]) +#define GTK_TYPE_GDK_FILL_RULE (gtk_type_builtins[9]) +#define GTK_TYPE_GDK_LINE_STYLE (gtk_type_builtins[10]) +#define GTK_TYPE_GDK_CAP_STYLE (gtk_type_builtins[11]) +#define GTK_TYPE_GDK_JOIN_STYLE (gtk_type_builtins[12]) +#define GTK_TYPE_GDK_FILTER_RETURN (gtk_type_builtins[13]) +#define GTK_TYPE_GDK_VISIBILITY_STATE (gtk_type_builtins[14]) +#define GTK_TYPE_GDK_EVENT_TYPE (gtk_type_builtins[15]) +#define GTK_TYPE_GDK_EVENT_MASK (gtk_type_builtins[16]) +#define GTK_TYPE_GDK_NOTIFY_TYPE (gtk_type_builtins[17]) +#define GTK_TYPE_GDK_CROSSING_MODE (gtk_type_builtins[18]) +#define GTK_TYPE_GDK_MODIFIER_TYPE (gtk_type_builtins[19]) +#define GTK_TYPE_GDK_SUBWINDOW_MODE (gtk_type_builtins[20]) +#define GTK_TYPE_GDK_INPUT_CONDITION (gtk_type_builtins[21]) +#define GTK_TYPE_GDK_STATUS (gtk_type_builtins[22]) +#define GTK_TYPE_GDK_BYTE_ORDER (gtk_type_builtins[23]) +#define GTK_TYPE_GDK_GCVALUES_MASK (gtk_type_builtins[24]) +#define GTK_TYPE_GDK_SELECTION (gtk_type_builtins[25]) +#define GTK_TYPE_GDK_PROPERTY_STATE (gtk_type_builtins[26]) +#define GTK_TYPE_GDK_PROP_MODE (gtk_type_builtins[27]) +#define GTK_TYPE_GDK_DND_TYPE (gtk_type_builtins[28]) +#define GTK_TYPE_GDK_INPUT_SOURCE (gtk_type_builtins[29]) +#define GTK_TYPE_GDK_INPUT_MODE (gtk_type_builtins[30]) +#define GTK_TYPE_GDK_AXIS_USE (gtk_type_builtins[31]) +#define GTK_TYPE_GDK_TARGET (gtk_type_builtins[32]) +#define GTK_TYPE_GDK_SELECTION_TYPE (gtk_type_builtins[33]) +#define GTK_TYPE_GDK_EXTENSION_MODE (gtk_type_builtins[34]) +#define GTK_TYPE_GDK_WMDECORATION (gtk_type_builtins[35]) +#define GTK_TYPE_GDK_WMFUNCTION (gtk_type_builtins[36]) +#define GTK_TYPE_GDK_COLOR_CONTEXT_MODE (gtk_type_builtins[37]) +#define GTK_TYPE_GDK_OVERLAP_TYPE (gtk_type_builtins[38]) +#define GTK_TYPE_ACCEL_FLAGS (gtk_type_builtins[39]) +#define GTK_TYPE_ARROW_TYPE (gtk_type_builtins[40]) +#define GTK_TYPE_ATTACH_OPTIONS (gtk_type_builtins[41]) +#define GTK_TYPE_BUTTON_BOX_STYLE (gtk_type_builtins[42]) +#define GTK_TYPE_CURVE_TYPE (gtk_type_builtins[43]) +#define GTK_TYPE_DIRECTION_TYPE (gtk_type_builtins[44]) +#define GTK_TYPE_JUSTIFICATION (gtk_type_builtins[45]) +#define GTK_TYPE_MATCH_TYPE (gtk_type_builtins[46]) +#define GTK_TYPE_MENU_FACTORY_TYPE (gtk_type_builtins[47]) +#define GTK_TYPE_METRIC_TYPE (gtk_type_builtins[48]) +#define GTK_TYPE_ORIENTATION (gtk_type_builtins[49]) +#define GTK_TYPE_PACK_TYPE (gtk_type_builtins[50]) +#define GTK_TYPE_PATH_PRIORITY_TYPE (gtk_type_builtins[51]) +#define GTK_TYPE_PATH_TYPE (gtk_type_builtins[52]) +#define GTK_TYPE_POLICY_TYPE (gtk_type_builtins[53]) +#define GTK_TYPE_POSITION_TYPE (gtk_type_builtins[54]) +#define GTK_TYPE_PREVIEW_TYPE (gtk_type_builtins[55]) +#define GTK_TYPE_RELIEF_STYLE (gtk_type_builtins[56]) +#define GTK_TYPE_SCROLL_TYPE (gtk_type_builtins[57]) +#define GTK_TYPE_SELECTION_MODE (gtk_type_builtins[58]) +#define GTK_TYPE_SHADOW_TYPE (gtk_type_builtins[59]) +#define GTK_TYPE_SIGNAL_RUN_TYPE (gtk_type_builtins[60]) +#define GTK_TYPE_STATE_TYPE (gtk_type_builtins[61]) +#define GTK_TYPE_SUBMENU_DIRECTION (gtk_type_builtins[62]) +#define GTK_TYPE_SUBMENU_PLACEMENT (gtk_type_builtins[63]) +#define GTK_TYPE_TOOLBAR_STYLE (gtk_type_builtins[64]) +#define GTK_TYPE_TROUGH_TYPE (gtk_type_builtins[65]) +#define GTK_TYPE_UPDATE_TYPE (gtk_type_builtins[66]) +#define GTK_TYPE_VISIBILITY (gtk_type_builtins[67]) +#define GTK_TYPE_WINDOW_POSITION (gtk_type_builtins[68]) +#define GTK_TYPE_WINDOW_TYPE (gtk_type_builtins[69]) +#define GTK_TYPE_FUNDAMENTAL_TYPE (gtk_type_builtins[70]) +#define GTK_TYPE_DEBUG_FLAG (gtk_type_builtins[71]) +#define GTK_TYPE_OBJECT_FLAGS (gtk_type_builtins[72]) +#define GTK_TYPE_ARG_FLAGS (gtk_type_builtins[73]) +#define GTK_TYPE_WIDGET_FLAGS (gtk_type_builtins[74]) +#define GTK_TYPE_PRIVATE_FLAGS (gtk_type_builtins[75]) +#define GTK_TYPE_GDK_DEBUG_FLAG (gtk_type_builtins[76]) +#define GTK_TYPE_ACCEL_GROUP (gtk_type_builtins[77]) +#define GTK_TYPE_STYLE (gtk_type_builtins[78]) +#define GTK_TYPE_GDK_COLORMAP (gtk_type_builtins[79]) +#define GTK_TYPE_GDK_VISUAL (gtk_type_builtins[80]) +#define GTK_TYPE_GDK_FONT (gtk_type_builtins[81]) +#define GTK_TYPE_GDK_WINDOW (gtk_type_builtins[82]) +#define GTK_TYPE_GDK_EVENT (gtk_type_builtins[83]) +#define GTK_TYPE_GDK_COLOR (gtk_type_builtins[84]) +#define GTK_TYPE_NUM_BUILTINS 85 diff --git a/gtk/gtkenumvalues.c b/gtk/gtktypebuiltins1.c similarity index 78% rename from gtk/gtkenumvalues.c rename to gtk/gtktypebuiltins1.c index bfe015c2b3..a432f8b3d0 100644 --- a/gtk/gtkenumvalues.c +++ b/gtk/gtktypebuiltins1.c @@ -1,276 +1,5 @@ -/* generated by makeenums.awk from "./gtk.defs" */ +/* generated by makeenums.awk */ -static GtkEnumValue enum_values_GtkAccelFlags[] = { - { GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" }, - { GTK_ACCEL_SIGNAL_VISIBLE, "GTK_ACCEL_SIGNAL_VISIBLE", "signal-visible" }, - { GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" }, - { GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkArrowType[] = { - { GTK_ARROW_UP, "GTK_ARROW_UP", "up" }, - { GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" }, - { GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" }, - { GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkAttachOptions[] = { - { GTK_EXPAND, "GTK_EXPAND", "expand" }, - { GTK_SHRINK, "GTK_SHRINK", "shrink" }, - { GTK_FILL, "GTK_FILL", "fill" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkButtonBoxStyle[] = { - { GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default" }, - { GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" }, - { GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" }, - { GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" }, - { GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkDirectionType[] = { - { GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" }, - { GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" }, - { GTK_DIR_UP, "GTK_DIR_UP", "up" }, - { GTK_DIR_DOWN, "GTK_DIR_DOWN", "down" }, - { GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" }, - { GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkJustification[] = { - { GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" }, - { GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" }, - { GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" }, - { GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkMatchType[] = { - { GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" }, - { GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" }, - { GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" }, - { GTK_MATCH_TAIL, "GTK_MATCH_TAIL", "tail" }, - { GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" }, - { GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkMenuFactoryType[] = { - { GTK_MENU_FACTORY_MENU, "GTK_MENU_FACTORY_MENU", "menu" }, - { GTK_MENU_FACTORY_MENU_BAR, "GTK_MENU_FACTORY_MENU_BAR", "menu-bar" }, - { GTK_MENU_FACTORY_OPTION_MENU, "GTK_MENU_FACTORY_OPTION_MENU", "option-menu" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkMetricType[] = { - { GTK_PIXELS, "GTK_PIXELS", "pixels" }, - { GTK_INCHES, "GTK_INCHES", "inches" }, - { GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkOrientation[] = { - { GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" }, - { GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPackType[] = { - { GTK_PACK_START, "GTK_PACK_START", "start" }, - { GTK_PACK_END, "GTK_PACK_END", "end" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPathPriorityType[] = { - { GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" }, - { GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" }, - { GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" }, - { GTK_PATH_PRIO_RC, "GTK_PATH_PRIO_RC", "rc" }, - { GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" }, - { GTK_PATH_PRIO_MASK, "GTK_PATH_PRIO_MASK", "mask" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPathType[] = { - { GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" }, - { GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" }, - { GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPolicyType[] = { - { GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" }, - { GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPositionType[] = { - { GTK_POS_LEFT, "GTK_POS_LEFT", "left" }, - { GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" }, - { GTK_POS_TOP, "GTK_POS_TOP", "top" }, - { GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPreviewType[] = { - { GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" }, - { GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkReliefStyle[] = { - { GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" }, - { GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkScrollType[] = { - { GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" }, - { GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" }, - { GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" }, - { GTK_SCROLL_PAGE_BACKWARD, "GTK_SCROLL_PAGE_BACKWARD", "page-backward" }, - { GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" }, - { GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkSelectionMode[] = { - { GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" }, - { GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" }, - { GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" }, - { GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkShadowType[] = { - { GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" }, - { GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" }, - { GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" }, - { GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" }, - { GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkSignalRunType[] = { - { GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" }, - { GTK_RUN_LAST, "GTK_RUN_LAST", "last" }, - { GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" }, - { GTK_RUN_MASK, "GTK_RUN_MASK", "mask" }, - { GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkStateType[] = { - { GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" }, - { GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" }, - { GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" }, - { GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" }, - { GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkSubmenuDirection[] = { - { GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" }, - { GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkSubmenuPlacement[] = { - { GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" }, - { GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkToolbarStyle[] = { - { GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" }, - { GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" }, - { GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkTroughType[] = { - { GTK_TROUGH_NONE, "GTK_TROUGH_NONE", "none" }, - { GTK_TROUGH_START, "GTK_TROUGH_START", "start" }, - { GTK_TROUGH_END, "GTK_TROUGH_END", "end" }, - { GTK_TROUGH_JUMP, "GTK_TROUGH_JUMP", "jump" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkUpdateType[] = { - { GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" }, - { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" }, - { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkVisibility[] = { - { GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" }, - { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" }, - { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkWindowPosition[] = { - { GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" }, - { GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" }, - { GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkWindowType[] = { - { GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" }, - { GTK_WINDOW_DIALOG, "GTK_WINDOW_DIALOG", "dialog" }, - { GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkObjectFlags[] = { - { GTK_DESTROYED, "GTK_DESTROYED", "destroyed" }, - { GTK_FLOATING, "GTK_FLOATING", "floating" }, - { GTK_CONNECTED, "GTK_CONNECTED", "connected" }, - { GTK_OBJECT_FLAG_LAST, "GTK_OBJECT_FLAG_LAST", "object-flag-last" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkArgFlags[] = { - { GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" }, - { GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" }, - { GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" }, - { GTK_ARG_MASK, "GTK_ARG_MASK", "mask" }, - { GTK_ARG_READWRITE, "GTK_ARG_READWRITE", "readwrite" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkWidgetFlags[] = { - { GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" }, - { GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" }, - { GTK_REALIZED, "GTK_REALIZED", "realized" }, - { GTK_MAPPED, "GTK_MAPPED", "mapped" }, - { GTK_VISIBLE, "GTK_VISIBLE", "visible" }, - { GTK_SENSITIVE, "GTK_SENSITIVE", "sensitive" }, - { GTK_PARENT_SENSITIVE, "GTK_PARENT_SENSITIVE", "parent-sensitive" }, - { GTK_CAN_FOCUS, "GTK_CAN_FOCUS", "can-focus" }, - { GTK_HAS_FOCUS, "GTK_HAS_FOCUS", "has-focus" }, - { GTK_CAN_DEFAULT, "GTK_CAN_DEFAULT", "can-default" }, - { GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" }, - { GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" }, - { GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" }, - { GTK_BASIC, "GTK_BASIC", "basic" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkPrivateFlags[] = { - { PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" }, - { PRIVATE_GTK_REDRAW_PENDING, "PRIVATE_GTK_REDRAW_PENDING", "redraw-pending" }, - { PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" }, - { PRIVATE_GTK_RESIZE_NEEDED, "PRIVATE_GTK_RESIZE_NEEDED", "resize-needed" }, - { PRIVATE_GTK_LEAVE_PENDING, "PRIVATE_GTK_LEAVE_PENDING", "leave-pending" }, - { PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" }, - { PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkCurveType[] = { - { GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" }, - { GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" }, - { GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" }, - { 0, NULL, NULL }, -}; -static GtkEnumValue enum_values_GtkFundamentalType[] = { - { GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" }, - { GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" }, - { GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" }, - { GTK_TYPE_BOOL, "GTK_TYPE_BOOL", "bool" }, - { GTK_TYPE_INT, "GTK_TYPE_INT", "int" }, - { GTK_TYPE_UINT, "GTK_TYPE_UINT", "uint" }, - { GTK_TYPE_LONG, "GTK_TYPE_LONG", "long" }, - { GTK_TYPE_ULONG, "GTK_TYPE_ULONG", "ulong" }, - { GTK_TYPE_FLOAT, "GTK_TYPE_FLOAT", "float" }, - { GTK_TYPE_DOUBLE, "GTK_TYPE_DOUBLE", "double" }, - { GTK_TYPE_STRING, "GTK_TYPE_STRING", "string" }, - { GTK_TYPE_ENUM, "GTK_TYPE_ENUM", "enum" }, - { GTK_TYPE_FLAGS, "GTK_TYPE_FLAGS", "flags" }, - { GTK_TYPE_BOXED, "GTK_TYPE_BOXED", "boxed" }, - { GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" }, - { GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" }, - { GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" }, - { GTK_TYPE_POINTER, "GTK_TYPE_POINTER", "pointer" }, - { GTK_TYPE_SIGNAL, "GTK_TYPE_SIGNAL", "signal" }, - { GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" }, - { GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" }, - { 0, NULL, NULL }, -}; static GtkEnumValue enum_values_GdkWindowType[] = { { GDK_WINDOW_ROOT, "GDK_WINDOW_ROOT", "root" }, { GDK_WINDOW_TOPLEVEL, "GDK_WINDOW_TOPLEVEL", "toplevel" }, @@ -278,18 +7,16 @@ static GtkEnumValue enum_values_GdkWindowType[] = { { GDK_WINDOW_DIALOG, "GDK_WINDOW_DIALOG", "dialog" }, { GDK_WINDOW_TEMP, "GDK_WINDOW_TEMP", "temp" }, { GDK_WINDOW_PIXMAP, "GDK_WINDOW_PIXMAP", "pixmap" }, - { 0, NULL, NULL }, + { GDK_WINDOW_FOREIGN, "GDK_WINDOW_FOREIGN", "foreign" }, }; static GtkEnumValue enum_values_GdkWindowClass[] = { { GDK_INPUT_OUTPUT, "GDK_INPUT_OUTPUT", "input-output" }, { GDK_INPUT_ONLY, "GDK_INPUT_ONLY", "input-only" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkImageType[] = { { GDK_IMAGE_NORMAL, "GDK_IMAGE_NORMAL", "normal" }, { GDK_IMAGE_SHARED, "GDK_IMAGE_SHARED", "shared" }, { GDK_IMAGE_FASTEST, "GDK_IMAGE_FASTEST", "fastest" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkVisualType[] = { { GDK_VISUAL_STATIC_GRAY, "GDK_VISUAL_STATIC_GRAY", "static-gray" }, @@ -298,7 +25,10 @@ static GtkEnumValue enum_values_GdkVisualType[] = { { GDK_VISUAL_PSEUDO_COLOR, "GDK_VISUAL_PSEUDO_COLOR", "pseudo-color" }, { GDK_VISUAL_TRUE_COLOR, "GDK_VISUAL_TRUE_COLOR", "true-color" }, { GDK_VISUAL_DIRECT_COLOR, "GDK_VISUAL_DIRECT_COLOR", "direct-color" }, - { 0, NULL, NULL }, +}; +static GtkEnumValue enum_values_GdkFontType[] = { + { GDK_FONT_FONT, "GDK_FONT_FONT", "font" }, + { GDK_FONT_FONTSET, "GDK_FONT_FONTSET", "fontset" }, }; static GtkEnumValue enum_values_GdkWindowAttributesType[] = { { GDK_WA_TITLE, "GDK_WA_TITLE", "title" }, @@ -307,49 +37,54 @@ static GtkEnumValue enum_values_GdkWindowAttributesType[] = { { GDK_WA_CURSOR, "GDK_WA_CURSOR", "cursor" }, { GDK_WA_COLORMAP, "GDK_WA_COLORMAP", "colormap" }, { GDK_WA_VISUAL, "GDK_WA_VISUAL", "visual" }, - { 0, NULL, NULL }, + { GDK_WA_WMCLASS, "GDK_WA_WMCLASS", "wmclass" }, + { GDK_WA_NOREDIR, "GDK_WA_NOREDIR", "noredir" }, }; static GtkEnumValue enum_values_GdkWindowHints[] = { { GDK_HINT_POS, "GDK_HINT_POS", "pos" }, { GDK_HINT_MIN_SIZE, "GDK_HINT_MIN_SIZE", "min-size" }, { GDK_HINT_MAX_SIZE, "GDK_HINT_MAX_SIZE", "max-size" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkFunction[] = { { GDK_COPY, "GDK_COPY", "copy" }, { GDK_INVERT, "GDK_INVERT", "invert" }, { GDK_XOR, "GDK_XOR", "xor" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkFill[] = { { GDK_SOLID, "GDK_SOLID", "solid" }, { GDK_TILED, "GDK_TILED", "tiled" }, { GDK_STIPPLED, "GDK_STIPPLED", "stippled" }, { GDK_OPAQUE_STIPPLED, "GDK_OPAQUE_STIPPLED", "opaque-stippled" }, - { 0, NULL, NULL }, +}; +static GtkEnumValue enum_values_GdkFillRule[] = { + { GDK_EVEN_ODD_RULE, "GDK_EVEN_ODD_RULE", "even-odd-rule" }, + { GDK_WINDING_RULE, "GDK_WINDING_RULE", "winding-rule" }, }; static GtkEnumValue enum_values_GdkLineStyle[] = { { GDK_LINE_SOLID, "GDK_LINE_SOLID", "solid" }, { GDK_LINE_ON_OFF_DASH, "GDK_LINE_ON_OFF_DASH", "on-off-dash" }, { GDK_LINE_DOUBLE_DASH, "GDK_LINE_DOUBLE_DASH", "double-dash" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkCapStyle[] = { { GDK_CAP_NOT_LAST, "GDK_CAP_NOT_LAST", "not-last" }, { GDK_CAP_BUTT, "GDK_CAP_BUTT", "butt" }, { GDK_CAP_ROUND, "GDK_CAP_ROUND", "round" }, { GDK_CAP_PROJECTING, "GDK_CAP_PROJECTING", "projecting" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkJoinStyle[] = { { GDK_JOIN_MITER, "GDK_JOIN_MITER", "miter" }, { GDK_JOIN_ROUND, "GDK_JOIN_ROUND", "round" }, { GDK_JOIN_BEVEL, "GDK_JOIN_BEVEL", "bevel" }, - { 0, NULL, NULL }, }; -static GtkEnumValue enum_values_GdkCursorType[] = { - { GDK_LAST_CURSOR, "GDK_LAST_CURSOR", "cursor" }, - { 0, NULL, NULL }, +static GtkEnumValue enum_values_GdkFilterReturn[] = { + { GDK_FILTER_CONTINUE, "GDK_FILTER_CONTINUE", "continue" }, + { GDK_FILTER_TRANSLATE, "GDK_FILTER_TRANSLATE", "translate" }, + { GDK_FILTER_REMOVE, "GDK_FILTER_REMOVE", "remove" }, +}; +static GtkEnumValue enum_values_GdkVisibilityState[] = { + { GDK_VISIBILITY_UNOBSCURED, "GDK_VISIBILITY_UNOBSCURED", "unobscured" }, + { GDK_VISIBILITY_PARTIAL, "GDK_VISIBILITY_PARTIAL", "partial" }, + { GDK_VISIBILITY_FULLY_OBSCURED, "GDK_VISIBILITY_FULLY_OBSCURED", "fully-obscured" }, }; static GtkEnumValue enum_values_GdkEventType[] = { { GDK_NOTHING, "GDK_NOTHING", "nothing" }, @@ -384,7 +119,6 @@ static GtkEnumValue enum_values_GdkEventType[] = { { GDK_VISIBILITY_NOTIFY, "GDK_VISIBILITY_NOTIFY", "visibility-notify" }, { GDK_NO_EXPOSE, "GDK_NO_EXPOSE", "no-expose" }, { GDK_OTHER_EVENT, "GDK_OTHER_EVENT", "other-event" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkEventMask[] = { { GDK_EXPOSURE_MASK, "GDK_EXPOSURE_MASK", "exposure-mask" }, @@ -408,7 +142,6 @@ static GtkEnumValue enum_values_GdkEventMask[] = { { GDK_PROXIMITY_OUT_MASK, "GDK_PROXIMITY_OUT_MASK", "proximity-out-mask" }, { GDK_SUBSTRUCTURE_MASK, "GDK_SUBSTRUCTURE_MASK", "substructure-mask" }, { GDK_ALL_EVENTS_MASK, "GDK_ALL_EVENTS_MASK", "all-events-mask" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkNotifyType[] = { { GDK_NOTIFY_ANCESTOR, "GDK_NOTIFY_ANCESTOR", "ancestor" }, @@ -417,13 +150,11 @@ static GtkEnumValue enum_values_GdkNotifyType[] = { { GDK_NOTIFY_NONLINEAR, "GDK_NOTIFY_NONLINEAR", "nonlinear" }, { GDK_NOTIFY_NONLINEAR_VIRTUAL, "GDK_NOTIFY_NONLINEAR_VIRTUAL", "nonlinear-virtual" }, { GDK_NOTIFY_UNKNOWN, "GDK_NOTIFY_UNKNOWN", "unknown" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkCrossingMode[] = { { GDK_CROSSING_NORMAL, "GDK_CROSSING_NORMAL", "crossing-normal" }, { GDK_CROSSING_GRAB, "GDK_CROSSING_GRAB", "crossing-grab" }, { GDK_CROSSING_UNGRAB, "GDK_CROSSING_UNGRAB", "crossing-ungrab" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkModifierType[] = { { GDK_SHIFT_MASK, "GDK_SHIFT_MASK", "shift-mask" }, @@ -441,18 +172,15 @@ static GtkEnumValue enum_values_GdkModifierType[] = { { GDK_BUTTON5_MASK, "GDK_BUTTON5_MASK", "button5-mask" }, { GDK_AFTER_MASK, "GDK_AFTER_MASK", "after-mask" }, { GDK_MODIFIER_MASK, "GDK_MODIFIER_MASK", "modifier-mask" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkSubwindowMode[] = { { GDK_CLIP_BY_CHILDREN, "GDK_CLIP_BY_CHILDREN", "clip-by-children" }, { GDK_INCLUDE_INFERIORS, "GDK_INCLUDE_INFERIORS", "include-inferiors" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkInputCondition[] = { { GDK_INPUT_READ, "GDK_INPUT_READ", "read" }, { GDK_INPUT_WRITE, "GDK_INPUT_WRITE", "write" }, { GDK_INPUT_EXCEPTION, "GDK_INPUT_EXCEPTION", "exception" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkStatus[] = { { GDK_OK, "GDK_OK", "ok" }, @@ -460,12 +188,10 @@ static GtkEnumValue enum_values_GdkStatus[] = { { GDK_ERROR_PARAM, "GDK_ERROR_PARAM", "error-param" }, { GDK_ERROR_FILE, "GDK_ERROR_FILE", "error-file" }, { GDK_ERROR_MEM, "GDK_ERROR_MEM", "error-mem" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkByteOrder[] = { { GDK_LSB_FIRST, "GDK_LSB_FIRST", "lsb-first" }, { GDK_MSB_FIRST, "GDK_MSB_FIRST", "msb-first" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkGCValuesMask[] = { { GDK_GC_FOREGROUND, "GDK_GC_FOREGROUND", "foreground" }, @@ -486,21 +212,352 @@ static GtkEnumValue enum_values_GdkGCValuesMask[] = { { GDK_GC_LINE_STYLE, "GDK_GC_LINE_STYLE", "line-style" }, { GDK_GC_CAP_STYLE, "GDK_GC_CAP_STYLE", "cap-style" }, { GDK_GC_JOIN_STYLE, "GDK_GC_JOIN_STYLE", "join-style" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkSelection[] = { { GDK_SELECTION_PRIMARY, "GDK_SELECTION_PRIMARY", "primary" }, { GDK_SELECTION_SECONDARY, "GDK_SELECTION_SECONDARY", "secondary" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkPropertyState[] = { { GDK_PROPERTY_NEW_VALUE, "GDK_PROPERTY_NEW_VALUE", "new-value" }, { GDK_PROPERTY_DELETE, "GDK_PROPERTY_DELETE", "delete" }, - { 0, NULL, NULL }, }; static GtkEnumValue enum_values_GdkPropMode[] = { { GDK_PROP_MODE_REPLACE, "GDK_PROP_MODE_REPLACE", "replace" }, { GDK_PROP_MODE_PREPEND, "GDK_PROP_MODE_PREPEND", "prepend" }, { GDK_PROP_MODE_APPEND, "GDK_PROP_MODE_APPEND", "append" }, - { 0, NULL, NULL }, }; +static GtkEnumValue enum_values_GdkDndType[] = { + { GDK_DNDTYPE_NOTDND, "GDK_DNDTYPE_NOTDND", "notdnd" }, + { GDK_DNDTYPE_UNKNOWN, "GDK_DNDTYPE_UNKNOWN", "unknown" }, + { GDK_DNDTYPE_RAWDATA, "GDK_DNDTYPE_RAWDATA", "rawdata" }, + { GDK_DNDTYPE_FILE, "GDK_DNDTYPE_FILE", "file" }, + { GDK_DNDTYPE_FILES, "GDK_DNDTYPE_FILES", "files" }, + { GDK_DNDTYPE_TEXT, "GDK_DNDTYPE_TEXT", "text" }, + { GDK_DNDTYPE_DIR, "GDK_DNDTYPE_DIR", "dir" }, + { GDK_DNDTYPE_LINK, "GDK_DNDTYPE_LINK", "link" }, + { GDK_DNDTYPE_EXE, "GDK_DNDTYPE_EXE", "exe" }, + { GDK_DNDTYPE_URL, "GDK_DNDTYPE_URL", "url" }, + { GDK_DNDTYPE_MIME, "GDK_DNDTYPE_MIME", "mime" }, + { GDK_DNDTYPE_END, "GDK_DNDTYPE_END", "end" }, +}; +static GtkEnumValue enum_values_GdkInputSource[] = { + { GDK_SOURCE_MOUSE, "GDK_SOURCE_MOUSE", "mouse" }, + { GDK_SOURCE_PEN, "GDK_SOURCE_PEN", "pen" }, + { GDK_SOURCE_ERASER, "GDK_SOURCE_ERASER", "eraser" }, + { GDK_SOURCE_CURSOR, "GDK_SOURCE_CURSOR", "cursor" }, +}; +static GtkEnumValue enum_values_GdkInputMode[] = { + { GDK_MODE_DISABLED, "GDK_MODE_DISABLED", "disabled" }, + { GDK_MODE_SCREEN, "GDK_MODE_SCREEN", "screen" }, + { GDK_MODE_WINDOW, "GDK_MODE_WINDOW", "window" }, +}; +static GtkEnumValue enum_values_GdkAxisUse[] = { + { GDK_AXIS_IGNORE, "GDK_AXIS_IGNORE", "ignore" }, + { GDK_AXIS_X, "GDK_AXIS_X", "x" }, + { GDK_AXIS_Y, "GDK_AXIS_Y", "y" }, + { GDK_AXIS_PRESSURE, "GDK_AXIS_PRESSURE", "pressure" }, + { GDK_AXIS_XTILT, "GDK_AXIS_XTILT", "xtilt" }, + { GDK_AXIS_YTILT, "GDK_AXIS_YTILT", "ytilt" }, + { GDK_AXIS_LAST, "GDK_AXIS_LAST", "last" }, +}; +static GtkEnumValue enum_values_GdkTarget[] = { + { GDK_TARGET_BITMAP, "GDK_TARGET_BITMAP", "bitmap" }, + { GDK_TARGET_COLORMAP, "GDK_TARGET_COLORMAP", "colormap" }, + { GDK_TARGET_DRAWABLE, "GDK_TARGET_DRAWABLE", "drawable" }, + { GDK_TARGET_PIXMAP, "GDK_TARGET_PIXMAP", "pixmap" }, + { GDK_TARGET_STRING, "GDK_TARGET_STRING", "string" }, +}; +static GtkEnumValue enum_values_GdkSelectionType[] = { + { GDK_SELECTION_TYPE_ATOM, "GDK_SELECTION_TYPE_ATOM", "atom" }, + { GDK_SELECTION_TYPE_BITMAP, "GDK_SELECTION_TYPE_BITMAP", "bitmap" }, + { GDK_SELECTION_TYPE_COLORMAP, "GDK_SELECTION_TYPE_COLORMAP", "colormap" }, + { GDK_SELECTION_TYPE_DRAWABLE, "GDK_SELECTION_TYPE_DRAWABLE", "drawable" }, + { GDK_SELECTION_TYPE_INTEGER, "GDK_SELECTION_TYPE_INTEGER", "integer" }, + { GDK_SELECTION_TYPE_PIXMAP, "GDK_SELECTION_TYPE_PIXMAP", "pixmap" }, + { GDK_SELECTION_TYPE_WINDOW, "GDK_SELECTION_TYPE_WINDOW", "window" }, + { GDK_SELECTION_TYPE_STRING, "GDK_SELECTION_TYPE_STRING", "string" }, +}; +static GtkEnumValue enum_values_GdkExtensionMode[] = { + { GDK_EXTENSION_EVENTS_NONE, "GDK_EXTENSION_EVENTS_NONE", "none" }, + { GDK_EXTENSION_EVENTS_ALL, "GDK_EXTENSION_EVENTS_ALL", "all" }, + { GDK_EXTENSION_EVENTS_CURSOR, "GDK_EXTENSION_EVENTS_CURSOR", "cursor" }, +}; +static GtkEnumValue enum_values_GdkWMDecoration[] = { + { GDK_DECOR_ALL, "GDK_DECOR_ALL", "all" }, + { GDK_DECOR_BORDER, "GDK_DECOR_BORDER", "border" }, + { GDK_DECOR_RESIZEH, "GDK_DECOR_RESIZEH", "resizeh" }, + { GDK_DECOR_TITLE, "GDK_DECOR_TITLE", "title" }, + { GDK_DECOR_MENU, "GDK_DECOR_MENU", "menu" }, + { GDK_DECOR_MINIMIZE, "GDK_DECOR_MINIMIZE", "minimize" }, + { GDK_DECOR_MAXIMIZE, "GDK_DECOR_MAXIMIZE", "maximize" }, +}; +static GtkEnumValue enum_values_GdkWMFunction[] = { + { GDK_FUNC_ALL, "GDK_FUNC_ALL", "all" }, + { GDK_FUNC_RESIZE, "GDK_FUNC_RESIZE", "resize" }, + { GDK_FUNC_MOVE, "GDK_FUNC_MOVE", "move" }, + { GDK_FUNC_MINIMIZE, "GDK_FUNC_MINIMIZE", "minimize" }, + { GDK_FUNC_MAXIMIZE, "GDK_FUNC_MAXIMIZE", "maximize" }, + { GDK_FUNC_CLOSE, "GDK_FUNC_CLOSE", "close" }, +}; +static GtkEnumValue enum_values_GdkColorContextMode[] = { + { GDK_CC_MODE_UNDEFINED, "GDK_CC_MODE_UNDEFINED", "undefined" }, + { GDK_CC_MODE_BW, "GDK_CC_MODE_BW", "bw" }, + { GDK_CC_MODE_STD_CMAP, "GDK_CC_MODE_STD_CMAP", "std-cmap" }, + { GDK_CC_MODE_TRUE, "GDK_CC_MODE_TRUE", "true" }, + { GDK_CC_MODE_MY_GRAY, "GDK_CC_MODE_MY_GRAY", "my-gray" }, + { GDK_CC_MODE_PALETTE, "GDK_CC_MODE_PALETTE", "palette" }, +}; +static GtkEnumValue enum_values_GdkOverlapType[] = { + { GDK_OVERLAP_RECTANGLE_IN, "GDK_OVERLAP_RECTANGLE_IN", "in" }, + { GDK_OVERLAP_RECTANGLE_OUT, "GDK_OVERLAP_RECTANGLE_OUT", "out" }, + { GDK_OVERLAP_RECTANGLE_PART, "GDK_OVERLAP_RECTANGLE_PART", "part" }, +}; +static GtkEnumValue enum_values_GtkAccelFlags[] = { + { GTK_ACCEL_VISIBLE, "GTK_ACCEL_VISIBLE", "visible" }, + { GTK_ACCEL_SIGNAL_VISIBLE, "GTK_ACCEL_SIGNAL_VISIBLE", "signal-visible" }, + { GTK_ACCEL_LOCKED, "GTK_ACCEL_LOCKED", "locked" }, + { GTK_ACCEL_MASK, "GTK_ACCEL_MASK", "mask" }, +}; +static GtkEnumValue enum_values_GtkArrowType[] = { + { GTK_ARROW_UP, "GTK_ARROW_UP", "up" }, + { GTK_ARROW_DOWN, "GTK_ARROW_DOWN", "down" }, + { GTK_ARROW_LEFT, "GTK_ARROW_LEFT", "left" }, + { GTK_ARROW_RIGHT, "GTK_ARROW_RIGHT", "right" }, +}; +static GtkEnumValue enum_values_GtkAttachOptions[] = { + { GTK_EXPAND, "GTK_EXPAND", "expand" }, + { GTK_SHRINK, "GTK_SHRINK", "shrink" }, + { GTK_FILL, "GTK_FILL", "fill" }, +}; +static GtkEnumValue enum_values_GtkButtonBoxStyle[] = { + { GTK_BUTTONBOX_DEFAULT_STYLE, "GTK_BUTTONBOX_DEFAULT_STYLE", "default" }, + { GTK_BUTTONBOX_SPREAD, "GTK_BUTTONBOX_SPREAD", "spread" }, + { GTK_BUTTONBOX_EDGE, "GTK_BUTTONBOX_EDGE", "edge" }, + { GTK_BUTTONBOX_START, "GTK_BUTTONBOX_START", "start" }, + { GTK_BUTTONBOX_END, "GTK_BUTTONBOX_END", "end" }, +}; +static GtkEnumValue enum_values_GtkCurveType[] = { + { GTK_CURVE_TYPE_LINEAR, "GTK_CURVE_TYPE_LINEAR", "linear" }, + { GTK_CURVE_TYPE_SPLINE, "GTK_CURVE_TYPE_SPLINE", "spline" }, + { GTK_CURVE_TYPE_FREE, "GTK_CURVE_TYPE_FREE", "free" }, +}; +static GtkEnumValue enum_values_GtkDirectionType[] = { + { GTK_DIR_TAB_FORWARD, "GTK_DIR_TAB_FORWARD", "tab-forward" }, + { GTK_DIR_TAB_BACKWARD, "GTK_DIR_TAB_BACKWARD", "tab-backward" }, + { GTK_DIR_UP, "GTK_DIR_UP", "up" }, + { GTK_DIR_DOWN, "GTK_DIR_DOWN", "down" }, + { GTK_DIR_LEFT, "GTK_DIR_LEFT", "left" }, + { GTK_DIR_RIGHT, "GTK_DIR_RIGHT", "right" }, +}; +static GtkEnumValue enum_values_GtkJustification[] = { + { GTK_JUSTIFY_LEFT, "GTK_JUSTIFY_LEFT", "left" }, + { GTK_JUSTIFY_RIGHT, "GTK_JUSTIFY_RIGHT", "right" }, + { GTK_JUSTIFY_CENTER, "GTK_JUSTIFY_CENTER", "center" }, + { GTK_JUSTIFY_FILL, "GTK_JUSTIFY_FILL", "fill" }, +}; +static GtkEnumValue enum_values_GtkMatchType[] = { + { GTK_MATCH_ALL, "GTK_MATCH_ALL", "all" }, + { GTK_MATCH_ALL_TAIL, "GTK_MATCH_ALL_TAIL", "all-tail" }, + { GTK_MATCH_HEAD, "GTK_MATCH_HEAD", "head" }, + { GTK_MATCH_TAIL, "GTK_MATCH_TAIL", "tail" }, + { GTK_MATCH_EXACT, "GTK_MATCH_EXACT", "exact" }, + { GTK_MATCH_LAST, "GTK_MATCH_LAST", "last" }, +}; +static GtkEnumValue enum_values_GtkMenuFactoryType[] = { + { GTK_MENU_FACTORY_MENU, "GTK_MENU_FACTORY_MENU", "menu" }, + { GTK_MENU_FACTORY_MENU_BAR, "GTK_MENU_FACTORY_MENU_BAR", "menu-bar" }, + { GTK_MENU_FACTORY_OPTION_MENU, "GTK_MENU_FACTORY_OPTION_MENU", "option-menu" }, +}; +static GtkEnumValue enum_values_GtkMetricType[] = { + { GTK_PIXELS, "GTK_PIXELS", "pixels" }, + { GTK_INCHES, "GTK_INCHES", "inches" }, + { GTK_CENTIMETERS, "GTK_CENTIMETERS", "centimeters" }, +}; +static GtkEnumValue enum_values_GtkOrientation[] = { + { GTK_ORIENTATION_HORIZONTAL, "GTK_ORIENTATION_HORIZONTAL", "horizontal" }, + { GTK_ORIENTATION_VERTICAL, "GTK_ORIENTATION_VERTICAL", "vertical" }, +}; +static GtkEnumValue enum_values_GtkPackType[] = { + { GTK_PACK_START, "GTK_PACK_START", "start" }, + { GTK_PACK_END, "GTK_PACK_END", "end" }, +}; +static GtkEnumValue enum_values_GtkPathPriorityType[] = { + { GTK_PATH_PRIO_LOWEST, "GTK_PATH_PRIO_LOWEST", "lowest" }, + { GTK_PATH_PRIO_GTK, "GTK_PATH_PRIO_GTK", "gtk" }, + { GTK_PATH_PRIO_APPLICATION, "GTK_PATH_PRIO_APPLICATION", "application" }, + { GTK_PATH_PRIO_RC, "GTK_PATH_PRIO_RC", "rc" }, + { GTK_PATH_PRIO_HIGHEST, "GTK_PATH_PRIO_HIGHEST", "highest" }, + { GTK_PATH_PRIO_MASK, "GTK_PATH_PRIO_MASK", "mask" }, +}; +static GtkEnumValue enum_values_GtkPathType[] = { + { GTK_PATH_WIDGET, "GTK_PATH_WIDGET", "widget" }, + { GTK_PATH_WIDGET_CLASS, "GTK_PATH_WIDGET_CLASS", "widget-class" }, + { GTK_PATH_CLASS, "GTK_PATH_CLASS", "class" }, +}; +static GtkEnumValue enum_values_GtkPolicyType[] = { + { GTK_POLICY_ALWAYS, "GTK_POLICY_ALWAYS", "always" }, + { GTK_POLICY_AUTOMATIC, "GTK_POLICY_AUTOMATIC", "automatic" }, +}; +static GtkEnumValue enum_values_GtkPositionType[] = { + { GTK_POS_LEFT, "GTK_POS_LEFT", "left" }, + { GTK_POS_RIGHT, "GTK_POS_RIGHT", "right" }, + { GTK_POS_TOP, "GTK_POS_TOP", "top" }, + { GTK_POS_BOTTOM, "GTK_POS_BOTTOM", "bottom" }, +}; +static GtkEnumValue enum_values_GtkPreviewType[] = { + { GTK_PREVIEW_COLOR, "GTK_PREVIEW_COLOR", "color" }, + { GTK_PREVIEW_GRAYSCALE, "GTK_PREVIEW_GRAYSCALE", "grayscale" }, + { GTK_PREVIEW_GREYSCALE, "GTK_PREVIEW_GREYSCALE", "greyscale" }, +}; +static GtkEnumValue enum_values_GtkReliefStyle[] = { + { GTK_RELIEF_NORMAL, "GTK_RELIEF_NORMAL", "normal" }, + { GTK_RELIEF_NONE, "GTK_RELIEF_NONE", "none" }, +}; +static GtkEnumValue enum_values_GtkScrollType[] = { + { GTK_SCROLL_NONE, "GTK_SCROLL_NONE", "none" }, + { GTK_SCROLL_STEP_BACKWARD, "GTK_SCROLL_STEP_BACKWARD", "step-backward" }, + { GTK_SCROLL_STEP_FORWARD, "GTK_SCROLL_STEP_FORWARD", "step-forward" }, + { GTK_SCROLL_PAGE_BACKWARD, "GTK_SCROLL_PAGE_BACKWARD", "page-backward" }, + { GTK_SCROLL_PAGE_FORWARD, "GTK_SCROLL_PAGE_FORWARD", "page-forward" }, + { GTK_SCROLL_JUMP, "GTK_SCROLL_JUMP", "jump" }, +}; +static GtkEnumValue enum_values_GtkSelectionMode[] = { + { GTK_SELECTION_SINGLE, "GTK_SELECTION_SINGLE", "single" }, + { GTK_SELECTION_BROWSE, "GTK_SELECTION_BROWSE", "browse" }, + { GTK_SELECTION_MULTIPLE, "GTK_SELECTION_MULTIPLE", "multiple" }, + { GTK_SELECTION_EXTENDED, "GTK_SELECTION_EXTENDED", "extended" }, +}; +static GtkEnumValue enum_values_GtkShadowType[] = { + { GTK_SHADOW_NONE, "GTK_SHADOW_NONE", "none" }, + { GTK_SHADOW_IN, "GTK_SHADOW_IN", "in" }, + { GTK_SHADOW_OUT, "GTK_SHADOW_OUT", "out" }, + { GTK_SHADOW_ETCHED_IN, "GTK_SHADOW_ETCHED_IN", "etched-in" }, + { GTK_SHADOW_ETCHED_OUT, "GTK_SHADOW_ETCHED_OUT", "etched-out" }, +}; +static GtkEnumValue enum_values_GtkSignalRunType[] = { + { GTK_RUN_FIRST, "GTK_RUN_FIRST", "first" }, + { GTK_RUN_LAST, "GTK_RUN_LAST", "last" }, + { GTK_RUN_BOTH, "GTK_RUN_BOTH", "both" }, + { GTK_RUN_MASK, "GTK_RUN_MASK", "mask" }, + { GTK_RUN_NO_RECURSE, "GTK_RUN_NO_RECURSE", "no-recurse" }, +}; +static GtkEnumValue enum_values_GtkStateType[] = { + { GTK_STATE_NORMAL, "GTK_STATE_NORMAL", "normal" }, + { GTK_STATE_ACTIVE, "GTK_STATE_ACTIVE", "active" }, + { GTK_STATE_PRELIGHT, "GTK_STATE_PRELIGHT", "prelight" }, + { GTK_STATE_SELECTED, "GTK_STATE_SELECTED", "selected" }, + { GTK_STATE_INSENSITIVE, "GTK_STATE_INSENSITIVE", "insensitive" }, +}; +static GtkEnumValue enum_values_GtkSubmenuDirection[] = { + { GTK_DIRECTION_LEFT, "GTK_DIRECTION_LEFT", "left" }, + { GTK_DIRECTION_RIGHT, "GTK_DIRECTION_RIGHT", "right" }, +}; +static GtkEnumValue enum_values_GtkSubmenuPlacement[] = { + { GTK_TOP_BOTTOM, "GTK_TOP_BOTTOM", "top-bottom" }, + { GTK_LEFT_RIGHT, "GTK_LEFT_RIGHT", "left-right" }, +}; +static GtkEnumValue enum_values_GtkToolbarStyle[] = { + { GTK_TOOLBAR_ICONS, "GTK_TOOLBAR_ICONS", "icons" }, + { GTK_TOOLBAR_TEXT, "GTK_TOOLBAR_TEXT", "text" }, + { GTK_TOOLBAR_BOTH, "GTK_TOOLBAR_BOTH", "both" }, +}; +static GtkEnumValue enum_values_GtkTroughType[] = { + { GTK_TROUGH_NONE, "GTK_TROUGH_NONE", "none" }, + { GTK_TROUGH_START, "GTK_TROUGH_START", "start" }, + { GTK_TROUGH_END, "GTK_TROUGH_END", "end" }, + { GTK_TROUGH_JUMP, "GTK_TROUGH_JUMP", "jump" }, +}; +static GtkEnumValue enum_values_GtkUpdateType[] = { + { GTK_UPDATE_CONTINUOUS, "GTK_UPDATE_CONTINUOUS", "continuous" }, + { GTK_UPDATE_DISCONTINUOUS, "GTK_UPDATE_DISCONTINUOUS", "discontinuous" }, + { GTK_UPDATE_DELAYED, "GTK_UPDATE_DELAYED", "delayed" }, +}; +static GtkEnumValue enum_values_GtkVisibility[] = { + { GTK_VISIBILITY_NONE, "GTK_VISIBILITY_NONE", "none" }, + { GTK_VISIBILITY_PARTIAL, "GTK_VISIBILITY_PARTIAL", "partial" }, + { GTK_VISIBILITY_FULL, "GTK_VISIBILITY_FULL", "full" }, +}; +static GtkEnumValue enum_values_GtkWindowPosition[] = { + { GTK_WIN_POS_NONE, "GTK_WIN_POS_NONE", "none" }, + { GTK_WIN_POS_CENTER, "GTK_WIN_POS_CENTER", "center" }, + { GTK_WIN_POS_MOUSE, "GTK_WIN_POS_MOUSE", "mouse" }, +}; +static GtkEnumValue enum_values_GtkWindowType[] = { + { GTK_WINDOW_TOPLEVEL, "GTK_WINDOW_TOPLEVEL", "toplevel" }, + { GTK_WINDOW_DIALOG, "GTK_WINDOW_DIALOG", "dialog" }, + { GTK_WINDOW_POPUP, "GTK_WINDOW_POPUP", "popup" }, +}; +static GtkEnumValue enum_values_GtkFundamentalType[] = { + { GTK_TYPE_INVALID, "GTK_TYPE_INVALID", "invalid" }, + { GTK_TYPE_NONE, "GTK_TYPE_NONE", "none" }, + { GTK_TYPE_CHAR, "GTK_TYPE_CHAR", "char" }, + { GTK_TYPE_BOOL, "GTK_TYPE_BOOL", "bool" }, + { GTK_TYPE_INT, "GTK_TYPE_INT", "int" }, + { GTK_TYPE_UINT, "GTK_TYPE_UINT", "uint" }, + { GTK_TYPE_LONG, "GTK_TYPE_LONG", "long" }, + { GTK_TYPE_ULONG, "GTK_TYPE_ULONG", "ulong" }, + { GTK_TYPE_FLOAT, "GTK_TYPE_FLOAT", "float" }, + { GTK_TYPE_DOUBLE, "GTK_TYPE_DOUBLE", "double" }, + { GTK_TYPE_STRING, "GTK_TYPE_STRING", "string" }, + { GTK_TYPE_ENUM, "GTK_TYPE_ENUM", "enum" }, + { GTK_TYPE_FLAGS, "GTK_TYPE_FLAGS", "flags" }, + { GTK_TYPE_BOXED, "GTK_TYPE_BOXED", "boxed" }, + { GTK_TYPE_FOREIGN, "GTK_TYPE_FOREIGN", "foreign" }, + { GTK_TYPE_CALLBACK, "GTK_TYPE_CALLBACK", "callback" }, + { GTK_TYPE_ARGS, "GTK_TYPE_ARGS", "args" }, + { GTK_TYPE_POINTER, "GTK_TYPE_POINTER", "pointer" }, + { GTK_TYPE_SIGNAL, "GTK_TYPE_SIGNAL", "signal" }, + { GTK_TYPE_C_CALLBACK, "GTK_TYPE_C_CALLBACK", "c-callback" }, + { GTK_TYPE_OBJECT, "GTK_TYPE_OBJECT", "object" }, +}; +static GtkEnumValue enum_values_GtkDebugFlag[] = { + { GTK_DEBUG_OBJECTS, "GTK_DEBUG_OBJECTS", "objects" }, + { GTK_DEBUG_MISC, "GTK_DEBUG_MISC", "misc" }, + { GTK_DEBUG_SIGNALS, "GTK_DEBUG_SIGNALS", "signals" }, +}; +static GtkEnumValue enum_values_GtkObjectFlags[] = { + { GTK_DESTROYED, "GTK_DESTROYED", "destroyed" }, + { GTK_FLOATING, "GTK_FLOATING", "floating" }, + { GTK_CONNECTED, "GTK_CONNECTED", "connected" }, + { GTK_OBJECT_FLAG_LAST, "GTK_OBJECT_FLAG_LAST", "object-flag-last" }, +}; +static GtkEnumValue enum_values_GtkArgFlags[] = { + { GTK_ARG_READABLE, "GTK_ARG_READABLE", "readable" }, + { GTK_ARG_WRITABLE, "GTK_ARG_WRITABLE", "writable" }, + { GTK_ARG_CONSTRUCT, "GTK_ARG_CONSTRUCT", "construct" }, + { GTK_ARG_MASK, "GTK_ARG_MASK", "mask" }, + { GTK_ARG_READWRITE, "GTK_ARG_READWRITE", "readwrite" }, +}; +static GtkEnumValue enum_values_GtkWidgetFlags[] = { + { GTK_TOPLEVEL, "GTK_TOPLEVEL", "toplevel" }, + { GTK_NO_WINDOW, "GTK_NO_WINDOW", "no-window" }, + { GTK_REALIZED, "GTK_REALIZED", "realized" }, + { GTK_MAPPED, "GTK_MAPPED", "mapped" }, + { GTK_VISIBLE, "GTK_VISIBLE", "visible" }, + { GTK_SENSITIVE, "GTK_SENSITIVE", "sensitive" }, + { GTK_PARENT_SENSITIVE, "GTK_PARENT_SENSITIVE", "parent-sensitive" }, + { GTK_CAN_FOCUS, "GTK_CAN_FOCUS", "can-focus" }, + { GTK_HAS_FOCUS, "GTK_HAS_FOCUS", "has-focus" }, + { GTK_CAN_DEFAULT, "GTK_CAN_DEFAULT", "can-default" }, + { GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" }, + { GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" }, + { GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" }, + { GTK_BASIC, "GTK_BASIC", "basic" }, +}; +static GtkEnumValue enum_values_GtkPrivateFlags[] = { + { PRIVATE_GTK_USER_STYLE, "PRIVATE_GTK_USER_STYLE", "user-style" }, + { PRIVATE_GTK_REDRAW_PENDING, "PRIVATE_GTK_REDRAW_PENDING", "redraw-pending" }, + { PRIVATE_GTK_RESIZE_PENDING, "PRIVATE_GTK_RESIZE_PENDING", "resize-pending" }, + { PRIVATE_GTK_RESIZE_NEEDED, "PRIVATE_GTK_RESIZE_NEEDED", "resize-needed" }, + { PRIVATE_GTK_LEAVE_PENDING, "PRIVATE_GTK_LEAVE_PENDING", "leave-pending" }, + { PRIVATE_GTK_HAS_SHAPE_MASK, "PRIVATE_GTK_HAS_SHAPE_MASK", "has-shape-mask" }, + { PRIVATE_GTK_IN_REPARENT, "PRIVATE_GTK_IN_REPARENT", "in-reparent" }, +}; +static GtkEnumValue enum_values_GdkDebugFlag[] = { + { GDK_DEBUG_MISC, "GDK_DEBUG_MISC", "misc" }, + { GDK_DEBUG_EVENTS, "GDK_DEBUG_EVENTS", "events" }, + { GDK_DEBUG_DND, "GDK_DEBUG_DND", "dnd" }, + { GDK_DEBUG_COLOR_CONTEXT, "GDK_DEBUG_COLOR_CONTEXT", "color-context" }, + { GDK_DEBUG_XIM, "GDK_DEBUG_XIM", "xim" }, +}; + diff --git a/gtk/gtktypebuiltins.c b/gtk/gtktypebuiltins2.c similarity index 78% rename from gtk/gtktypebuiltins.c rename to gtk/gtktypebuiltins2.c index 8ca1418a40..8651dce683 100644 --- a/gtk/gtktypebuiltins.c +++ b/gtk/gtktypebuiltins2.c @@ -1,9 +1,49 @@ /* generated by gentypeinfo from "gtk.defs" */ + { "GdkWindowType", GTK_TYPE_ENUM, enum_values_GdkWindowType }, + { "GdkWindowClass", GTK_TYPE_ENUM, enum_values_GdkWindowClass }, + { "GdkImageType", GTK_TYPE_ENUM, enum_values_GdkImageType }, + { "GdkVisualType", GTK_TYPE_ENUM, enum_values_GdkVisualType }, + { "GdkFontType", GTK_TYPE_ENUM, enum_values_GdkFontType }, + { "GdkWindowAttributesType", GTK_TYPE_FLAGS, enum_values_GdkWindowAttributesType }, + { "GdkWindowHints", GTK_TYPE_FLAGS, enum_values_GdkWindowHints }, + { "GdkFunction", GTK_TYPE_ENUM, enum_values_GdkFunction }, + { "GdkFill", GTK_TYPE_ENUM, enum_values_GdkFill }, + { "GdkFillRule", GTK_TYPE_ENUM, enum_values_GdkFillRule }, + { "GdkLineStyle", GTK_TYPE_ENUM, enum_values_GdkLineStyle }, + { "GdkCapStyle", GTK_TYPE_ENUM, enum_values_GdkCapStyle }, + { "GdkJoinStyle", GTK_TYPE_ENUM, enum_values_GdkJoinStyle }, + { "GdkFilterReturn", GTK_TYPE_ENUM, enum_values_GdkFilterReturn }, + { "GdkVisibilityState", GTK_TYPE_ENUM, enum_values_GdkVisibilityState }, + { "GdkEventType", GTK_TYPE_ENUM, enum_values_GdkEventType }, + { "GdkEventMask", GTK_TYPE_FLAGS, enum_values_GdkEventMask }, + { "GdkNotifyType", GTK_TYPE_ENUM, enum_values_GdkNotifyType }, + { "GdkCrossingMode", GTK_TYPE_ENUM, enum_values_GdkCrossingMode }, + { "GdkModifierType", GTK_TYPE_FLAGS, enum_values_GdkModifierType }, + { "GdkSubwindowMode", GTK_TYPE_ENUM, enum_values_GdkSubwindowMode }, + { "GdkInputCondition", GTK_TYPE_FLAGS, enum_values_GdkInputCondition }, + { "GdkStatus", GTK_TYPE_ENUM, enum_values_GdkStatus }, + { "GdkByteOrder", GTK_TYPE_ENUM, enum_values_GdkByteOrder }, + { "GdkGCValuesMask", GTK_TYPE_FLAGS, enum_values_GdkGCValuesMask }, + { "GdkSelection", GTK_TYPE_ENUM, enum_values_GdkSelection }, + { "GdkPropertyState", GTK_TYPE_ENUM, enum_values_GdkPropertyState }, + { "GdkPropMode", GTK_TYPE_ENUM, enum_values_GdkPropMode }, + { "GdkDndType", GTK_TYPE_ENUM, enum_values_GdkDndType }, + { "GdkInputSource", GTK_TYPE_ENUM, enum_values_GdkInputSource }, + { "GdkInputMode", GTK_TYPE_ENUM, enum_values_GdkInputMode }, + { "GdkAxisUse", GTK_TYPE_ENUM, enum_values_GdkAxisUse }, + { "GdkTarget", GTK_TYPE_ENUM, enum_values_GdkTarget }, + { "GdkSelectionType", GTK_TYPE_ENUM, enum_values_GdkSelectionType }, + { "GdkExtensionMode", GTK_TYPE_ENUM, enum_values_GdkExtensionMode }, + { "GdkWMDecoration", GTK_TYPE_FLAGS, enum_values_GdkWMDecoration }, + { "GdkWMFunction", GTK_TYPE_FLAGS, enum_values_GdkWMFunction }, + { "GdkColorContextMode", GTK_TYPE_ENUM, enum_values_GdkColorContextMode }, + { "GdkOverlapType", GTK_TYPE_ENUM, enum_values_GdkOverlapType }, { "GtkAccelFlags", GTK_TYPE_FLAGS, enum_values_GtkAccelFlags }, { "GtkArrowType", GTK_TYPE_ENUM, enum_values_GtkArrowType }, { "GtkAttachOptions", GTK_TYPE_FLAGS, enum_values_GtkAttachOptions }, { "GtkButtonBoxStyle", GTK_TYPE_ENUM, enum_values_GtkButtonBoxStyle }, + { "GtkCurveType", GTK_TYPE_ENUM, enum_values_GtkCurveType }, { "GtkDirectionType", GTK_TYPE_ENUM, enum_values_GtkDirectionType }, { "GtkJustification", GTK_TYPE_ENUM, enum_values_GtkJustification }, { "GtkMatchType", GTK_TYPE_ENUM, enum_values_GtkMatchType }, @@ -30,37 +70,13 @@ { "GtkVisibility", GTK_TYPE_ENUM, enum_values_GtkVisibility }, { "GtkWindowPosition", GTK_TYPE_ENUM, enum_values_GtkWindowPosition }, { "GtkWindowType", GTK_TYPE_ENUM, enum_values_GtkWindowType }, + { "GtkFundamentalType", GTK_TYPE_ENUM, enum_values_GtkFundamentalType }, + { "GtkDebugFlag", GTK_TYPE_FLAGS, enum_values_GtkDebugFlag }, { "GtkObjectFlags", GTK_TYPE_FLAGS, enum_values_GtkObjectFlags }, { "GtkArgFlags", GTK_TYPE_FLAGS, enum_values_GtkArgFlags }, { "GtkWidgetFlags", GTK_TYPE_FLAGS, enum_values_GtkWidgetFlags }, { "GtkPrivateFlags", GTK_TYPE_FLAGS, enum_values_GtkPrivateFlags }, - { "GtkCurveType", GTK_TYPE_ENUM, enum_values_GtkCurveType }, - { "GtkFundamentalType", GTK_TYPE_ENUM, enum_values_GtkFundamentalType }, - { "GdkWindowType", GTK_TYPE_ENUM, enum_values_GdkWindowType }, - { "GdkWindowClass", GTK_TYPE_ENUM, enum_values_GdkWindowClass }, - { "GdkImageType", GTK_TYPE_ENUM, enum_values_GdkImageType }, - { "GdkVisualType", GTK_TYPE_ENUM, enum_values_GdkVisualType }, - { "GdkWindowAttributesType", GTK_TYPE_FLAGS, enum_values_GdkWindowAttributesType }, - { "GdkWindowHints", GTK_TYPE_FLAGS, enum_values_GdkWindowHints }, - { "GdkFunction", GTK_TYPE_ENUM, enum_values_GdkFunction }, - { "GdkFill", GTK_TYPE_ENUM, enum_values_GdkFill }, - { "GdkLineStyle", GTK_TYPE_ENUM, enum_values_GdkLineStyle }, - { "GdkCapStyle", GTK_TYPE_ENUM, enum_values_GdkCapStyle }, - { "GdkJoinStyle", GTK_TYPE_ENUM, enum_values_GdkJoinStyle }, - { "GdkCursorType", GTK_TYPE_ENUM, enum_values_GdkCursorType }, - { "GdkEventType", GTK_TYPE_ENUM, enum_values_GdkEventType }, - { "GdkEventMask", GTK_TYPE_FLAGS, enum_values_GdkEventMask }, - { "GdkNotifyType", GTK_TYPE_ENUM, enum_values_GdkNotifyType }, - { "GdkCrossingMode", GTK_TYPE_FLAGS, enum_values_GdkCrossingMode }, - { "GdkModifierType", GTK_TYPE_FLAGS, enum_values_GdkModifierType }, - { "GdkSubwindowMode", GTK_TYPE_ENUM, enum_values_GdkSubwindowMode }, - { "GdkInputCondition", GTK_TYPE_FLAGS, enum_values_GdkInputCondition }, - { "GdkStatus", GTK_TYPE_ENUM, enum_values_GdkStatus }, - { "GdkByteOrder", GTK_TYPE_ENUM, enum_values_GdkByteOrder }, - { "GdkGCValuesMask", GTK_TYPE_FLAGS, enum_values_GdkGCValuesMask }, - { "GdkSelection", GTK_TYPE_ENUM, enum_values_GdkSelection }, - { "GdkPropertyState", GTK_TYPE_ENUM, enum_values_GdkPropertyState }, - { "GdkPropMode", GTK_TYPE_ENUM, enum_values_GdkPropMode }, + { "GdkDebugFlag", GTK_TYPE_FLAGS, enum_values_GdkDebugFlag }, { "GtkAccelGroup", GTK_TYPE_BOXED, NULL }, { "GtkStyle", GTK_TYPE_BOXED, NULL }, { "GdkColormap", GTK_TYPE_BOXED, NULL }, diff --git a/gtk/gtktypeutils.c b/gtk/gtktypeutils.c index 5704bb487d..0ac01291ad 100644 --- a/gtk/gtktypeutils.c +++ b/gtk/gtktypeutils.c @@ -615,9 +615,8 @@ extern void gtk_object_init_type (void); GtkType gtk_type_builtins[GTK_TYPE_NUM_BUILTINS]; -#include "gtkwidget.h" /* include for enum values from GtkWidgetFlags */ -#include "gtkprivate.h" /* include for enum values from GtkPrivateFlags */ -#include "gtkenumvalues.c" +#include "makeenums.h" /* include for various places with enum definitions */ +#include "gtktypebuiltins1.c" static void gtk_type_init_builtin_types (void) @@ -656,7 +655,7 @@ gtk_type_init_builtin_types (void) GtkType parent; GtkEnumValue *values; } builtin_info[] = { -#include "gtktypebuiltins.c" +#include "gtktypebuiltins2.c" { NULL } }; guint i; diff --git a/gtk/gtktypeutils.h b/gtk/gtktypeutils.h index 87853259a5..44f248e13a 100644 --- a/gtk/gtktypeutils.h +++ b/gtk/gtktypeutils.h @@ -33,34 +33,35 @@ extern "C" { */ typedef enum { - GTK_TYPE_INVALID, - GTK_TYPE_NONE, - GTK_TYPE_CHAR, - GTK_TYPE_BOOL, - GTK_TYPE_INT, - GTK_TYPE_UINT, - GTK_TYPE_LONG, - GTK_TYPE_ULONG, - GTK_TYPE_FLOAT, - GTK_TYPE_DOUBLE, - GTK_TYPE_STRING, - GTK_TYPE_ENUM, - GTK_TYPE_FLAGS, - GTK_TYPE_BOXED, - GTK_TYPE_FOREIGN, - GTK_TYPE_CALLBACK, - GTK_TYPE_ARGS, + G_SV (GTK_TYPE_INVALID, invalid), + G_SV (GTK_TYPE_NONE, none), + G_SV (GTK_TYPE_CHAR, char), + G_SV (GTK_TYPE_BOOL, bool), + G_SV (GTK_TYPE_INT, int), + G_SV (GTK_TYPE_UINT, uint), + G_SV (GTK_TYPE_LONG, long), + G_SV (GTK_TYPE_ULONG, ulong), + G_SV (GTK_TYPE_FLOAT, float), + G_SV (GTK_TYPE_DOUBLE, double), + G_SV (GTK_TYPE_STRING, string), + G_SV (GTK_TYPE_ENUM, enum), + G_SV (GTK_TYPE_FLAGS, flags), + G_SV (GTK_TYPE_BOXED, boxed), + G_SV (GTK_TYPE_FOREIGN, foreign), + G_SV (GTK_TYPE_CALLBACK, callback), + G_SV (GTK_TYPE_ARGS, args), - GTK_TYPE_POINTER, - - /* It'd be great if the next two could be removed eventually + G_SV (GTK_TYPE_POINTER, pointer), + + /* It'd be great if GTK_TYPE_POINTER and GTK_TYPE_C_CALLBACK + * could be removed eventually */ - GTK_TYPE_SIGNAL, - GTK_TYPE_C_CALLBACK, + G_SV (GTK_TYPE_SIGNAL, signal), + G_SV (GTK_TYPE_C_CALLBACK, c-callback), - GTK_TYPE_OBJECT + G_SV (GTK_TYPE_OBJECT, object) -} GtkFundamentalType; +} G_ENUM (GtkFundamentalType); typedef guint GtkType; diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h index 12446033d7..27cff3d68d 100644 --- a/gtk/gtkwidget.h +++ b/gtk/gtkwidget.h @@ -37,21 +37,21 @@ extern "C" { */ typedef enum { - GTK_TOPLEVEL = 1 << 4, - GTK_NO_WINDOW = 1 << 5, - GTK_REALIZED = 1 << 6, - GTK_MAPPED = 1 << 7, - GTK_VISIBLE = 1 << 8, - GTK_SENSITIVE = 1 << 9, - GTK_PARENT_SENSITIVE = 1 << 10, - GTK_CAN_FOCUS = 1 << 11, - GTK_HAS_FOCUS = 1 << 12, - GTK_CAN_DEFAULT = 1 << 13, - GTK_HAS_DEFAULT = 1 << 14, - GTK_HAS_GRAB = 1 << 15, - GTK_RC_STYLE = 1 << 16, - GTK_BASIC = 1 << 17 -} GtkWidgetFlags; + G_NV (GTK_TOPLEVEL, toplevel, 1 << 4), + G_NV (GTK_NO_WINDOW, no-window, 1 << 5), + G_NV (GTK_REALIZED, realized, 1 << 6), + G_NV (GTK_MAPPED, mapped, 1 << 7), + G_NV (GTK_VISIBLE, visible, 1 << 8), + G_NV (GTK_SENSITIVE, sensitive, 1 << 9), + G_NV (GTK_PARENT_SENSITIVE, parent-sensitive, 1 << 10), + G_NV (GTK_CAN_FOCUS, can-focus, 1 << 11), + G_NV (GTK_HAS_FOCUS, has-focus, 1 << 12), + G_NV (GTK_CAN_DEFAULT, can-default, 1 << 13), + G_NV (GTK_HAS_DEFAULT, has-default, 1 << 14), + G_NV (GTK_HAS_GRAB, has-grab, 1 << 15), + G_NV (GTK_RC_STYLE, rc-style, 1 << 16), + G_NV (GTK_BASIC, basic, 1 << 17) +} G_FLAGS (GtkWidgetFlags); /* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer. diff --git a/gtk/makeenums.awk b/gtk/makeenums.awk index be9df4076b..0e90e18eea 100644 --- a/gtk/makeenums.awk +++ b/gtk/makeenums.awk @@ -1,105 +1,130 @@ BEGIN { - in_def=0; - TI=0; - delete type_names; - delete type_nicks; - delete type_flags; - n_defs = 0; -} - -(init == 0) { - printf ("/* generated by makeenums.awk from \"%s\" */\n\n", FILENAME); - init=1; -} - -";" { - sub (";.*", ""); -} - -/\(/ { - if (in_def == 0) - { - if ($1 == "(define-enum") - { - in_def = 1; - type_flags[TI]=0; - } - else if ($1 == "(define-flags") - { - in_def = 1; - type_flags[TI]=1; - } - } - else - in_def += 1; -} - -(in_def == 1) { + type_name = ""; # GtkEnumType + type_macro = ""; # GTK_TYPE_ENUM_TYPE + type_ident = ""; # _gtk_enum_type + type_flags = 0; + type_counter = 0; + delete value_names; # GTK_ENUM_VALUE + delete value_nicks; # enum-value VI = 0; - delete value_names; - delete value_nicks; + gen_arrays = 0; + gen_defs = 0; - type_nicks[TI] = $2; - type_names[TI] = "GTK_TYPE"; - for (i = 0; i < length(type_nicks[TI]); i++) + for (i = 1; i < ARGC; i++) { - ch = substr(type_nicks[TI], i + 1, 1); - Ch = toupper(ch); + if (ARGV[i] == "arrays") + gen_arrays = 1; + else if (ARGV[i] == "defs") + gen_defs = 1; + ARGV[i] = ""; + } + + if (gen_arrays) + printf ("/* generated by makeenums.awk */\n\n"); + else if (gen_defs) + printf (";; generated by makeenums.awk ; -*- scheme -*-\n\n"); + else + { + printf ("hm? what do you want me to do?\n") > "/dev/stderr"; + exit 1; + } +} + +function set_type (set_type_1) +{ + type_name = set_type_1; + type_macro = "GTK_TYPE"; + type_ident = ""; + for (i = 0; i < length (type_name); i++) + { + ch = substr (type_name, i + 1, 1); + Ch = toupper (ch); if (Ch == ch) - type_names[TI] = type_names[TI] "_" Ch; + { + type_macro = type_macro "_" Ch; + type_ident = type_ident "_" tolower (ch); + } else - type_names[TI] = type_names[TI] Ch; + { + type_macro = type_macro Ch; + type_ident = type_ident ch; + } } } -(in_def == 2) { - value_nicks[VI] = tolower ($1); - value_names[VI] = $2; - kill_pat="[^-A-z0123456789_]+"; - while (match (value_nicks[VI],kill_pat)) - sub(kill_pat,"",value_nicks[VI]); - while (match (value_names[VI],kill_pat)) - sub(kill_pat,"",value_names[VI]); +function set_value (set_value_1, set_value_2) +{ + value_names[VI] = set_value_1; + value_nicks[VI] = tolower (set_value_2); + while (match (value_nicks[VI], "_")) + sub ("_", "-", value_nicks[VI]); } -/\)/ { - if (in_def > 0) +function generate_arrays () +{ + if (gen_arrays) { - while (match($0,")")) + printf ("static GtkEnumValue enum_values_%s[] = {\n", type_name); + for (i = 0; i < VI; i++) { - sub(")",""); - if (in_def == 2) - VI += 1; - if (in_def == 1) - { - TI += 1; - } - in_def -= 1; - } - - if (in_def == 0) - { - printf ("static GtkEnumValue enum_values_%s[] = {\n", type_nicks[TI-1]); - for (j = 0; value_names[j] != ""; j++) - { - printf (" { %s, \"%s\", \"%s\" },\n", - value_names[j], value_names[j], value_nicks[j]); - } - printf (" { 0, NULL, NULL },\n"); - printf ("};\n"); + printf (" { %s, \"%s\", \"%s\" },\n", + value_names[i], value_names[i], value_nicks[i]); } + printf ("};\n"); } } +function generate_defs () +{ + if (gen_defs) + { + printf ("\n(define-%s %s", + type_flags ? "flags" : "enum", + type_name); + for (i = 0; i < VI; i++) + { + printf ("\n (%s %s)", + value_nicks[i], value_names[i]); + } + printf (")\n"); + } +} + +# parse keywords + +/G_ENUM_E/ { + if ($3 != "+" || $5 != "+") + printf ("huh? G_ENUM_E keyword without arg?\n") > "/dev/stderr"; + else + set_type($4); + type_flags = 0; + + generate_defs(); + generate_arrays(); + VI = 0; +} + +/G_ENUM_F/ { + if ($3 != "+" || $5 != "+") + printf ("huh? G_ENUM_F keyword without arg?\n") > "/dev/stderr"; + else + set_type($4); + type_flags = 1; + + generate_defs(); + generate_arrays(); + VI = 0; +} + +/G_ENUM_V/ { + if ($2 != "+" || $4 != "+" || $6 != "+") + printf ("huh? G_ENUM_V keyword without arg?\n") > "/dev/stderr"; + else + set_value($3, $5); + VI += 1; +} + END { -# printf("%u{\n", TI); - for (i = 0; i < TI; i++) - { -# printf(" { %s, \"%s\", %s, %s_values },\n", -# type_names[i], type_nicks[i], -# type_flags[i] ? "TRUE" : "FALSE", -# tolower(type_nicks[i])); - } -# printf("};\n"); + printf("\n"); } diff --git a/gtk/makeenums.h b/gtk/makeenums.h new file mode 100644 index 0000000000..4629eee633 --- /dev/null +++ b/gtk/makeenums.h @@ -0,0 +1,4 @@ +#include +#include +#include +#include diff --git a/gtk/testgtk.c b/gtk/testgtk.c index f270e9b01b..b93a16da61 100644 --- a/gtk/testgtk.c +++ b/gtk/testgtk.c @@ -19,6 +19,7 @@ #include #include #include +#include #include "gtk.h" #include "../gdk/gdk.h" #include "../gdk/gdkx.h" diff --git a/tests/testgtk.c b/tests/testgtk.c index f270e9b01b..b93a16da61 100644 --- a/tests/testgtk.c +++ b/tests/testgtk.c @@ -19,6 +19,7 @@ #include #include #include +#include #include "gtk.h" #include "../gdk/gdk.h" #include "../gdk/gdkx.h"