Attachment 4532 Details for Bug 11741 – preprocessed source which fails to compile

preprocessed source which fails to compile

gtkcauldron.i (text/plain), 514.85 KB, created by rehsack on 2003-07-31 09:21:46 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: rehsack

Created: 2003-07-31 09:21:46 UTC

Size: 514.85 KB

patch

obsolete

># 1 "gtkcauldron.c"
># 1 "<built-in>"
># 1 "<command line>"
># 1 "gtkcauldron.c"
># 20 "gtkcauldron.c"
># 1 "gtkcauldron.h" 1
># 22 "gtkcauldron.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h" 1
># 30 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h"
># 1 "/usr/X11R6/include/gtk12/gdk/gdk.h" 1
># 31 "/usr/X11R6/include/gtk12/gdk/gdk.h"
># 1 "/usr/X11R6/include/gtk12/gdk/gdktypes.h" 1
># 33 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
># 1 "/usr/local/include/glib12/glib.h" 1
># 66 "/usr/local/include/glib12/glib.h"
># 1 "/usr/local/include/glib12/glibconfig.h" 1
># 9 "/usr/local/include/glib12/glibconfig.h"
># 1 "/usr/include/limits.h" 1 3 4
># 40 "/usr/include/limits.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 41 "/usr/include/limits.h" 2 3 4
># 128 "/usr/include/limits.h" 3 4
># 1 "/usr/include/sys/limits.h" 1 3 4
># 40 "/usr/include/sys/limits.h" 3 4
># 1 "/usr/include/machine/_limits.h" 1 3 4
># 41 "/usr/include/sys/limits.h" 2 3 4
># 129 "/usr/include/limits.h" 2 3 4
>
>
># 1 "/usr/include/sys/syslimits.h" 1 3 4
># 132 "/usr/include/limits.h" 2 3 4
># 10 "/usr/local/include/glib12/glibconfig.h" 2
># 1 "/usr/include/float.h" 1 3 4
># 11 "/usr/local/include/glib12/glibconfig.h" 2
># 28 "/usr/local/include/glib12/glibconfig.h"
>typedef signed char gint8;
>typedef unsigned char guint8;
>typedef signed short gint16;
>typedef unsigned short guint16;
>typedef signed int gint32;
>typedef unsigned int guint32;
># 43 "/usr/local/include/glib12/glibconfig.h"
>__extension__ typedef signed long long gint64;
>__extension__ typedef unsigned long long guint64;
># 79 "/usr/local/include/glib12/glibconfig.h"
>typedef struct _GStaticMutex GStaticMutex;
>struct _GStaticMutex
>{
>  struct _GMutex *runtime_mutex;
>  union {
>    char pad[4];
>    double dummy_double;
>    void *dummy_pointer;
>    long dummy_long;
>  } aligned_pad_u;
>};
># 67 "/usr/local/include/glib12/glib.h" 2
>
>
>
># 1 "/usr/include/stdarg.h" 1 3 4
># 42 "/usr/include/stdarg.h" 3 4
># 1 "/usr/include/sys/_types.h" 1 3 4
># 33 "/usr/include/sys/_types.h" 3 4
># 1 "/usr/include/machine/_types.h" 1 3 4
># 45 "/usr/include/machine/_types.h" 3 4
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef short __int16_t;
>typedef unsigned short __uint16_t;
>typedef int __int32_t;
>typedef unsigned int __uint32_t;
>
>
>
>
>
>
>
>typedef int __attribute__((__mode__(__DI__))) __int64_t;
>typedef unsigned int __attribute__((__mode__(__DI__))) __uint64_t;
># 70 "/usr/include/machine/_types.h" 3 4
>typedef unsigned long __clock_t;
>typedef __int32_t __critical_t;
>typedef double __double_t;
>typedef double __float_t;
>typedef __int32_t __intfptr_t;
>typedef __int64_t __intmax_t;
>typedef __int32_t __intptr_t;
>typedef __int32_t __int_fast8_t;
>typedef __int32_t __int_fast16_t;
>typedef __int32_t __int_fast32_t;
>typedef __int64_t __int_fast64_t;
>typedef __int8_t __int_least8_t;
>typedef __int16_t __int_least16_t;
>typedef __int32_t __int_least32_t;
>typedef __int64_t __int_least64_t;
>typedef __int32_t __ptrdiff_t;
>typedef __int32_t __register_t;
>typedef __int32_t __segsz_t;
>typedef __uint32_t __size_t;
>typedef __int32_t __ssize_t;
>typedef __int32_t __time_t;
>typedef __uint32_t __uintfptr_t;
>typedef __uint64_t __uintmax_t;
>typedef __uint32_t __uintptr_t;
>typedef __uint32_t __uint_fast8_t;
>typedef __uint32_t __uint_fast16_t;
>typedef __uint32_t __uint_fast32_t;
>typedef __uint64_t __uint_fast64_t;
>typedef __uint8_t __uint_least8_t;
>typedef __uint16_t __uint_least16_t;
>typedef __uint32_t __uint_least32_t;
>typedef __uint64_t __uint_least64_t;
>typedef __uint32_t __u_register_t;
>typedef __uint32_t __vm_offset_t;
>typedef __int64_t __vm_ooffset_t;
>
>
>
>typedef __uint32_t __vm_paddr_t;
>
>typedef __uint64_t __vm_pindex_t;
>typedef __uint32_t __vm_size_t;
>
>
>
>
>
>typedef __builtin_va_list __va_list;
>
>
>
>
>
>typedef __va_list __gnuc_va_list;
># 34 "/usr/include/sys/_types.h" 2 3 4
>
>
>
>
>typedef __int32_t __clockid_t;
>typedef __uint32_t __fflags_t;
>typedef __uint64_t __fsblkcnt_t;
>typedef __uint64_t __fsfilcnt_t;
>typedef __uint32_t __gid_t;
>typedef __int64_t __id_t;
>typedef __uint32_t __ino_t;
>typedef long __key_t;
>typedef __uint16_t __mode_t;
>typedef int __nl_item;
>typedef __uint16_t __nlink_t;
>typedef __int64_t __off_t;
>typedef __int32_t __pid_t;
>typedef __int64_t __rlim_t;
>typedef __uint8_t __sa_family_t;
>typedef __uint32_t __socklen_t;
>typedef long __suseconds_t;
>typedef __int32_t __timer_t;
>typedef __uint32_t __udev_t;
>typedef __uint32_t __uid_t;
>typedef unsigned int __useconds_t;
># 78 "/usr/include/sys/_types.h" 3 4
>typedef int __ct_rune_t;
>typedef __ct_rune_t __rune_t;
>typedef __ct_rune_t __wchar_t;
>typedef __ct_rune_t __wint_t;
># 90 "/usr/include/sys/_types.h" 3 4
>typedef __udev_t __dev_t;
>
>
>
>
>
>
>typedef union {
>        char __mbstate8[128];
>        __int64_t _mbstateL;
>} __mbstate_t;
># 43 "/usr/include/stdarg.h" 2 3 4
>
>
>
>typedef __va_list va_list;
># 71 "/usr/local/include/glib12/glib.h" 2
># 477 "/usr/local/include/glib12/glib.h"
>typedef char gchar;
>typedef short gshort;
>typedef long glong;
>typedef int gint;
>typedef gint gboolean;
>
>typedef unsigned char guchar;
>typedef unsigned short gushort;
>typedef unsigned long gulong;
>typedef unsigned int guint;
>
>typedef float gfloat;
>typedef double gdouble;
># 502 "/usr/local/include/glib12/glib.h"
>typedef void* gpointer;
>typedef const void *gconstpointer;
>
>
>typedef gint32 gssize;
>typedef guint32 gsize;
>typedef guint32 GQuark;
>typedef gint32 GTime;
># 680 "/usr/local/include/glib12/glib.h"
>extern const guint glib_major_version;
>extern const guint glib_minor_version;
>extern const guint glib_micro_version;
>extern const guint glib_interface_age;
>extern const guint glib_binary_age;
># 694 "/usr/local/include/glib12/glib.h"
>typedef struct _GAllocator GAllocator;
>typedef struct _GArray GArray;
>typedef struct _GByteArray GByteArray;
>typedef struct _GCache GCache;
>typedef struct _GCompletion GCompletion;
>typedef struct _GData GData;
>typedef struct _GDebugKey GDebugKey;
>typedef struct _GHashTable GHashTable;
>typedef struct _GHook GHook;
>typedef struct _GHookList GHookList;
>typedef struct _GList GList;
>typedef struct _GMemChunk GMemChunk;
>typedef struct _GNode GNode;
>typedef struct _GPtrArray GPtrArray;
>typedef struct _GRelation GRelation;
>typedef struct _GScanner GScanner;
>typedef struct _GScannerConfig GScannerConfig;
>typedef struct _GSList GSList;
>typedef struct _GString GString;
>typedef struct _GStringChunk GStringChunk;
>typedef struct _GTimer GTimer;
>typedef struct _GTree GTree;
>typedef struct _GTuples GTuples;
>typedef union _GTokenValue GTokenValue;
>typedef struct _GIOChannel GIOChannel;
>
>
>typedef enum
>{
>  G_TRAVERSE_LEAFS = 1 << 0,
>  G_TRAVERSE_NON_LEAFS = 1 << 1,
>  G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
>  G_TRAVERSE_MASK = 0x03
>} GTraverseFlags;
>
>
>typedef enum
>{
>  G_IN_ORDER,
>  G_PRE_ORDER,
>  G_POST_ORDER,
>  G_LEVEL_ORDER
>} GTraverseType;
># 745 "/usr/local/include/glib12/glib.h"
>typedef enum
>{
>
>  G_LOG_FLAG_RECURSION = 1 << 0,
>  G_LOG_FLAG_FATAL = 1 << 1,
>
>
>  G_LOG_LEVEL_ERROR = 1 << 2,
>  G_LOG_LEVEL_CRITICAL = 1 << 3,
>  G_LOG_LEVEL_WARNING = 1 << 4,
>  G_LOG_LEVEL_MESSAGE = 1 << 5,
>  G_LOG_LEVEL_INFO = 1 << 6,
>  G_LOG_LEVEL_DEBUG = 1 << 7,
>
>  G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
>} GLogLevelFlags;
>
>
>
>
>
>typedef gpointer (*GCacheNewFunc) (gpointer key);
>typedef gpointer (*GCacheDupFunc) (gpointer value);
>typedef void (*GCacheDestroyFunc) (gpointer value);
>typedef gint (*GCompareFunc) (gconstpointer a,
>                                                 gconstpointer b);
>typedef gchar* (*GCompletionFunc) (gpointer);
>typedef void (*GDestroyNotify) (gpointer data);
>typedef void (*GDataForeachFunc) (GQuark key_id,
>                                                 gpointer data,
>                                                 gpointer user_data);
>typedef void (*GFunc) (gpointer data,
>                                                 gpointer user_data);
>typedef guint (*GHashFunc) (gconstpointer key);
>typedef void (*GFreeFunc) (gpointer data);
>typedef void (*GHFunc) (gpointer key,
>                                                 gpointer value,
>                                                 gpointer user_data);
>typedef gboolean (*GHRFunc) (gpointer key,
>                                                 gpointer value,
>                                                 gpointer user_data);
>typedef gint (*GHookCompareFunc) (GHook *new_hook,
>                                                 GHook *sibling);
>typedef gboolean (*GHookFindFunc) (GHook *hook,
>                                                 gpointer data);
>typedef void (*GHookMarshaller) (GHook *hook,
>                                                 gpointer data);
>typedef gboolean (*GHookCheckMarshaller) (GHook *hook,
>                                                 gpointer data);
>typedef void (*GHookFunc) (gpointer data);
>typedef gboolean (*GHookCheckFunc) (gpointer data);
>typedef void (*GHookFreeFunc) (GHookList *hook_list,
>                                                 GHook *hook);
>typedef void (*GLogFunc) (const gchar *log_domain,
>                                                 GLogLevelFlags log_level,
>                                                 const gchar *message,
>                                                 gpointer user_data);
>typedef gboolean (*GNodeTraverseFunc) (GNode *node,
>                                                 gpointer data);
>typedef void (*GNodeForeachFunc) (GNode *node,
>                                                 gpointer data);
>typedef gint (*GSearchFunc) (gpointer key,
>                                                 gpointer data);
>typedef void (*GScannerMsgFunc) (GScanner *scanner,
>                                                 gchar *message,
>                                                 gint error);
>typedef gint (*GTraverseFunc) (gpointer key,
>                                                 gpointer value,
>                                                 gpointer data);
>typedef void (*GVoidFunc) (void);
>
>
>struct _GList
>{
>  gpointer data;
>  GList *next;
>  GList *prev;
>};
>
>struct _GSList
>{
>  gpointer data;
>  GSList *next;
>};
>
>struct _GString
>{
>  gchar *str;
>  gint len;
>};
>
>struct _GArray
>{
>  gchar *data;
>  guint len;
>};
>
>struct _GByteArray
>{
>  guint8 *data;
>  guint len;
>};
>
>struct _GPtrArray
>{
>  gpointer *pdata;
>  guint len;
>};
>
>struct _GTuples
>{
>  guint len;
>};
>
>struct _GDebugKey
>{
>  gchar *key;
>  guint value;
>};
>
>
>
>
>void g_list_push_allocator (GAllocator *allocator);
>void g_list_pop_allocator (void);
>GList* g_list_alloc (void);
>void g_list_free (GList *list);
>void g_list_free_1 (GList *list);
>GList* g_list_append (GList *list,
>                                 gpointer data);
>GList* g_list_prepend (GList *list,
>                                 gpointer data);
>GList* g_list_insert (GList *list,
>                                 gpointer data,
>                                 gint position);
>GList* g_list_insert_sorted (GList *list,
>                                 gpointer data,
>                                 GCompareFunc func);
>GList* g_list_concat (GList *list1,
>                                 GList *list2);
>GList* g_list_remove (GList *list,
>                                 gpointer data);
>GList* g_list_remove_link (GList *list,
>                                 GList *llink);
>GList* g_list_reverse (GList *list);
>GList* g_list_copy (GList *list);
>GList* g_list_nth (GList *list,
>                                 guint n);
>GList* g_list_find (GList *list,
>                                 gpointer data);
>GList* g_list_find_custom (GList *list,
>                                 gpointer data,
>                                 GCompareFunc func);
>gint g_list_position (GList *list,
>                                 GList *llink);
>gint g_list_index (GList *list,
>                                 gpointer data);
>GList* g_list_last (GList *list);
>GList* g_list_first (GList *list);
>guint g_list_length (GList *list);
>void g_list_foreach (GList *list,
>                                 GFunc func,
>                                 gpointer user_data);
>GList* g_list_sort (GList *list,
>                                 GCompareFunc compare_func);
>gpointer g_list_nth_data (GList *list,
>                                 guint n);
>
>
>
>
>
>
>void g_slist_push_allocator (GAllocator *allocator);
>void g_slist_pop_allocator (void);
>GSList* g_slist_alloc (void);
>void g_slist_free (GSList *list);
>void g_slist_free_1 (GSList *list);
>GSList* g_slist_append (GSList *list,
>                                 gpointer data);
>GSList* g_slist_prepend (GSList *list,
>                                 gpointer data);
>GSList* g_slist_insert (GSList *list,
>                                 gpointer data,
>                                 gint position);
>GSList* g_slist_insert_sorted (GSList *list,
>                                 gpointer data,
>                                 GCompareFunc func);
>GSList* g_slist_concat (GSList *list1,
>                                 GSList *list2);
>GSList* g_slist_remove (GSList *list,
>                                 gpointer data);
>GSList* g_slist_remove_link (GSList *list,
>                                 GSList *llink);
>GSList* g_slist_reverse (GSList *list);
>GSList* g_slist_copy (GSList *list);
>GSList* g_slist_nth (GSList *list,
>                                 guint n);
>GSList* g_slist_find (GSList *list,
>                                 gpointer data);
>GSList* g_slist_find_custom (GSList *list,
>                                 gpointer data,
>                                 GCompareFunc func);
>gint g_slist_position (GSList *list,
>                                 GSList *llink);
>gint g_slist_index (GSList *list,
>                                 gpointer data);
>GSList* g_slist_last (GSList *list);
>guint g_slist_length (GSList *list);
>void g_slist_foreach (GSList *list,
>                                 GFunc func,
>                                 gpointer user_data);
>GSList* g_slist_sort (GSList *list,
>                                 GCompareFunc compare_func);
>gpointer g_slist_nth_data (GSList *list,
>                                 guint n);
>
>
>
>
>
>GHashTable* g_hash_table_new (GHashFunc hash_func,
>                                         GCompareFunc key_compare_func);
>void g_hash_table_destroy (GHashTable *hash_table);
>void g_hash_table_insert (GHashTable *hash_table,
>                                         gpointer key,
>                                         gpointer value);
>void g_hash_table_remove (GHashTable *hash_table,
>                                         gconstpointer key);
>gpointer g_hash_table_lookup (GHashTable *hash_table,
>                                         gconstpointer key);
>gboolean g_hash_table_lookup_extended(GHashTable *hash_table,
>                                         gconstpointer lookup_key,
>                                         gpointer *orig_key,
>                                         gpointer *value);
>void g_hash_table_freeze (GHashTable *hash_table);
>void g_hash_table_thaw (GHashTable *hash_table);
>void g_hash_table_foreach (GHashTable *hash_table,
>                                         GHFunc func,
>                                         gpointer user_data);
>guint g_hash_table_foreach_remove (GHashTable *hash_table,
>                                         GHRFunc func,
>                                         gpointer user_data);
>guint g_hash_table_size (GHashTable *hash_table);
>
>
>
>
>GCache* g_cache_new (GCacheNewFunc value_new_func,
>                                GCacheDestroyFunc value_destroy_func,
>                                GCacheDupFunc key_dup_func,
>                                GCacheDestroyFunc key_destroy_func,
>                                GHashFunc hash_key_func,
>                                GHashFunc hash_value_func,
>                                GCompareFunc key_compare_func);
>void g_cache_destroy (GCache *cache);
>gpointer g_cache_insert (GCache *cache,
>                                gpointer key);
>void g_cache_remove (GCache *cache,
>                                gpointer value);
>void g_cache_key_foreach (GCache *cache,
>                                GHFunc func,
>                                gpointer user_data);
>void g_cache_value_foreach (GCache *cache,
>                                GHFunc func,
>                                gpointer user_data);
>
>
>
>
>GTree* g_tree_new (GCompareFunc key_compare_func);
>void g_tree_destroy (GTree *tree);
>void g_tree_insert (GTree *tree,
>                          gpointer key,
>                          gpointer value);
>void g_tree_remove (GTree *tree,
>                          gpointer key);
>gpointer g_tree_lookup (GTree *tree,
>                          gpointer key);
>void g_tree_traverse (GTree *tree,
>                          GTraverseFunc traverse_func,
>                          GTraverseType traverse_type,
>                          gpointer data);
>gpointer g_tree_search (GTree *tree,
>                          GSearchFunc search_func,
>                          gpointer data);
>gint g_tree_height (GTree *tree);
>gint g_tree_nnodes (GTree *tree);
>
>
>
>
>
>struct _GNode
>{
>  gpointer data;
>  GNode *next;
>  GNode *prev;
>  GNode *parent;
>  GNode *children;
>};
>
>
>
>
>
>
>void g_node_push_allocator (GAllocator *allocator);
>void g_node_pop_allocator (void);
>GNode* g_node_new (gpointer data);
>void g_node_destroy (GNode *root);
>void g_node_unlink (GNode *node);
>GNode* g_node_insert (GNode *parent,
>                                 gint position,
>                                 GNode *node);
>GNode* g_node_insert_before (GNode *parent,
>                                 GNode *sibling,
>                                 GNode *node);
>GNode* g_node_prepend (GNode *parent,
>                                 GNode *node);
>guint g_node_n_nodes (GNode *root,
>                                 GTraverseFlags flags);
>GNode* g_node_get_root (GNode *node);
>gboolean g_node_is_ancestor (GNode *node,
>                                 GNode *descendant);
>guint g_node_depth (GNode *node);
>GNode* g_node_find (GNode *root,
>                                 GTraverseType order,
>                                 GTraverseFlags flags,
>                                 gpointer data);
># 1093 "/usr/local/include/glib12/glib.h"
>void g_node_traverse (GNode *root,
>                                 GTraverseType order,
>                                 GTraverseFlags flags,
>                                 gint max_depth,
>                                 GNodeTraverseFunc func,
>                                 gpointer data);
>
>
>
>
>
>
>guint g_node_max_height (GNode *root);
>
>void g_node_children_foreach (GNode *node,
>                                  GTraverseFlags flags,
>                                  GNodeForeachFunc func,
>                                  gpointer data);
>void g_node_reverse_children (GNode *node);
>guint g_node_n_children (GNode *node);
>GNode* g_node_nth_child (GNode *node,
>                                  guint n);
>GNode* g_node_last_child (GNode *node);
>GNode* g_node_find_child (GNode *node,
>                                  GTraverseFlags flags,
>                                  gpointer data);
>gint g_node_child_position (GNode *node,
>                                  GNode *child);
>gint g_node_child_index (GNode *node,
>                                  gpointer data);
>
>GNode* g_node_first_sibling (GNode *node);
>GNode* g_node_last_sibling (GNode *node);
># 1138 "/usr/local/include/glib12/glib.h"
>typedef enum
>{
>  G_HOOK_FLAG_ACTIVE = 1 << 0,
>  G_HOOK_FLAG_IN_CALL = 1 << 1,
>  G_HOOK_FLAG_MASK = 0x0f
>} GHookFlagMask;
>
>
>
>struct _GHookList
>{
>  guint seq_id;
>  guint hook_size;
>  guint is_setup : 1;
>  GHook *hooks;
>  GMemChunk *hook_memchunk;
>  GHookFreeFunc hook_free;
>  GHookFreeFunc hook_destroy;
>};
>
>struct _GHook
>{
>  gpointer data;
>  GHook *next;
>  GHook *prev;
>  guint ref_count;
>  guint hook_id;
>  guint flags;
>  gpointer func;
>  GDestroyNotify destroy;
>};
># 1181 "/usr/local/include/glib12/glib.h"
>void g_hook_list_init (GHookList *hook_list,
>                                         guint hook_size);
>void g_hook_list_clear (GHookList *hook_list);
>GHook* g_hook_alloc (GHookList *hook_list);
>void g_hook_free (GHookList *hook_list,
>                                         GHook *hook);
>void g_hook_ref (GHookList *hook_list,
>                                         GHook *hook);
>void g_hook_unref (GHookList *hook_list,
>                                         GHook *hook);
>gboolean g_hook_destroy (GHookList *hook_list,
>                                         guint hook_id);
>void g_hook_destroy_link (GHookList *hook_list,
>                                         GHook *hook);
>void g_hook_prepend (GHookList *hook_list,
>                                         GHook *hook);
>void g_hook_insert_before (GHookList *hook_list,
>                                         GHook *sibling,
>                                         GHook *hook);
>void g_hook_insert_sorted (GHookList *hook_list,
>                                         GHook *hook,
>                                         GHookCompareFunc func);
>GHook* g_hook_get (GHookList *hook_list,
>                                         guint hook_id);
>GHook* g_hook_find (GHookList *hook_list,
>                                         gboolean need_valids,
>                                         GHookFindFunc func,
>                                         gpointer data);
>GHook* g_hook_find_data (GHookList *hook_list,
>                                         gboolean need_valids,
>                                         gpointer data);
>GHook* g_hook_find_func (GHookList *hook_list,
>                                         gboolean need_valids,
>                                         gpointer func);
>GHook* g_hook_find_func_data (GHookList *hook_list,
>                                         gboolean need_valids,
>                                         gpointer func,
>                                         gpointer data);
>
>GHook* g_hook_first_valid (GHookList *hook_list,
>                                         gboolean may_be_in_call);
>
>
>
>GHook* g_hook_next_valid (GHookList *hook_list,
>                                         GHook *hook,
>                                         gboolean may_be_in_call);
>
>
>gint g_hook_compare_ids (GHook *new_hook,
>                                         GHook *sibling);
>
>
>
>
>
>
>
>void g_hook_list_invoke (GHookList *hook_list,
>                                         gboolean may_recurse);
>
>
>
>void g_hook_list_invoke_check (GHookList *hook_list,
>                                         gboolean may_recurse);
>
>
>void g_hook_list_marshal (GHookList *hook_list,
>                                         gboolean may_recurse,
>                                         GHookMarshaller marshaller,
>                                         gpointer data);
>void g_hook_list_marshal_check (GHookList *hook_list,
>                                         gboolean may_recurse,
>                                         GHookCheckMarshaller marshaller,
>                                         gpointer data);
># 1267 "/usr/local/include/glib12/glib.h"
>void g_on_error_query (const gchar *prg_name);
>void g_on_error_stack_trace (const gchar *prg_name);
>
>
>
>
>extern const gchar *g_log_domain_glib;
>guint g_log_set_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_levels,
>                                         GLogFunc log_func,
>                                         gpointer user_data);
>void g_log_remove_handler (const gchar *log_domain,
>                                         guint handler_id);
>void g_log_default_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *message,
>                                         gpointer unused_data);
>void g_log (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         ...) __attribute__((format (printf, 3, 4)));
>void g_logv (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         va_list args);
>GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
>                                         GLogLevelFlags fatal_mask);
>GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
># 1354 "/usr/local/include/glib12/glib.h"
>typedef void (*GPrintFunc) (const gchar *string);
>void g_print (const gchar *format,
>                                         ...) __attribute__((format (printf, 1, 2)));
>GPrintFunc g_set_print_handler (GPrintFunc func);
>void g_printerr (const gchar *format,
>                                         ...) __attribute__((format (printf, 1, 2)));
>GPrintFunc g_set_printerr_handler (GPrintFunc func);
>
>
>typedef void (*GErrorFunc) (const gchar *str);
>typedef void (*GWarningFunc) (const gchar *str);
>GErrorFunc g_set_error_handler (GErrorFunc func);
>GWarningFunc g_set_warning_handler (GWarningFunc func);
>GPrintFunc g_set_message_handler (GPrintFunc func);
># 1381 "/usr/local/include/glib12/glib.h"
>gpointer g_malloc (gulong size);
>gpointer g_malloc0 (gulong size);
>gpointer g_realloc (gpointer mem,
>                        gulong size);
>void g_free (gpointer mem);
>
>
>
>void g_mem_profile (void);
>void g_mem_check (gpointer mem);
>
>
>
>GAllocator* g_allocator_new (const gchar *name,
>                               guint n_preallocs);
>void g_allocator_free (GAllocator *allocator);
># 1425 "/usr/local/include/glib12/glib.h"
>GMemChunk* g_mem_chunk_new (gchar *name,
>                                gint atom_size,
>                                gulong area_size,
>                                gint type);
>void g_mem_chunk_destroy (GMemChunk *mem_chunk);
>gpointer g_mem_chunk_alloc (GMemChunk *mem_chunk);
>gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk);
>void g_mem_chunk_free (GMemChunk *mem_chunk,
>                                gpointer mem);
>void g_mem_chunk_clean (GMemChunk *mem_chunk);
>void g_mem_chunk_reset (GMemChunk *mem_chunk);
>void g_mem_chunk_print (GMemChunk *mem_chunk);
>void g_mem_chunk_info (void);
># 1447 "/usr/local/include/glib12/glib.h"
>void g_blow_chunks (void);
>
>
>
>
>GTimer* g_timer_new (void);
>void g_timer_destroy (GTimer *timer);
>void g_timer_start (GTimer *timer);
>void g_timer_stop (GTimer *timer);
>void g_timer_reset (GTimer *timer);
>gdouble g_timer_elapsed (GTimer *timer,
>                         gulong *microseconds);
>
>
>
>
>
>
>gchar* g_strdelimit (gchar *string,
>                                 const gchar *delimiters,
>                                 gchar new_delimiter);
>gdouble g_strtod (const gchar *nptr,
>                                 gchar **endptr);
>gchar* g_strerror (gint errnum);
>gchar* g_strsignal (gint signum);
>gint g_strcasecmp (const gchar *s1,
>                                 const gchar *s2);
>gint g_strncasecmp (const gchar *s1,
>                                 const gchar *s2,
>                                 guint n);
>void g_strdown (gchar *string);
>void g_strup (gchar *string);
>void g_strreverse (gchar *string);
>
>gchar* g_strchug (gchar *string);
>
>gchar* g_strchomp (gchar *string);
>
>
>
>
>
>
>gchar* g_strdup (const gchar *str);
>gchar* g_strdup_printf (const gchar *format,
>                                 ...) __attribute__((format (printf, 1, 2)));
>gchar* g_strdup_vprintf (const gchar *format,
>                                 va_list args);
>gchar* g_strndup (const gchar *str,
>                                 guint n);
>gchar* g_strnfill (guint length,
>                                 gchar fill_char);
>gchar* g_strconcat (const gchar *string1,
>                                 ...);
>gchar* g_strjoin (const gchar *separator,
>                                 ...);
>gchar* g_strescape (gchar *string);
>gpointer g_memdup (gconstpointer mem,
>                                 guint byte_size);
># 1514 "/usr/local/include/glib12/glib.h"
>gchar** g_strsplit (const gchar *string,
>                                 const gchar *delimiter,
>                                 gint max_tokens);
>gchar* g_strjoinv (const gchar *separator,
>                                 gchar **str_array);
>void g_strfreev (gchar **str_array);
>
>
>
>
>
>guint g_printf_string_upper_bound (const gchar* format,
>                                     va_list args);
>
>
>
>
>gchar* g_get_user_name (void);
>gchar* g_get_real_name (void);
>gchar* g_get_home_dir (void);
>gchar* g_get_tmp_dir (void);
>gchar* g_get_prgname (void);
>void g_set_prgname (const gchar *prgname);
>
>
>
>
>guint g_parse_debug_string (const gchar *string,
>                                 GDebugKey *keys,
>                                 guint nkeys);
>gint g_snprintf (gchar *string,
>                                 gulong n,
>                                 gchar const *format,
>                                 ...) __attribute__((format (printf, 3, 4)));
>gint g_vsnprintf (gchar *string,
>                                 gulong n,
>                                 gchar const *format,
>                                 va_list args);
>gchar* g_basename (const gchar *file_name);
>
>gboolean g_path_is_absolute (const gchar *file_name);
>
>gchar* g_path_skip_root (gchar *file_name);
>
>
>gchar* g_dirname (const gchar *file_name);
>gchar* g_get_current_dir (void);
>
>
>
>gchar* g_getenv (const gchar *variable);
>
>
>
>
>
>
>
>void g_atexit (GVoidFunc func);
>
>
>
>
>extern inline gint g_bit_nth_lsf (guint32 mask,
>                                       gint nth_bit);
>
>extern inline gint
>g_bit_nth_lsf (guint32 mask,
>               gint nth_bit)
>{
>  do
>    {
>      nth_bit++;
>      if (mask & (1 << (guint) nth_bit))
>        return nth_bit;
>    }
>  while (nth_bit < 32);
>  return -1;
>}
>
>
>extern inline gint g_bit_nth_msf (guint32 mask,
>                                       gint nth_bit);
>
>extern inline gint
>g_bit_nth_msf (guint32 mask,
>               gint nth_bit)
>{
>  if (nth_bit < 0)
>    nth_bit = 32;
>  do
>    {
>      nth_bit--;
>      if (mask & (1 << (guint) nth_bit))
>        return nth_bit;
>    }
>  while (nth_bit > 0);
>  return -1;
>}
>
>
>extern inline guint g_bit_storage (guint number);
>
>extern inline guint
>g_bit_storage (guint number)
>{
>  register guint n_bits = 0;
>
>  do
>    {
>      n_bits++;
>      number >>= 1;
>    }
>  while (number);
>  return n_bits;
>}
>
>
>
>
>GStringChunk* g_string_chunk_new (gint size);
>void g_string_chunk_free (GStringChunk *chunk);
>gchar* g_string_chunk_insert (GStringChunk *chunk,
>                                            const gchar *string);
>gchar* g_string_chunk_insert_const (GStringChunk *chunk,
>                                            const gchar *string);
>
>
>
>
>GString* g_string_new (const gchar *init);
>GString* g_string_sized_new (guint dfl_size);
>void g_string_free (GString *string,
>                             gint free_segment);
>GString* g_string_assign (GString *lval,
>                             const gchar *rval);
>GString* g_string_truncate (GString *string,
>                             gint len);
>GString* g_string_append (GString *string,
>                             const gchar *val);
>GString* g_string_append_c (GString *string,
>                             gchar c);
>GString* g_string_prepend (GString *string,
>                             const gchar *val);
>GString* g_string_prepend_c (GString *string,
>                             gchar c);
>GString* g_string_insert (GString *string,
>                             gint pos,
>                             const gchar *val);
>GString* g_string_insert_c (GString *string,
>                             gint pos,
>                             gchar c);
>GString* g_string_erase (GString *string,
>                             gint pos,
>                             gint len);
>GString* g_string_down (GString *string);
>GString* g_string_up (GString *string);
>void g_string_sprintf (GString *string,
>                             const gchar *format,
>                             ...) __attribute__((format (printf, 2, 3)));
>void g_string_sprintfa (GString *string,
>                             const gchar *format,
>                             ...) __attribute__((format (printf, 2, 3)));
># 1689 "/usr/local/include/glib12/glib.h"
>GArray* g_array_new (gboolean zero_terminated,
>                                   gboolean clear,
>                                   guint element_size);
>void g_array_free (GArray *array,
>                                   gboolean free_segment);
>GArray* g_array_append_vals (GArray *array,
>                                   gconstpointer data,
>                                   guint len);
>GArray* g_array_prepend_vals (GArray *array,
>                                   gconstpointer data,
>                                   guint len);
>GArray* g_array_insert_vals (GArray *array,
>                                   guint index,
>                                   gconstpointer data,
>                                   guint len);
>GArray* g_array_set_size (GArray *array,
>                                   guint length);
>GArray* g_array_remove_index (GArray *array,
>                                   guint index);
>GArray* g_array_remove_index_fast (GArray *array,
>                                   guint index);
>
>
>
>
>
>
>
>GPtrArray* g_ptr_array_new (void);
>void g_ptr_array_free (GPtrArray *array,
>                                            gboolean free_seg);
>void g_ptr_array_set_size (GPtrArray *array,
>                                            gint length);
>gpointer g_ptr_array_remove_index (GPtrArray *array,
>                                            guint index);
>gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
>                                            guint index);
>gboolean g_ptr_array_remove (GPtrArray *array,
>                                            gpointer data);
>gboolean g_ptr_array_remove_fast (GPtrArray *array,
>                                            gpointer data);
>void g_ptr_array_add (GPtrArray *array,
>                                            gpointer data);
>
>
>
>
>
>GByteArray* g_byte_array_new (void);
>void g_byte_array_free (GByteArray *array,
>                                            gboolean free_segment);
>GByteArray* g_byte_array_append (GByteArray *array,
>                                            const guint8 *data,
>                                            guint len);
>GByteArray* g_byte_array_prepend (GByteArray *array,
>                                            const guint8 *data,
>                                            guint len);
>GByteArray* g_byte_array_set_size (GByteArray *array,
>                                            guint length);
>GByteArray* g_byte_array_remove_index (GByteArray *array,
>                                            guint index);
>GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
>                                            guint index);
>
>
>
>
>gint g_str_equal (gconstpointer v,
>                   gconstpointer v2);
>guint g_str_hash (gconstpointer v);
>
>gint g_int_equal (gconstpointer v,
>                   gconstpointer v2);
>guint g_int_hash (gconstpointer v);
>
>
>
>
>
>
>
>guint g_direct_hash (gconstpointer v);
>gint g_direct_equal (gconstpointer v,
>                      gconstpointer v2);
>
>
>
>
>GQuark g_quark_try_string (const gchar *string);
>GQuark g_quark_from_static_string (const gchar *string);
>GQuark g_quark_from_string (const gchar *string);
>gchar* g_quark_to_string (GQuark quark);
>
>
>
>
>
>void g_datalist_init (GData **datalist);
>void g_datalist_clear (GData **datalist);
>gpointer g_datalist_id_get_data (GData **datalist,
>                                          GQuark key_id);
>void g_datalist_id_set_data_full (GData **datalist,
>                                          GQuark key_id,
>                                          gpointer data,
>                                          GDestroyNotify destroy_func);
>void g_datalist_id_remove_no_notify (GData **datalist,
>                                          GQuark key_id);
>void g_datalist_foreach (GData **datalist,
>                                          GDataForeachFunc func,
>                                          gpointer user_data);
># 1818 "/usr/local/include/glib12/glib.h"
>void g_dataset_destroy (gconstpointer dataset_location);
>gpointer g_dataset_id_get_data (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_id_set_data_full (gconstpointer dataset_location,
>                                         GQuark key_id,
>                                         gpointer data,
>                                         GDestroyNotify destroy_func);
>void g_dataset_id_remove_no_notify (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_foreach (gconstpointer dataset_location,
>                                         GDataForeachFunc func,
>                                         gpointer user_data);
># 1862 "/usr/local/include/glib12/glib.h"
>typedef enum
>{
>  G_ERR_UNKNOWN,
>  G_ERR_UNEXP_EOF,
>  G_ERR_UNEXP_EOF_IN_STRING,
>  G_ERR_UNEXP_EOF_IN_COMMENT,
>  G_ERR_NON_DIGIT_IN_CONST,
>  G_ERR_DIGIT_RADIX,
>  G_ERR_FLOAT_RADIX,
>  G_ERR_FLOAT_MALFORMED
>} GErrorType;
>
>
>typedef enum
>{
>  G_TOKEN_EOF = 0,
>
>  G_TOKEN_LEFT_PAREN = '(',
>  G_TOKEN_RIGHT_PAREN = ')',
>  G_TOKEN_LEFT_CURLY = '{',
>  G_TOKEN_RIGHT_CURLY = '}',
>  G_TOKEN_LEFT_BRACE = '[',
>  G_TOKEN_RIGHT_BRACE = ']',
>  G_TOKEN_EQUAL_SIGN = '=',
>  G_TOKEN_COMMA = ',',
>
>  G_TOKEN_NONE = 256,
>
>  G_TOKEN_ERROR,
>
>  G_TOKEN_CHAR,
>  G_TOKEN_BINARY,
>  G_TOKEN_OCTAL,
>  G_TOKEN_INT,
>  G_TOKEN_HEX,
>  G_TOKEN_FLOAT,
>  G_TOKEN_STRING,
>
>  G_TOKEN_SYMBOL,
>  G_TOKEN_IDENTIFIER,
>  G_TOKEN_IDENTIFIER_NULL,
>
>  G_TOKEN_COMMENT_SINGLE,
>  G_TOKEN_COMMENT_MULTI,
>  G_TOKEN_LAST
>} GTokenType;
>
>union _GTokenValue
>{
>  gpointer v_symbol;
>  gchar *v_identifier;
>  gulong v_binary;
>  gulong v_octal;
>  gulong v_int;
>  gdouble v_float;
>  gulong v_hex;
>  gchar *v_string;
>  gchar *v_comment;
>  guchar v_char;
>  guint v_error;
>};
>
>struct _GScannerConfig
>{
>
>
>  gchar *cset_skip_characters;
>  gchar *cset_identifier_first;
>  gchar *cset_identifier_nth;
>  gchar *cpair_comment_single;
>
>
>
>  guint case_sensitive : 1;
>
>
>
>
>  guint skip_comment_multi : 1;
>  guint skip_comment_single : 1;
>  guint scan_comment_multi : 1;
>  guint scan_identifier : 1;
>  guint scan_identifier_1char : 1;
>  guint scan_identifier_NULL : 1;
>  guint scan_symbols : 1;
>  guint scan_binary : 1;
>  guint scan_octal : 1;
>  guint scan_float : 1;
>  guint scan_hex : 1;
>  guint scan_hex_dollar : 1;
>  guint scan_string_sq : 1;
>  guint scan_string_dq : 1;
>  guint numbers_2_int : 1;
>  guint int_2_float : 1;
>  guint identifier_2_string : 1;
>  guint char_2_token : 1;
>  guint symbol_2_token : 1;
>  guint scope_0_fallback : 1;
>};
>
>struct _GScanner
>{
>
>  gpointer user_data;
>  guint max_parse_errors;
>
>
>  guint parse_errors;
>
>
>  const gchar *input_name;
>
>
>  gpointer derived_data;
>
>
>  GScannerConfig *config;
>
>
>  GTokenType token;
>  GTokenValue value;
>  guint line;
>  guint position;
>
>
>  GTokenType next_token;
>  GTokenValue next_value;
>  guint next_line;
>  guint next_position;
>
>
>  GHashTable *symbol_table;
>  gint input_fd;
>  const gchar *text;
>  const gchar *text_end;
>  gchar *buffer;
>  guint scope_id;
>
>
>  GScannerMsgFunc msg_handler;
>};
>
>GScanner* g_scanner_new (GScannerConfig *config_templ);
>void g_scanner_destroy (GScanner *scanner);
>void g_scanner_input_file (GScanner *scanner,
>                                                 gint input_fd);
>void g_scanner_sync_file_offset (GScanner *scanner);
>void g_scanner_input_text (GScanner *scanner,
>                                                 const gchar *text,
>                                                 guint text_len);
>GTokenType g_scanner_get_next_token (GScanner *scanner);
>GTokenType g_scanner_peek_next_token (GScanner *scanner);
>GTokenType g_scanner_cur_token (GScanner *scanner);
>GTokenValue g_scanner_cur_value (GScanner *scanner);
>guint g_scanner_cur_line (GScanner *scanner);
>guint g_scanner_cur_position (GScanner *scanner);
>gboolean g_scanner_eof (GScanner *scanner);
>guint g_scanner_set_scope (GScanner *scanner,
>                                                 guint scope_id);
>void g_scanner_scope_add_symbol (GScanner *scanner,
>                                                 guint scope_id,
>                                                 const gchar *symbol,
>                                                 gpointer value);
>void g_scanner_scope_remove_symbol (GScanner *scanner,
>                                                 guint scope_id,
>                                                 const gchar *symbol);
>gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
>                                                 guint scope_id,
>                                                 const gchar *symbol);
>void g_scanner_scope_foreach_symbol (GScanner *scanner,
>                                                 guint scope_id,
>                                                 GHFunc func,
>                                                 gpointer user_data);
>gpointer g_scanner_lookup_symbol (GScanner *scanner,
>                                                 const gchar *symbol);
>void g_scanner_freeze_symbol_table (GScanner *scanner);
>void g_scanner_thaw_symbol_table (GScanner *scanner);
>void g_scanner_unexp_token (GScanner *scanner,
>                                                 GTokenType expected_token,
>                                                 const gchar *identifier_spec,
>                                                 const gchar *symbol_spec,
>                                                 const gchar *symbol_name,
>                                                 const gchar *message,
>                                                 gint is_error);
>void g_scanner_error (GScanner *scanner,
>                                                 const gchar *format,
>                                                 ...) __attribute__((format (printf, 2, 3)));
>void g_scanner_warn (GScanner *scanner,
>                                                 const gchar *format,
>                                                 ...) __attribute__((format (printf, 2, 3)));
>gint g_scanner_stat_mode (const gchar *filename);
># 2068 "/usr/local/include/glib12/glib.h"
>struct _GCompletion
>{
>  GList* items;
>  GCompletionFunc func;
>
>  gchar* prefix;
>  GList* cache;
>};
>
>GCompletion* g_completion_new (GCompletionFunc func);
>void g_completion_add_items (GCompletion* cmp,
>                                        GList* items);
>void g_completion_remove_items (GCompletion* cmp,
>                                        GList* items);
>void g_completion_clear_items (GCompletion* cmp);
>GList* g_completion_complete (GCompletion* cmp,
>                                        gchar* prefix,
>                                        gchar** new_prefix);
>void g_completion_free (GCompletion* cmp);
># 2098 "/usr/local/include/glib12/glib.h"
>typedef guint16 GDateYear;
>typedef guint8 GDateDay;
>typedef struct _GDate GDate;
>
>struct tm;
>
>
>typedef enum
>{
>  G_DATE_DAY = 0,
>  G_DATE_MONTH = 1,
>  G_DATE_YEAR = 2
>} GDateDMY;
>
>
>typedef enum
>{
>  G_DATE_BAD_WEEKDAY = 0,
>  G_DATE_MONDAY = 1,
>  G_DATE_TUESDAY = 2,
>  G_DATE_WEDNESDAY = 3,
>  G_DATE_THURSDAY = 4,
>  G_DATE_FRIDAY = 5,
>  G_DATE_SATURDAY = 6,
>  G_DATE_SUNDAY = 7
>} GDateWeekday;
>typedef enum
>{
>  G_DATE_BAD_MONTH = 0,
>  G_DATE_JANUARY = 1,
>  G_DATE_FEBRUARY = 2,
>  G_DATE_MARCH = 3,
>  G_DATE_APRIL = 4,
>  G_DATE_MAY = 5,
>  G_DATE_JUNE = 6,
>  G_DATE_JULY = 7,
>  G_DATE_AUGUST = 8,
>  G_DATE_SEPTEMBER = 9,
>  G_DATE_OCTOBER = 10,
>  G_DATE_NOVEMBER = 11,
>  G_DATE_DECEMBER = 12
>} GDateMonth;
># 2150 "/usr/local/include/glib12/glib.h"
>struct _GDate
>{
>  guint julian_days : 32;
>
>
>
>
>
>  guint julian : 1;
>  guint dmy : 1;
>
>
>  guint day : 6;
>  guint month : 4;
>  guint year : 16;
>};
>
>
>
>
>
>GDate* g_date_new (void);
>GDate* g_date_new_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year);
>GDate* g_date_new_julian (guint32 julian_day);
>void g_date_free (GDate *date);
>
>
>
>
>
>
>gboolean g_date_valid (GDate *date);
>gboolean g_date_valid_day (GDateDay day);
>gboolean g_date_valid_month (GDateMonth month);
>gboolean g_date_valid_year (GDateYear year);
>gboolean g_date_valid_weekday (GDateWeekday weekday);
>gboolean g_date_valid_julian (guint32 julian_date);
>gboolean g_date_valid_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year);
>
>GDateWeekday g_date_weekday (GDate *date);
>GDateMonth g_date_month (GDate *date);
>GDateYear g_date_year (GDate *date);
>GDateDay g_date_day (GDate *date);
>guint32 g_date_julian (GDate *date);
>guint g_date_day_of_year (GDate *date);
>
>
>
>
>
>
>
>guint g_date_monday_week_of_year (GDate *date);
>guint g_date_sunday_week_of_year (GDate *date);
>
>
>
>
>
>void g_date_clear (GDate *date,
>                                           guint n_dates);
>
>
>
>
>
>void g_date_set_parse (GDate *date,
>                                           const gchar *str);
>void g_date_set_time (GDate *date,
>                                           GTime time);
>void g_date_set_month (GDate *date,
>                                           GDateMonth month);
>void g_date_set_day (GDate *date,
>                                           GDateDay day);
>void g_date_set_year (GDate *date,
>                                           GDateYear year);
>void g_date_set_dmy (GDate *date,
>                                           GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear y);
>void g_date_set_julian (GDate *date,
>                                           guint32 julian_date);
>gboolean g_date_is_first_of_month (GDate *date);
>gboolean g_date_is_last_of_month (GDate *date);
>
>
>void g_date_add_days (GDate *date,
>                                           guint n_days);
>void g_date_subtract_days (GDate *date,
>                                           guint n_days);
>
>
>void g_date_add_months (GDate *date,
>                                           guint n_months);
>void g_date_subtract_months (GDate *date,
>                                           guint n_months);
>
>
>void g_date_add_years (GDate *date,
>                                           guint n_years);
>void g_date_subtract_years (GDate *date,
>                                           guint n_years);
>gboolean g_date_is_leap_year (GDateYear year);
>guint8 g_date_days_in_month (GDateMonth month,
>                                           GDateYear year);
>guint8 g_date_monday_weeks_in_year (GDateYear year);
>guint8 g_date_sunday_weeks_in_year (GDateYear year);
>
>
>gint g_date_compare (GDate *lhs,
>                                           GDate *rhs);
>void g_date_to_struct_tm (GDate *date,
>                                           struct tm *tm);
>
>
>
>
>gsize g_date_strftime (gchar *s,
>                                           gsize slen,
>                                           const gchar *format,
>                                           GDate *date);
># 2300 "/usr/local/include/glib12/glib.h"
>GRelation* g_relation_new (gint fields);
>void g_relation_destroy (GRelation *relation);
>void g_relation_index (GRelation *relation,
>                               gint field,
>                               GHashFunc hash_func,
>                               GCompareFunc key_compare_func);
>void g_relation_insert (GRelation *relation,
>                               ...);
>gint g_relation_delete (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>GTuples* g_relation_select (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gint g_relation_count (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gboolean g_relation_exists (GRelation *relation,
>                               ...);
>void g_relation_print (GRelation *relation);
>
>void g_tuples_destroy (GTuples *tuples);
>gpointer g_tuples_index (GTuples *tuples,
>                               gint index,
>                               gint field);
># 2336 "/usr/local/include/glib12/glib.h"
>guint g_spaced_primes_closest (guint num);
>
>
>
>
>
>typedef struct _GIOFuncs GIOFuncs;
>typedef enum
>{
>  G_IO_ERROR_NONE,
>  G_IO_ERROR_AGAIN,
>  G_IO_ERROR_INVAL,
>  G_IO_ERROR_UNKNOWN
>} GIOError;
>typedef enum
>{
>  G_SEEK_CUR,
>  G_SEEK_SET,
>  G_SEEK_END
>} GSeekType;
>typedef enum
>{
>  G_IO_IN =1,
>  G_IO_OUT =4,
>  G_IO_PRI =2,
>  G_IO_ERR =8,
>  G_IO_HUP =16,
>  G_IO_NVAL =32
>} GIOCondition;
>
>struct _GIOChannel
>{
>  guint channel_flags;
>  guint ref_count;
>  GIOFuncs *funcs;
>};
>
>typedef gboolean (*GIOFunc) (GIOChannel *source,
>                             GIOCondition condition,
>                             gpointer data);
>struct _GIOFuncs
>{
>  GIOError (*io_read) (GIOChannel *channel,
>                         gchar *buf,
>                         guint count,
>                         guint *bytes_read);
>  GIOError (*io_write) (GIOChannel *channel,
>                         gchar *buf,
>                         guint count,
>                         guint *bytes_written);
>  GIOError (*io_seek) (GIOChannel *channel,
>                         gint offset,
>                         GSeekType type);
>  void (*io_close) (GIOChannel *channel);
>  guint (*io_add_watch) (GIOChannel *channel,
>                         gint priority,
>                         GIOCondition condition,
>                         GIOFunc func,
>                         gpointer user_data,
>                         GDestroyNotify notify);
>  void (*io_free) (GIOChannel *channel);
>};
>
>void g_io_channel_init (GIOChannel *channel);
>void g_io_channel_ref (GIOChannel *channel);
>void g_io_channel_unref (GIOChannel *channel);
>GIOError g_io_channel_read (GIOChannel *channel,
>                                 gchar *buf,
>                                 guint count,
>                                 guint *bytes_read);
>GIOError g_io_channel_write (GIOChannel *channel,
>                                 gchar *buf,
>                                 guint count,
>                                 guint *bytes_written);
>GIOError g_io_channel_seek (GIOChannel *channel,
>                                 gint offset,
>                                 GSeekType type);
>void g_io_channel_close (GIOChannel *channel);
>guint g_io_add_watch_full (GIOChannel *channel,
>                                 gint priority,
>                                 GIOCondition condition,
>                                 GIOFunc func,
>                                 gpointer user_data,
>                                 GDestroyNotify notify);
>guint g_io_add_watch (GIOChannel *channel,
>                                 GIOCondition condition,
>                                 GIOFunc func,
>                                 gpointer user_data);
>
>
>
>
>typedef struct _GTimeVal GTimeVal;
>typedef struct _GSourceFuncs GSourceFuncs;
>typedef struct _GMainLoop GMainLoop;
>
>struct _GTimeVal
>{
>  glong tv_sec;
>  glong tv_usec;
>};
>struct _GSourceFuncs
>{
>  gboolean (*prepare) (gpointer source_data,
>                        GTimeVal *current_time,
>                        gint *timeout,
>                        gpointer user_data);
>  gboolean (*check) (gpointer source_data,
>                        GTimeVal *current_time,
>                        gpointer user_data);
>  gboolean (*dispatch) (gpointer source_data,
>                        GTimeVal *dispatch_time,
>                        gpointer user_data);
>  GDestroyNotify destroy;
>};
># 2460 "/usr/local/include/glib12/glib.h"
>typedef gboolean (*GSourceFunc) (gpointer data);
>
>
>guint g_source_add (gint priority,
>                                              gboolean can_recurse,
>                                              GSourceFuncs *funcs,
>                                              gpointer source_data,
>                                              gpointer user_data,
>                                              GDestroyNotify notify);
>gboolean g_source_remove (guint tag);
>gboolean g_source_remove_by_user_data (gpointer user_data);
>gboolean g_source_remove_by_source_data (gpointer source_data);
>gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
>                                              gpointer user_data);
>
>void g_get_current_time (GTimeVal *result);
>
>
>GMainLoop* g_main_new (gboolean is_running);
>void g_main_run (GMainLoop *loop);
>void g_main_quit (GMainLoop *loop);
>void g_main_destroy (GMainLoop *loop);
>gboolean g_main_is_running (GMainLoop *loop);
>
>
>
>
>gboolean g_main_iteration (gboolean may_block);
>
>
>gboolean g_main_pending (void);
>
>
>guint g_timeout_add_full (gint priority,
>                                         guint interval,
>                                         GSourceFunc function,
>                                         gpointer data,
>                                         GDestroyNotify notify);
>guint g_timeout_add (guint interval,
>                                         GSourceFunc function,
>                                         gpointer data);
>guint g_idle_add (GSourceFunc function,
>                                         gpointer data);
>guint g_idle_add_full (gint priority,
>                                         GSourceFunc function,
>                                         gpointer data,
>                                         GDestroyNotify destroy);
>gboolean g_idle_remove_by_data (gpointer data);
># 2533 "/usr/local/include/glib12/glib.h"
>typedef struct _GPollFD GPollFD;
>typedef gint (*GPollFunc) (GPollFD *ufds,
>                                 guint nfsd,
>                                 gint timeout);
>struct _GPollFD
>{
>  gint fd;
>  gushort events;
>  gushort revents;
>};
>
>void g_main_add_poll (GPollFD *fd,
>                                      gint priority);
>void g_main_remove_poll (GPollFD *fd);
>void g_main_set_poll_func (GPollFunc func);
># 2560 "/usr/local/include/glib12/glib.h"
>GIOChannel* g_io_channel_unix_new (int fd);
>gint g_io_channel_unix_get_fd (GIOChannel *channel);
># 2681 "/usr/local/include/glib12/glib.h"
>typedef struct _GMutex GMutex;
>typedef struct _GCond GCond;
>typedef struct _GPrivate GPrivate;
>typedef struct _GStaticPrivate GStaticPrivate;
>typedef struct _GThreadFunctions GThreadFunctions;
>struct _GThreadFunctions
>{
>  GMutex* (*mutex_new) (void);
>  void (*mutex_lock) (GMutex *mutex);
>  gboolean (*mutex_trylock) (GMutex *mutex);
>  void (*mutex_unlock) (GMutex *mutex);
>  void (*mutex_free) (GMutex *mutex);
>  GCond* (*cond_new) (void);
>  void (*cond_signal) (GCond *cond);
>  void (*cond_broadcast) (GCond *cond);
>  void (*cond_wait) (GCond *cond,
>                               GMutex *mutex);
>  gboolean (*cond_timed_wait) (GCond *cond,
>                               GMutex *mutex,
>                               GTimeVal *end_time);
>  void (*cond_free) (GCond *cond);
>  GPrivate* (*private_new) (GDestroyNotify destructor);
>  gpointer (*private_get) (GPrivate *private_key);
>  void (*private_set) (GPrivate *private_key,
>                               gpointer data);
>};
>
>extern GThreadFunctions g_thread_functions_for_glib_use;
>extern gboolean g_thread_use_default_impl;
>extern gboolean g_threads_got_initialized;
>
>
>
>
>
>void g_thread_init (GThreadFunctions *vtable);
>
>
>GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
># 2764 "/usr/local/include/glib12/glib.h"
>struct _GStaticPrivate
>{
>  guint index;
>};
>
>gpointer g_static_private_get (GStaticPrivate *private_key);
>void g_static_private_set (GStaticPrivate *private_key,
>                               gpointer data,
>                               GDestroyNotify notify);
># 2783 "/usr/local/include/glib12/glib.h"
>extern void glib_dummy_decl (void);
># 34 "/usr/X11R6/include/gtk12/gdk/gdktypes.h" 2
># 52 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>typedef gulong GdkAtom;
>typedef struct _GdkColor GdkColor;
>typedef struct _GdkColormap GdkColormap;
>typedef struct _GdkVisual GdkVisual;
>typedef struct _GdkWindowAttr GdkWindowAttr;
>typedef struct _GdkWindow GdkWindow;
>typedef struct _GdkWindow GdkPixmap;
>typedef struct _GdkWindow GdkBitmap;
>typedef struct _GdkWindow GdkDrawable;
>typedef struct _GdkGeometry GdkGeometry;
>typedef struct _GdkImage GdkImage;
>typedef struct _GdkGCValues GdkGCValues;
>typedef struct _GdkGC GdkGC;
>typedef struct _GdkPoint GdkPoint;
>typedef struct _GdkRectangle GdkRectangle;
>typedef struct _GdkSegment GdkSegment;
>typedef struct _GdkFont GdkFont;
>typedef struct _GdkCursor GdkCursor;
>typedef struct _GdkColorContextDither GdkColorContextDither;
>typedef struct _GdkColorContext GdkColorContext;
>typedef struct _GdkDragContext GdkDragContext;
>
>typedef struct _GdkEventAny GdkEventAny;
>typedef struct _GdkEventExpose GdkEventExpose;
>typedef struct _GdkEventNoExpose GdkEventNoExpose;
>typedef struct _GdkEventVisibility GdkEventVisibility;
>typedef struct _GdkEventMotion GdkEventMotion;
>typedef struct _GdkEventButton GdkEventButton;
>typedef struct _GdkEventKey GdkEventKey;
>typedef struct _GdkEventFocus GdkEventFocus;
>typedef struct _GdkEventCrossing GdkEventCrossing;
>typedef struct _GdkEventConfigure GdkEventConfigure;
>typedef struct _GdkEventProperty GdkEventProperty;
>typedef struct _GdkEventSelection GdkEventSelection;
>typedef struct _GdkEventProximity GdkEventProximity;
>typedef struct _GdkEventClient GdkEventClient;
>
>typedef struct _GdkEventDND GdkEventDND;
>
>typedef union _GdkEvent GdkEvent;
>
>typedef struct _GdkDeviceKey GdkDeviceKey;
>typedef struct _GdkDeviceInfo GdkDeviceInfo;
>typedef struct _GdkTimeCoord GdkTimeCoord;
>typedef struct _GdkRegion GdkRegion;
>typedef void (*GdkEventFunc) (GdkEvent *event,
>                              gpointer data);
>
>typedef struct _GdkIC GdkIC;
>typedef struct _GdkICAttr GdkICAttr;
>
>typedef guint32 GdkWChar;
># 126 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>typedef enum
>{
>  GDK_WINDOW_ROOT,
>  GDK_WINDOW_TOPLEVEL,
>  GDK_WINDOW_CHILD,
>  GDK_WINDOW_DIALOG,
>  GDK_WINDOW_TEMP,
>  GDK_WINDOW_PIXMAP,
>  GDK_WINDOW_FOREIGN
>} GdkWindowType;
># 146 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>typedef enum
>{
>  GDK_INPUT_OUTPUT,
>  GDK_INPUT_ONLY
>} GdkWindowClass;
># 162 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>typedef enum
>{
>  GDK_IMAGE_NORMAL,
>  GDK_IMAGE_SHARED,
>  GDK_IMAGE_FASTEST
>} GdkImageType;
># 177 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>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;
>
>
>
>
>
>typedef enum
>{
>  GDK_FONT_FONT,
>  GDK_FONT_FONTSET
>} GdkFontType;
># 205 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>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;
>
>
>
>typedef enum
>{
>  GDK_HINT_POS = 1 << 0,
>  GDK_HINT_MIN_SIZE = 1 << 1,
>  GDK_HINT_MAX_SIZE = 1 << 2,
>  GDK_HINT_BASE_SIZE = 1 << 3,
>  GDK_HINT_ASPECT = 1 << 4,
>  GDK_HINT_RESIZE_INC = 1 << 5
>} GdkWindowHints;
># 247 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>typedef enum
>{
>  GDK_COPY,
>  GDK_INVERT,
>  GDK_XOR,
>  GDK_CLEAR,
>  GDK_AND,
>  GDK_AND_REVERSE,
>  GDK_AND_INVERT,
>  GDK_NOOP,
>  GDK_OR,
>  GDK_EQUIV,
>  GDK_OR_REVERSE,
>  GDK_COPY_INVERT,
>  GDK_OR_INVERT,
>  GDK_NAND,
>  GDK_SET
>} GdkFunction;
>
>
>
>
>
>
>
>typedef enum
>{
>  GDK_SOLID,
>  GDK_TILED,
>  GDK_STIPPLED,
>  GDK_OPAQUE_STIPPLED
>} GdkFill;
>
>
>
>
>
>typedef enum
>{
>  GDK_EVEN_ODD_RULE,
>  GDK_WINDING_RULE
>} GdkFillRule;
>
>
>
>
>
>
>typedef enum
>{
>  GDK_LINE_SOLID,
>  GDK_LINE_ON_OFF_DASH,
>  GDK_LINE_DOUBLE_DASH
>} GdkLineStyle;
>
>
>
>
>
>
>
>typedef enum
>{
>  GDK_CAP_NOT_LAST,
>  GDK_CAP_BUTT,
>  GDK_CAP_ROUND,
>  GDK_CAP_PROJECTING
>} GdkCapStyle;
>
>
>
>
>
>
>typedef enum
>{
>  GDK_JOIN_MITER,
>  GDK_JOIN_ROUND,
>  GDK_JOIN_BEVEL
>} GdkJoinStyle;
>
>
>
>typedef enum
>{
># 1 "/usr/X11R6/include/gtk12/gdk/gdkcursors.h" 1
>GDK_NUM_GLYPHS = 154,
>GDK_X_CURSOR = 0,
>GDK_ARROW = 2,
>GDK_BASED_ARROW_DOWN = 4,
>GDK_BASED_ARROW_UP = 6,
>GDK_BOAT = 8,
>GDK_BOGOSITY = 10,
>GDK_BOTTOM_LEFT_CORNER = 12,
>GDK_BOTTOM_RIGHT_CORNER = 14,
>GDK_BOTTOM_SIDE = 16,
>GDK_BOTTOM_TEE = 18,
>GDK_BOX_SPIRAL = 20,
>GDK_CENTER_PTR = 22,
>GDK_CIRCLE = 24,
>GDK_CLOCK = 26,
>GDK_COFFEE_MUG = 28,
>GDK_CROSS = 30,
>GDK_CROSS_REVERSE = 32,
>GDK_CROSSHAIR = 34,
>GDK_DIAMOND_CROSS = 36,
>GDK_DOT = 38,
>GDK_DOTBOX = 40,
>GDK_DOUBLE_ARROW = 42,
>GDK_DRAFT_LARGE = 44,
>GDK_DRAFT_SMALL = 46,
>GDK_DRAPED_BOX = 48,
>GDK_EXCHANGE = 50,
>GDK_FLEUR = 52,
>GDK_GOBBLER = 54,
>GDK_GUMBY = 56,
>GDK_HAND1 = 58,
>GDK_HAND2 = 60,
>GDK_HEART = 62,
>GDK_ICON = 64,
>GDK_IRON_CROSS = 66,
>GDK_LEFT_PTR = 68,
>GDK_LEFT_SIDE = 70,
>GDK_LEFT_TEE = 72,
>GDK_LEFTBUTTON = 74,
>GDK_LL_ANGLE = 76,
>GDK_LR_ANGLE = 78,
>GDK_MAN = 80,
>GDK_MIDDLEBUTTON = 82,
>GDK_MOUSE = 84,
>GDK_PENCIL = 86,
>GDK_PIRATE = 88,
>GDK_PLUS = 90,
>GDK_QUESTION_ARROW = 92,
>GDK_RIGHT_PTR = 94,
>GDK_RIGHT_SIDE = 96,
>GDK_RIGHT_TEE = 98,
>GDK_RIGHTBUTTON = 100,
>GDK_RTL_LOGO = 102,
>GDK_SAILBOAT = 104,
>GDK_SB_DOWN_ARROW = 106,
>GDK_SB_H_DOUBLE_ARROW = 108,
>GDK_SB_LEFT_ARROW = 110,
>GDK_SB_RIGHT_ARROW = 112,
>GDK_SB_UP_ARROW = 114,
>GDK_SB_V_DOUBLE_ARROW = 116,
>GDK_SHUTTLE = 118,
>GDK_SIZING = 120,
>GDK_SPIDER = 122,
>GDK_SPRAYCAN = 124,
>GDK_STAR = 126,
>GDK_TARGET = 128,
>GDK_TCROSS = 130,
>GDK_TOP_LEFT_ARROW = 132,
>GDK_TOP_LEFT_CORNER = 134,
>GDK_TOP_RIGHT_CORNER = 136,
>GDK_TOP_SIDE = 138,
>GDK_TOP_TEE = 140,
>GDK_TREK = 142,
>GDK_UL_ANGLE = 144,
>GDK_UMBRELLA = 146,
>GDK_UR_ANGLE = 148,
>GDK_WATCH = 150,
>GDK_XTERM = 152,
># 333 "/usr/X11R6/include/gtk12/gdk/gdktypes.h" 2
>  GDK_LAST_CURSOR,
>  GDK_CURSOR_IS_PIXMAP = -1
>} GdkCursorType;
>
>typedef enum {
>  GDK_FILTER_CONTINUE,
>  GDK_FILTER_TRANSLATE,
>  GDK_FILTER_REMOVE
>} GdkFilterReturn;
>
>typedef enum {
>  GDK_VISIBILITY_UNOBSCURED,
>  GDK_VISIBILITY_PARTIAL,
>  GDK_VISIBILITY_FULLY_OBSCURED
>} GdkVisibilityState;
># 371 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>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_ENTER = 22,
>  GDK_DRAG_LEAVE = 23,
>  GDK_DRAG_MOTION = 24,
>  GDK_DRAG_STATUS = 25,
>  GDK_DROP_START = 26,
>  GDK_DROP_FINISHED = 27,
>  GDK_CLIENT_EVENT = 28,
>  GDK_VISIBILITY_NOTIFY = 29,
>  GDK_NO_EXPOSE = 30
>} GdkEventType;
>
>
>
>
>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;
># 443 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>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;
>
>
>
>
>
>
>typedef enum
>{
>  GDK_CROSSING_NORMAL,
>  GDK_CROSSING_GRAB,
>  GDK_CROSSING_UNGRAB
>} GdkCrossingMode;
>
>
>
>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_RELEASE_MASK = 1 << 13,
>  GDK_MODIFIER_MASK = 0x3fff
>} GdkModifierType;
>
>typedef enum
>{
>  GDK_CLIP_BY_CHILDREN = 0,
>  GDK_INCLUDE_INFERIORS = 1
>} GdkSubwindowMode;
>
>typedef enum
>{
>  GDK_INPUT_READ = 1 << 0,
>  GDK_INPUT_WRITE = 1 << 1,
>  GDK_INPUT_EXCEPTION = 1 << 2
>} GdkInputCondition;
>
>typedef enum
>{
>  GDK_OK = 0,
>  GDK_ERROR = -1,
>  GDK_ERROR_PARAM = -2,
>  GDK_ERROR_FILE = -3,
>  GDK_ERROR_MEM = -4
>} GdkStatus;
>
>typedef enum
>{
>  GDK_LSB_FIRST,
>  GDK_MSB_FIRST
>} 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;
>
>typedef enum
>{
>  GDK_SELECTION_PRIMARY = 1,
>  GDK_SELECTION_SECONDARY = 2
>} GdkSelection;
>
>typedef enum
>{
>  GDK_PROPERTY_NEW_VALUE,
>  GDK_PROPERTY_DELETE
>} GdkPropertyState;
>
>typedef enum
>{
>  GDK_PROP_MODE_REPLACE,
>  GDK_PROP_MODE_PREPEND,
>  GDK_PROP_MODE_APPEND
>} GdkPropMode;
>
>
>
>typedef enum
>{
>  GDK_SOURCE_MOUSE,
>  GDK_SOURCE_PEN,
>  GDK_SOURCE_ERASER,
>  GDK_SOURCE_CURSOR
>} GdkInputSource;
>
>typedef enum
>{
>  GDK_MODE_DISABLED,
>  GDK_MODE_SCREEN,
>  GDK_MODE_WINDOW
>} 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;
>
>
>
>
>typedef enum
>{
>  GDK_TARGET_BITMAP = 5,
>  GDK_TARGET_COLORMAP = 7,
>  GDK_TARGET_DRAWABLE = 17,
>  GDK_TARGET_PIXMAP = 20,
>  GDK_TARGET_STRING = 31
>} GdkTarget;
>
>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;
>
>typedef enum
>{
>  GDK_IM_PREEDIT_AREA = 0x0001,
>  GDK_IM_PREEDIT_CALLBACKS = 0x0002,
>  GDK_IM_PREEDIT_POSITION = 0x0004,
>  GDK_IM_PREEDIT_NOTHING = 0x0008,
>  GDK_IM_PREEDIT_NONE = 0x0010,
>  GDK_IM_PREEDIT_MASK = 0x001f,
>
>  GDK_IM_STATUS_AREA = 0x0100,
>  GDK_IM_STATUS_CALLBACKS = 0x0200,
>  GDK_IM_STATUS_NOTHING = 0x0400,
>  GDK_IM_STATUS_NONE = 0x0800,
>  GDK_IM_STATUS_MASK = 0x0f00
>} GdkIMStyle;
>
>typedef enum
>{
>  GDK_IC_STYLE = 1 << 0,
>  GDK_IC_CLIENT_WINDOW = 1 << 1,
>  GDK_IC_FOCUS_WINDOW = 1 << 2,
>  GDK_IC_FILTER_EVENTS = 1 << 3,
>  GDK_IC_SPOT_LOCATION = 1 << 4,
>  GDK_IC_LINE_SPACING = 1 << 5,
>  GDK_IC_CURSOR = 1 << 6,
>
>  GDK_IC_PREEDIT_FONTSET = 1 << 10,
>  GDK_IC_PREEDIT_AREA = 1 << 11,
>  GDK_IC_PREEDIT_AREA_NEEDED = 1 << 12,
>  GDK_IC_PREEDIT_FOREGROUND = 1 << 13,
>  GDK_IC_PREEDIT_BACKGROUND = 1 << 14,
>  GDK_IC_PREEDIT_PIXMAP = 1 << 15,
>  GDK_IC_PREEDIT_COLORMAP = 1 << 16,
>
>  GDK_IC_STATUS_FONTSET = 1 << 21,
>  GDK_IC_STATUS_AREA = 1 << 22,
>  GDK_IC_STATUS_AREA_NEEDED = 1 << 23,
>  GDK_IC_STATUS_FOREGROUND = 1 << 24,
>  GDK_IC_STATUS_BACKGROUND = 1 << 25,
>  GDK_IC_STATUS_PIXMAP = 1 << 26,
>  GDK_IC_STATUS_COLORMAP = 1 << 27,
>
>  GDK_IC_ALL_REQ = GDK_IC_STYLE |
>                                  GDK_IC_CLIENT_WINDOW,
>
>  GDK_IC_PREEDIT_AREA_REQ = GDK_IC_PREEDIT_AREA |
>                                  GDK_IC_PREEDIT_FONTSET,
>  GDK_IC_PREEDIT_POSITION_REQ = GDK_IC_PREEDIT_AREA | GDK_IC_SPOT_LOCATION |
>                                  GDK_IC_PREEDIT_FONTSET,
>
>  GDK_IC_STATUS_AREA_REQ = GDK_IC_STATUS_AREA |
>                                  GDK_IC_STATUS_FONTSET
>} GdkICAttributesType;
>
>
>
>
>
>
>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;
>
>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;
>
>typedef void (*GdkInputFunction) (gpointer data,
>                                  gint source,
>                                  GdkInputCondition condition);
>
>typedef void (*GdkDestroyNotify) (gpointer data);
># 710 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>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;
>
>
>
>
>
>
>
>typedef enum
>{
>  GDK_OVERLAP_RECTANGLE_IN,
>  GDK_OVERLAP_RECTANGLE_OUT,
>  GDK_OVERLAP_RECTANGLE_PART
>} GdkOverlapType;
>
>typedef enum {
>  GDK_ACTION_DEFAULT = 1 << 0,
>  GDK_ACTION_COPY = 1 << 1,
>  GDK_ACTION_MOVE = 1 << 2,
>  GDK_ACTION_LINK = 1 << 3,
>  GDK_ACTION_PRIVATE = 1 << 4,
>  GDK_ACTION_ASK = 1 << 5
>} GdkDragAction;
>
>typedef enum {
>  GDK_DRAG_PROTO_MOTIF,
>  GDK_DRAG_PROTO_XDND,
>  GDK_DRAG_PROTO_ROOTWIN,
>
>  GDK_DRAG_PROTO_NONE
>} GdkDragProtocol;
># 757 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>struct _GdkColor
>{
>  gulong pixel;
>  gushort red;
>  gushort green;
>  gushort blue;
>};
>
>
>
>
>struct _GdkColormap
>{
>  gint size;
>  GdkColor *colors;
>};
># 786 "/usr/X11R6/include/gtk12/gdk/gdktypes.h"
>struct _GdkVisual
>{
>  GdkVisualType type;
>  gint depth;
>  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;
>};
>
>struct _GdkWindowAttr
>{
>  gchar *title;
>  gint event_mask;
>  gint16 x, y;
>  gint16 width;
>  gint16 height;
>  GdkWindowClass wclass;
>  GdkVisual *visual;
>  GdkColormap *colormap;
>  GdkWindowType window_type;
>  GdkCursor *cursor;
>  gchar *wmclass_name;
>  gchar *wmclass_class;
>  gboolean override_redirect;
>};
>
>struct _GdkWindow
>{
>  gpointer user_data;
>};
>
>struct _GdkGeometry {
>  gint min_width;
>  gint min_height;
>  gint max_width;
>  gint max_height;
>  gint base_width;
>  gint base_height;
>  gint width_inc;
>  gint height_inc;
>  gdouble min_aspect;
>  gdouble max_aspect;
>
>};
>
>struct _GdkImage
>{
>  GdkImageType type;
>  GdkVisual *visual;
>  GdkByteOrder byte_order;
>  guint16 width;
>  guint16 height;
>  guint16 depth;
>  guint16 bpp;
>  guint16 bpl;
>  gpointer mem;
>};
>
>struct _GdkGCValues
>{
>  GdkColor foreground;
>  GdkColor background;
>  GdkFont *font;
>  GdkFunction function;
>  GdkFill fill;
>  GdkPixmap *tile;
>  GdkPixmap *stipple;
>  GdkPixmap *clip_mask;
>  GdkSubwindowMode subwindow_mode;
>  gint ts_x_origin;
>  gint ts_y_origin;
>  gint clip_x_origin;
>  gint clip_y_origin;
>  gint graphics_exposures;
>  gint line_width;
>  GdkLineStyle line_style;
>  GdkCapStyle cap_style;
>  GdkJoinStyle join_style;
>};
>
>struct _GdkGC
>{
>  gint dummy_var;
>};
>
>struct _GdkPoint
>{
>  gint16 x;
>  gint16 y;
>};
>
>struct _GdkRectangle
>{
>  gint16 x;
>  gint16 y;
>  guint16 width;
>  guint16 height;
>};
>
>struct _GdkSegment
>{
>  gint16 x1;
>  gint16 y1;
>  gint16 x2;
>  gint16 y2;
>};
>
>struct _GdkFont
>{
>  GdkFontType type;
>  gint ascent;
>  gint descent;
>};
>
>struct _GdkCursor
>{
>  GdkCursorType type;
>};
>
>
>struct _GdkColorContextDither
>{
>  gint fast_rgb[32][32][32];
>  gint fast_err[32][32][32];
>  gint fast_erg[32][32][32];
>  gint fast_erb[32][32][32];
>};
>
>struct _GdkColorContext
>{
>  GdkVisual *visual;
>  GdkColormap *colormap;
>
>  gint num_colors;
>  gint max_colors;
>  gint num_allocated;
>
>  GdkColorContextMode mode;
>  gint need_to_free_colormap;
>  GdkAtom std_cmap_atom;
>
>  gulong *clut;
>  GdkColor *cmap;
>
>  GHashTable *color_hash;
>  GdkColor *palette;
>  gint num_palette;
>
>  GdkColorContextDither *fast_dither;
>
>  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;
>};
>
>
>
>struct _GdkDeviceKey
>{
>  guint keyval;
>  GdkModifierType modifiers;
>};
>
>struct _GdkDeviceInfo
>{
>  guint32 deviceid;
>  gchar *name;
>  GdkInputSource source;
>  GdkInputMode mode;
>  gint has_cursor;
>  gint num_axes;
>  GdkAxisUse *axes;
>  gint num_keys;
>  GdkDeviceKey *keys;
>};
>
>struct _GdkTimeCoord
>{
>  guint32 time;
>  gdouble x;
>  gdouble y;
>  gdouble pressure;
>  gdouble xtilt;
>  gdouble ytilt;
>};
>
>
>
>
>struct _GdkDragContext {
>  GdkDragProtocol protocol;
>
>  gboolean is_source;
>
>  GdkWindow *source_window;
>  GdkWindow *dest_window;
>
>  GList *targets;
>  GdkDragAction actions;
>  GdkDragAction suggested_action;
>  GdkDragAction action;
>
>  guint32 start_time;
>};
>
>
>
>typedef void GdkXEvent;
>
>typedef GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent,
>                                          GdkEvent *event,
>                                          gpointer data);
>
>struct _GdkEventAny
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>};
>
>struct _GdkEventExpose
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkRectangle area;
>  gint count;
>};
>
>struct _GdkEventNoExpose
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>
>};
>
>struct _GdkEventVisibility
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkVisibilityState state;
>};
>
>struct _GdkEventMotion
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  guint32 time;
>  gdouble x;
>  gdouble y;
>  gdouble pressure;
>  gdouble xtilt;
>  gdouble ytilt;
>  guint state;
>  gint16 is_hint;
>  GdkInputSource source;
>  guint32 deviceid;
>  gdouble x_root, y_root;
>};
>
>struct _GdkEventButton
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  guint32 time;
>  gdouble x;
>  gdouble y;
>  gdouble pressure;
>  gdouble xtilt;
>  gdouble ytilt;
>  guint state;
>  guint button;
>  GdkInputSource source;
>  guint32 deviceid;
>  gdouble x_root, y_root;
>};
>
>struct _GdkEventKey
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  guint32 time;
>  guint state;
>  guint keyval;
>  gint length;
>  gchar *string;
>};
>
>struct _GdkEventCrossing
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkWindow *subwindow;
>  guint32 time;
>  gdouble x;
>  gdouble y;
>  gdouble x_root;
>  gdouble y_root;
>  GdkCrossingMode mode;
>  GdkNotifyType detail;
>  gboolean focus;
>  guint state;
>};
>
>struct _GdkEventFocus
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  gint16 in;
>};
>
>struct _GdkEventConfigure
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  gint16 x, y;
>  gint16 width;
>  gint16 height;
>};
>
>struct _GdkEventProperty
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkAtom atom;
>  guint32 time;
>  guint state;
>};
>
>struct _GdkEventSelection
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkAtom selection;
>  GdkAtom target;
>  GdkAtom property;
>  guint32 requestor;
>  guint32 time;
>};
>
>
>
>
>struct _GdkEventProximity
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  guint32 time;
>  GdkInputSource source;
>  guint32 deviceid;
>};
>
>struct _GdkEventClient
>{
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkAtom message_type;
>  gushort data_format;
>  union {
>    char b[20];
>    short s[10];
>    long l[5];
>  } data;
>};
>
>
>
>struct _GdkEventDND {
>  GdkEventType type;
>  GdkWindow *window;
>  gint8 send_event;
>  GdkDragContext *context;
>
>  guint32 time;
>  gshort x_root, y_root;
>};
>
>union _GdkEvent
>{
>  GdkEventType type;
>  GdkEventAny any;
>  GdkEventExpose expose;
>  GdkEventNoExpose no_expose;
>  GdkEventVisibility visibility;
>  GdkEventMotion motion;
>  GdkEventButton button;
>  GdkEventKey key;
>  GdkEventCrossing crossing;
>  GdkEventFocus focus_change;
>  GdkEventConfigure configure;
>  GdkEventProperty property;
>  GdkEventSelection selection;
>  GdkEventProximity proximity;
>  GdkEventClient client;
>  GdkEventDND dnd;
>};
>
>struct _GdkRegion
>{
>  gpointer user_data;
>};
>
>struct _GdkICAttr
>{
>  GdkIMStyle style;
>  GdkWindow *client_window;
>  GdkWindow *focus_window;
>  GdkEventMask filter_events;
>  GdkPoint spot_location;
>  gint line_spacing;
>  GdkCursor *cursor;
>
>  GdkFont *preedit_fontset;
>  GdkRectangle preedit_area;
>  GdkRectangle preedit_area_needed;
>  GdkColor preedit_foreground;
>  GdkColor preedit_background;
>  GdkPixmap *preedit_pixmap;
>  GdkColormap *preedit_colormap;
>
>  GdkFont *status_fontset;
>  GdkRectangle status_area;
>  GdkRectangle status_area_needed;
>  GdkColor status_foreground;
>  GdkColor status_background;
>  GdkPixmap *status_pixmap;
>  GdkColormap *status_colormap;
>};
># 32 "/usr/X11R6/include/gtk12/gdk/gdk.h" 2
># 41 "/usr/X11R6/include/gtk12/gdk/gdk.h"
>void gdk_init (gint *argc,
>                                         gchar ***argv);
>gboolean gdk_init_check (gint *argc,
>                                         gchar ***argv);
>void gdk_exit (gint error_code);
>gchar* gdk_set_locale (void);
>
>
>
>void gdk_error_trap_push (void);
>gint gdk_error_trap_pop (void);
>
>
>gboolean gdk_events_pending (void);
>GdkEvent* gdk_event_get (void);
>
>GdkEvent* gdk_event_peek (void);
>GdkEvent* gdk_event_get_graphics_expose (GdkWindow *window);
>void gdk_event_put (GdkEvent *event);
>
>GdkEvent* gdk_event_copy (GdkEvent *event);
>void gdk_event_free (GdkEvent *event);
>guint32 gdk_event_get_time (GdkEvent *event);
>
>void gdk_event_handler_set (GdkEventFunc func,
>                                         gpointer data,
>                                         GDestroyNotify notify);
>
>void gdk_set_show_events (gboolean show_events);
>void gdk_set_use_xshm (gboolean use_xshm);
>
>gboolean gdk_get_show_events (void);
>gboolean gdk_get_use_xshm (void);
>gchar* gdk_get_display (void);
>
>guint32 gdk_time_get (void);
>guint32 gdk_timer_get (void);
>void gdk_timer_set (guint32 milliseconds);
>void gdk_timer_enable (void);
>void gdk_timer_disable (void);
>
>gint gdk_input_add_full (gint source,
>                           GdkInputCondition condition,
>                           GdkInputFunction function,
>                           gpointer data,
>                           GdkDestroyNotify destroy);
>gint gdk_input_add (gint source,
>                           GdkInputCondition condition,
>                           GdkInputFunction function,
>                           gpointer data);
>void gdk_input_remove (gint tag);
>
>gint gdk_pointer_grab (GdkWindow *window,
>                                 gint owner_events,
>                                 GdkEventMask event_mask,
>                                 GdkWindow *confine_to,
>                                 GdkCursor *cursor,
>                                 guint32 time);
>void gdk_pointer_ungrab (guint32 time);
>gint gdk_keyboard_grab (GdkWindow *window,
>                                 gboolean owner_events,
>                                 guint32 time);
>void gdk_keyboard_ungrab (guint32 time);
>gboolean gdk_pointer_is_grabbed (void);
>
>
>gint gdk_screen_width (void);
>gint gdk_screen_height (void);
>
>gint gdk_screen_width_mm (void);
>gint gdk_screen_height_mm (void);
>
>void gdk_flush (void);
>void gdk_beep (void);
>
>void gdk_key_repeat_disable (void);
>void gdk_key_repeat_restore (void);
>
>
>
>
>gint gdk_visual_get_best_depth (void);
>GdkVisualType gdk_visual_get_best_type (void);
>GdkVisual* gdk_visual_get_system (void);
>GdkVisual* gdk_visual_get_best (void);
>GdkVisual* gdk_visual_get_best_with_depth (gint depth);
>GdkVisual* gdk_visual_get_best_with_type (GdkVisualType visual_type);
>GdkVisual* gdk_visual_get_best_with_both (gint depth,
>                                              GdkVisualType visual_type);
>
>
>GdkVisual* gdk_visual_ref (GdkVisual *visual);
>void gdk_visual_unref (GdkVisual *visual);
>
>void gdk_query_depths (gint **depths,
>                             gint *count);
>void gdk_query_visual_types (GdkVisualType **visual_types,
>                             gint *count);
>
>GList* gdk_list_visuals (void);
>
>
>
>
>GdkWindow* gdk_window_new (GdkWindow *parent,
>                                      GdkWindowAttr *attributes,
>                                      gint attributes_mask);
>
>void gdk_window_destroy (GdkWindow *window);
>GdkWindow* gdk_window_ref (GdkWindow *window);
>void gdk_window_unref (GdkWindow *window);
>
>GdkWindow* gdk_window_at_pointer (gint *win_x,
>                                      gint *win_y);
>void gdk_window_show (GdkWindow *window);
>void gdk_window_hide (GdkWindow *window);
>void gdk_window_withdraw (GdkWindow *window);
>void gdk_window_move (GdkWindow *window,
>                                      gint x,
>                                      gint y);
>void gdk_window_resize (GdkWindow *window,
>                                      gint width,
>                                      gint height);
>void gdk_window_move_resize (GdkWindow *window,
>                                      gint x,
>                                      gint y,
>                                      gint width,
>                                      gint height);
>void gdk_window_reparent (GdkWindow *window,
>                                      GdkWindow *new_parent,
>                                      gint x,
>                                      gint y);
>void gdk_window_clear (GdkWindow *window);
>void gdk_window_clear_area (GdkWindow *window,
>                                      gint x,
>                                      gint y,
>                                      gint width,
>                                      gint height);
>void gdk_window_clear_area_e(GdkWindow *window,
>                                      gint x,
>                                      gint y,
>                                      gint width,
>                                      gint height);
>void gdk_window_copy_area (GdkWindow *window,
>                                      GdkGC *gc,
>                                      gint x,
>                                      gint y,
>                                      GdkWindow *source_window,
>                                      gint source_x,
>                                      gint source_y,
>                                      gint width,
>                                      gint height);
>void gdk_window_raise (GdkWindow *window);
>void gdk_window_lower (GdkWindow *window);
>
>void gdk_window_set_user_data (GdkWindow *window,
>                                          gpointer user_data);
>void gdk_window_set_override_redirect(GdkWindow *window,
>                                               gboolean override_redirect);
>
>void gdk_window_add_filter (GdkWindow *window,
>                                         GdkFilterFunc function,
>                                         gpointer data);
>void gdk_window_remove_filter (GdkWindow *window,
>                                         GdkFilterFunc function,
>                                         gpointer data);
>
>
>
>
>
>
>
>void gdk_window_shape_combine_mask (GdkWindow *window,
>                                    GdkBitmap *shape_mask,
>                                    gint offset_x,
>                                    gint offset_y);
>
>
>
>
>
>
>
>void gdk_window_set_child_shapes (GdkWindow *window);
># 234 "/usr/X11R6/include/gtk12/gdk/gdk.h"
>void gdk_window_merge_child_shapes (GdkWindow *window);
>
>
>
>
>
>
>
>gboolean gdk_window_is_visible (GdkWindow *window);
>gboolean gdk_window_is_viewable (GdkWindow *window);
>
>
>
>
>gboolean gdk_window_set_static_gravities (GdkWindow *window,
>                                          gboolean use_static);
>
>
>
>
>void gdk_add_client_message_filter (GdkAtom message_type,
>                                    GdkFilterFunc func,
>                                    gpointer data);
>
>
>
>GdkDragContext * gdk_drag_context_new (void);
>void gdk_drag_context_ref (GdkDragContext *context);
>void gdk_drag_context_unref (GdkDragContext *context);
>
>
>
>void gdk_drag_status (GdkDragContext *context,
>                                         GdkDragAction action,
>                                         guint32 time);
>void gdk_drop_reply (GdkDragContext *context,
>                                         gboolean ok,
>                                         guint32 time);
>void gdk_drop_finish (GdkDragContext *context,
>                                         gboolean success,
>                                         guint32 time);
>GdkAtom gdk_drag_get_selection (GdkDragContext *context);
>
>
>
>GdkDragContext * gdk_drag_begin (GdkWindow *window,
>                                      GList *targets);
>guint32 gdk_drag_get_protocol (guint32 xid,
>                                       GdkDragProtocol *protocol);
>void gdk_drag_find_window (GdkDragContext *context,
>                                       GdkWindow *drag_window,
>                                       gint x_root,
>                                       gint y_root,
>                                       GdkWindow **dest_window,
>                                       GdkDragProtocol *protocol);
>gboolean gdk_drag_motion (GdkDragContext *context,
>                                      GdkWindow *dest_window,
>                                      GdkDragProtocol protocol,
>                                      gint x_root,
>                                      gint y_root,
>                                      GdkDragAction suggested_action,
>                                      GdkDragAction possible_actions,
>                                      guint32 time);
>void gdk_drag_drop (GdkDragContext *context,
>                                      guint32 time);
>void gdk_drag_abort (GdkDragContext *context,
>                                      guint32 time);
>
>
>
>void gdk_window_set_hints (GdkWindow *window,
>                                          gint x,
>                                          gint y,
>                                          gint min_width,
>                                          gint min_height,
>                                          gint max_width,
>                                          gint max_height,
>                                          gint flags);
>void gdk_window_set_geometry_hints (GdkWindow *window,
>                                             GdkGeometry *geometry,
>                                             GdkWindowHints flags);
>void gdk_set_sm_client_id (const gchar *sm_client_id);
>
>
>void gdk_window_set_title (GdkWindow *window,
>                                            const gchar *title);
>void gdk_window_set_role (GdkWindow *window,
>                                            const gchar *role);
>void gdk_window_set_transient_for (GdkWindow *window,
>                                            GdkWindow *leader);
>void gdk_window_set_background (GdkWindow *window,
>                                          GdkColor *color);
>void gdk_window_set_back_pixmap (GdkWindow *window,
>                                          GdkPixmap *pixmap,
>                                          gboolean parent_relative);
>void gdk_window_set_cursor (GdkWindow *window,
>                                          GdkCursor *cursor);
>void gdk_window_set_colormap (GdkWindow *window,
>                                          GdkColormap *colormap);
>void gdk_window_get_user_data (GdkWindow *window,
>                                          gpointer *data);
>void gdk_window_get_geometry (GdkWindow *window,
>                                          gint *x,
>                                          gint *y,
>                                          gint *width,
>                                          gint *height,
>                                          gint *depth);
>void gdk_window_get_position (GdkWindow *window,
>                                          gint *x,
>                                          gint *y);
>void gdk_window_get_size (GdkWindow *window,
>                                          gint *width,
>                                          gint *height);
>GdkVisual* gdk_window_get_visual (GdkWindow *window);
>GdkColormap* gdk_window_get_colormap (GdkWindow *window);
>GdkWindowType gdk_window_get_type (GdkWindow *window);
>gint gdk_window_get_origin (GdkWindow *window,
>                                          gint *x,
>                                          gint *y);
>gboolean gdk_window_get_deskrelative_origin (GdkWindow *window,
>                                          gint *x,
>                                          gint *y);
>void gdk_window_get_root_origin (GdkWindow *window,
>                                          gint *x,
>                                          gint *y);
>GdkWindow* gdk_window_get_pointer (GdkWindow *window,
>                                          gint *x,
>                                          gint *y,
>                                          GdkModifierType *mask);
>GdkWindow* gdk_window_get_parent (GdkWindow *window);
>GdkWindow* gdk_window_get_toplevel (GdkWindow *window);
>GList* gdk_window_get_children (GdkWindow *window);
>GdkEventMask gdk_window_get_events (GdkWindow *window);
>void gdk_window_set_events (GdkWindow *window,
>                                          GdkEventMask event_mask);
>
>void gdk_window_set_icon (GdkWindow *window,
>                                          GdkWindow *icon_window,
>                                          GdkPixmap *pixmap,
>                                          GdkBitmap *mask);
>void gdk_window_set_icon_name (GdkWindow *window,
>                                          const gchar *name);
>void gdk_window_set_group (GdkWindow *window,
>                                          GdkWindow *leader);
>void gdk_window_set_decorations (GdkWindow *window,
>                                          GdkWMDecoration decorations);
>void gdk_window_set_functions (GdkWindow *window,
>                                          GdkWMFunction functions);
>GList * gdk_window_get_toplevels (void);
>
>void gdk_window_register_dnd (GdkWindow *window);
>
>void gdk_drawable_set_data (GdkDrawable *drawable,
>                                          const gchar *key,
>                                          gpointer data,
>                                          GDestroyNotify destroy_func);
>
>
>
>
>GdkCursor* gdk_cursor_new (GdkCursorType cursor_type);
>GdkCursor* gdk_cursor_new_from_pixmap (GdkPixmap *source,
>                                          GdkPixmap *mask,
>                                          GdkColor *fg,
>                                          GdkColor *bg,
>                                          gint x,
>                                          gint y);
>void gdk_cursor_destroy (GdkCursor *cursor);
>
>
>
>
>GdkGC* gdk_gc_new (GdkWindow *window);
>GdkGC* gdk_gc_new_with_values (GdkWindow *window,
>                                   GdkGCValues *values,
>                                   GdkGCValuesMask values_mask);
>GdkGC* gdk_gc_ref (GdkGC *gc);
>void gdk_gc_unref (GdkGC *gc);
>void gdk_gc_destroy (GdkGC *gc);
>void gdk_gc_get_values (GdkGC *gc,
>                                   GdkGCValues *values);
>void gdk_gc_set_foreground (GdkGC *gc,
>                                   GdkColor *color);
>void gdk_gc_set_background (GdkGC *gc,
>                                   GdkColor *color);
>void gdk_gc_set_font (GdkGC *gc,
>                                   GdkFont *font);
>void gdk_gc_set_function (GdkGC *gc,
>                                   GdkFunction function);
>void gdk_gc_set_fill (GdkGC *gc,
>                                   GdkFill fill);
>void gdk_gc_set_tile (GdkGC *gc,
>                                   GdkPixmap *tile);
>void gdk_gc_set_stipple (GdkGC *gc,
>                                   GdkPixmap *stipple);
>void gdk_gc_set_ts_origin (GdkGC *gc,
>                                   gint x,
>                                   gint y);
>void gdk_gc_set_clip_origin (GdkGC *gc,
>                                   gint x,
>                                   gint y);
>void gdk_gc_set_clip_mask (GdkGC *gc,
>                                   GdkBitmap *mask);
>void gdk_gc_set_clip_rectangle (GdkGC *gc,
>                                   GdkRectangle *rectangle);
>void gdk_gc_set_clip_region (GdkGC *gc,
>                                   GdkRegion *region);
>void gdk_gc_set_subwindow (GdkGC *gc,
>                                   GdkSubwindowMode mode);
>void gdk_gc_set_exposures (GdkGC *gc,
>                                   gboolean exposures);
>void gdk_gc_set_line_attributes (GdkGC *gc,
>                                   gint line_width,
>                                   GdkLineStyle line_style,
>                                   GdkCapStyle cap_style,
>                                   GdkJoinStyle join_style);
>void gdk_gc_set_dashes (GdkGC *gc,
>                                   gint dash_offset,
>                                   gint8 dash_list[],
>                                   gint n);
>void gdk_gc_copy (GdkGC *dst_gc,
>                                   GdkGC *src_gc);
>
>
>
>
>GdkPixmap* gdk_pixmap_new (GdkWindow *window,
>                                         gint width,
>                                         gint height,
>                                         gint depth);
>GdkBitmap* gdk_bitmap_create_from_data (GdkWindow *window,
>                                         const gchar *data,
>                                         gint width,
>                                         gint height);
>GdkPixmap* gdk_pixmap_create_from_data (GdkWindow *window,
>                                         const gchar *data,
>                                         gint width,
>                                         gint height,
>                                         gint depth,
>                                         GdkColor *fg,
>                                         GdkColor *bg);
>GdkPixmap* gdk_pixmap_create_from_xpm (GdkWindow *window,
>                                         GdkBitmap **mask,
>                                         GdkColor *transparent_color,
>                                         const gchar *filename);
>GdkPixmap* gdk_pixmap_colormap_create_from_xpm (
>                                         GdkWindow *window,
>                                         GdkColormap *colormap,
>                                         GdkBitmap **mask,
>                                         GdkColor *transparent_color,
>                                         const gchar *filename);
>GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow *window,
>                                         GdkBitmap **mask,
>                                         GdkColor *transparent_color,
>                                         gchar **data);
>GdkPixmap* gdk_pixmap_colormap_create_from_xpm_d (
>                                         GdkWindow *window,
>                                         GdkColormap *colormap,
>                                         GdkBitmap **mask,
>                                         GdkColor *transparent_color,
>                                         gchar **data);
>GdkPixmap *gdk_pixmap_ref (GdkPixmap *pixmap);
>void gdk_pixmap_unref (GdkPixmap *pixmap);
>
>GdkBitmap *gdk_bitmap_ref (GdkBitmap *pixmap);
>void gdk_bitmap_unref (GdkBitmap *pixmap);
>
>
>
>
>GdkImage* gdk_image_new_bitmap(GdkVisual *visual,
>                                gpointer data,
>                                gint width,
>                                gint height);
>GdkImage* gdk_image_new (GdkImageType type,
>                                GdkVisual *visual,
>                                gint width,
>                                gint height);
>GdkImage* gdk_image_get (GdkWindow *window,
>                                gint x,
>                                gint y,
>                                gint width,
>                                gint height);
>void gdk_image_put_pixel (GdkImage *image,
>                                gint x,
>                                gint y,
>                                guint32 pixel);
>guint32 gdk_image_get_pixel (GdkImage *image,
>                                gint x,
>                                gint y);
>void gdk_image_destroy (GdkImage *image);
>
>
>
>
>GdkColormap* gdk_colormap_new (GdkVisual *visual,
>                                           gboolean allocate);
>GdkColormap* gdk_colormap_ref (GdkColormap *cmap);
>void gdk_colormap_unref (GdkColormap *cmap);
>
>GdkColormap* gdk_colormap_get_system (void);
>gint gdk_colormap_get_system_size (void);
>
>void gdk_colormap_change (GdkColormap *colormap,
>                                           gint ncolors);
>
>void gdk_colormap_sync (GdkColormap *colormap,
>                                           gboolean force);
>gint gdk_colormap_alloc_colors (GdkColormap *colormap,
>                                           GdkColor *colors,
>                                           gint ncolors,
>                                           gboolean writeable,
>                                           gboolean best_match,
>                                           gboolean *success);
>gboolean gdk_colormap_alloc_color (GdkColormap *colormap,
>                                           GdkColor *color,
>                                           gboolean writeable,
>                                           gboolean best_match);
>void gdk_colormap_free_colors (GdkColormap *colormap,
>                                           GdkColor *colors,
>                                           gint ncolors);
>
>GdkVisual* gdk_colormap_get_visual (GdkColormap *colormap);
>
>GdkColor* gdk_color_copy (const GdkColor *color);
>void gdk_color_free (GdkColor *color);
>
>gboolean gdk_color_parse (const gchar *spec,
>                                           GdkColor *color);
>guint gdk_color_hash (const GdkColor *colora,
>                                           const GdkColor *colorb);
>gboolean gdk_color_equal (const GdkColor *colora,
>                                           const GdkColor *colorb);
>
>
>
>void gdk_colors_store (GdkColormap *colormap,
>                           GdkColor *colors,
>                           gint ncolors);
>gboolean gdk_colors_alloc (GdkColormap *colormap,
>                           gboolean contiguous,
>                           gulong *planes,
>                           gint nplanes,
>                           gulong *pixels,
>                           gint npixels);
>void gdk_colors_free (GdkColormap *colormap,
>                           gulong *pixels,
>                           gint npixels,
>                           gulong planes);
>gboolean gdk_color_white (GdkColormap *colormap,
>                           GdkColor *color);
>gboolean gdk_color_black (GdkColormap *colormap,
>                           GdkColor *color);
>gboolean gdk_color_alloc (GdkColormap *colormap,
>                           GdkColor *color);
>gboolean gdk_color_change (GdkColormap *colormap,
>                           GdkColor *color);
>
>
>
>
>GdkFont* gdk_font_load (const gchar *font_name);
>GdkFont* gdk_fontset_load (const gchar *fontset_name);
>GdkFont* gdk_font_ref (GdkFont *font);
>void gdk_font_unref (GdkFont *font);
>gint gdk_font_id (const GdkFont *font);
>gboolean gdk_font_equal (const GdkFont *fonta,
>                             const GdkFont *fontb);
>gint gdk_string_width (GdkFont *font,
>                             const gchar *string);
>gint gdk_text_width (GdkFont *font,
>                             const gchar *text,
>                             gint text_length);
>gint gdk_text_width_wc (GdkFont *font,
>                             const GdkWChar *text,
>                             gint text_length);
>gint gdk_char_width (GdkFont *font,
>                             gchar character);
>gint gdk_char_width_wc (GdkFont *font,
>                             GdkWChar character);
>gint gdk_string_measure (GdkFont *font,
>                             const gchar *string);
>gint gdk_text_measure (GdkFont *font,
>                             const gchar *text,
>                             gint text_length);
>gint gdk_char_measure (GdkFont *font,
>                             gchar character);
>gint gdk_string_height (GdkFont *font,
>                             const gchar *string);
>gint gdk_text_height (GdkFont *font,
>                             const gchar *text,
>                             gint text_length);
>gint gdk_char_height (GdkFont *font,
>                             gchar character);
>
>void gdk_text_extents (GdkFont *font,
>                             const gchar *text,
>                             gint text_length,
>                             gint *lbearing,
>                             gint *rbearing,
>                             gint *width,
>                             gint *ascent,
>                             gint *descent);
>void gdk_text_extents_wc (GdkFont *font,
>                             const GdkWChar *text,
>                             gint text_length,
>                             gint *lbearing,
>                             gint *rbearing,
>                             gint *width,
>                             gint *ascent,
>                             gint *descent);
>void gdk_string_extents (GdkFont *font,
>                             const gchar *string,
>                             gint *lbearing,
>                             gint *rbearing,
>                             gint *width,
>                             gint *ascent,
>                             gint *descent);
>
>
>
>void gdk_draw_point (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          gint x,
>                          gint y);
>void gdk_draw_line (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          gint x1,
>                          gint y1,
>                          gint x2,
>                          gint y2);
>void gdk_draw_rectangle (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          gint filled,
>                          gint x,
>                          gint y,
>                          gint width,
>                          gint height);
>void gdk_draw_arc (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          gint filled,
>                          gint x,
>                          gint y,
>                          gint width,
>                          gint height,
>                          gint angle1,
>                          gint angle2);
>void gdk_draw_polygon (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          gint filled,
>                          GdkPoint *points,
>                          gint npoints);
>void gdk_draw_string (GdkDrawable *drawable,
>                          GdkFont *font,
>                          GdkGC *gc,
>                          gint x,
>                          gint y,
>                          const gchar *string);
>void gdk_draw_text (GdkDrawable *drawable,
>                          GdkFont *font,
>                          GdkGC *gc,
>                          gint x,
>                          gint y,
>                          const gchar *text,
>                          gint text_length);
>void gdk_draw_text_wc (GdkDrawable *drawable,
>                          GdkFont *font,
>                          GdkGC *gc,
>                          gint x,
>                          gint y,
>                          const GdkWChar *text,
>                          gint text_length);
>void gdk_draw_pixmap (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          GdkDrawable *src,
>                          gint xsrc,
>                          gint ysrc,
>                          gint xdest,
>                          gint ydest,
>                          gint width,
>                          gint height);
>void gdk_draw_image (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          GdkImage *image,
>                          gint xsrc,
>                          gint ysrc,
>                          gint xdest,
>                          gint ydest,
>                          gint width,
>                          gint height);
>void gdk_draw_points (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          GdkPoint *points,
>                          gint npoints);
>void gdk_draw_segments (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          GdkSegment *segs,
>                          gint nsegs);
>void gdk_draw_lines (GdkDrawable *drawable,
>                          GdkGC *gc,
>                          GdkPoint *points,
>                          gint npoints);
>
>
>
>
>
>
>gboolean gdk_selection_owner_set (GdkWindow *owner,
>                                    GdkAtom selection,
>                                    guint32 time,
>                                    gint send_event);
>GdkWindow* gdk_selection_owner_get (GdkAtom selection);
>void gdk_selection_convert (GdkWindow *requestor,
>                                    GdkAtom selection,
>                                    GdkAtom target,
>                                    guint32 time);
>gboolean gdk_selection_property_get (GdkWindow *requestor,
>                                       guchar **data,
>                                       GdkAtom *prop_type,
>                                       gint *prop_format);
>void gdk_selection_send_notify (guint32 requestor,
>                                      GdkAtom selection,
>                                      GdkAtom target,
>                                      GdkAtom property,
>                                      guint32 time);
>
>gint gdk_text_property_to_text_list (GdkAtom encoding, gint format,
>                                           guchar *text, gint length,
>                                           gchar ***list);
>void gdk_free_text_list (gchar **list);
>gint gdk_string_to_compound_text (const gchar *str,
>                                           GdkAtom *encoding, gint *format,
>                                           guchar **ctext, gint *length);
>void gdk_free_compound_text (guchar *ctext);
>
>
>
>GdkAtom gdk_atom_intern (const gchar *atom_name,
>                              gint only_if_exists);
>gchar* gdk_atom_name (GdkAtom atom);
>gboolean gdk_property_get (GdkWindow *window,
>                              GdkAtom property,
>                              GdkAtom type,
>                              gulong offset,
>                              gulong length,
>                              gint pdelete,
>                              GdkAtom *actual_property_type,
>                              gint *actual_format,
>                              gint *actual_length,
>                              guchar **data);
>void gdk_property_change (GdkWindow *window,
>                              GdkAtom property,
>                              GdkAtom type,
>                              gint format,
>                              GdkPropMode mode,
>                              guchar *data,
>                              gint nelements);
>void gdk_property_delete (GdkWindow *window,
>                              GdkAtom property);
>
>
>
>
>
>gboolean gdk_rectangle_intersect (GdkRectangle *src1,
>                                  GdkRectangle *src2,
>                                  GdkRectangle *dest);
>void gdk_rectangle_union (GdkRectangle *src1,
>                                  GdkRectangle *src2,
>                                  GdkRectangle *dest);
>
>
>
>void gdk_input_init (void);
>void gdk_input_exit (void);
>GList * gdk_input_list_devices (void);
>void gdk_input_set_extension_events (GdkWindow *window,
>                                              gint mask,
>                                              GdkExtensionMode mode);
>void gdk_input_set_source (guint32 deviceid,
>                                              GdkInputSource source);
>gboolean gdk_input_set_mode (guint32 deviceid,
>                                              GdkInputMode mode);
>void gdk_input_set_axes (guint32 deviceid,
>                                              GdkAxisUse *axes);
>void gdk_input_set_key (guint32 deviceid,
>                                              guint index,
>                                              guint keyval,
>                                              GdkModifierType modifiers);
>void gdk_input_window_get_pointer (GdkWindow *window,
>                                              guint32 deviceid,
>                                              gdouble *x,
>                                              gdouble *y,
>                                              gdouble *pressure,
>                                              gdouble *xtilt,
>                                              gdouble *ytilt,
>                                              GdkModifierType *mask);
>GdkTimeCoord *gdk_input_motion_events (GdkWindow *window,
>                                              guint32 deviceid,
>                                              guint32 start,
>                                              guint32 stop,
>                                              gint *nevents_return);
>
>
>
>
>gboolean gdk_im_ready (void);
>
>void gdk_im_begin (GdkIC *ic,
>                                    GdkWindow *window);
>void gdk_im_end (void);
>GdkIMStyle gdk_im_decide_style (GdkIMStyle supported_style);
>GdkIMStyle gdk_im_set_best_style (GdkIMStyle best_allowed_style);
>
>GdkIC* gdk_ic_new (GdkICAttr *attr,
>                                    GdkICAttributesType mask);
>void gdk_ic_destroy (GdkIC *ic);
>GdkIMStyle gdk_ic_get_style (GdkIC *ic);
>GdkEventMask gdk_ic_get_events (GdkIC *ic);
>
>GdkICAttr* gdk_ic_attr_new (void);
>void gdk_ic_attr_destroy (GdkICAttr *attr);
>
>GdkICAttributesType gdk_ic_set_attr (GdkIC *ic,
>                                      GdkICAttr *attr,
>                                      GdkICAttributesType mask);
>GdkICAttributesType gdk_ic_get_attr (GdkIC *ic,
>                                      GdkICAttr *attr,
>                                      GdkICAttributesType mask);
>
>
>
>gchar *gdk_wcstombs (const GdkWChar *src);
>gint gdk_mbstowcs (GdkWChar *dest,
>                                  const gchar *src,
>                                  gint dest_max);
>
>
>
>
>GdkColorContext *gdk_color_context_new (GdkVisual *visual,
>                                                           GdkColormap *colormap);
>
>GdkColorContext *gdk_color_context_new_mono (GdkVisual *visual,
>                                                           GdkColormap *colormap);
>
>void gdk_color_context_free (GdkColorContext *cc);
>
>gulong gdk_color_context_get_pixel (GdkColorContext *cc,
>                                                           gushort red,
>                                                           gushort green,
>                                                           gushort blue,
>                                                           gint *failed);
>void gdk_color_context_get_pixels (GdkColorContext *cc,
>                                                           gushort *reds,
>                                                           gushort *greens,
>                                                           gushort *blues,
>                                                           gint ncolors,
>                                                           gulong *colors,
>                                                           gint *nallocated);
>void gdk_color_context_get_pixels_incremental (GdkColorContext *cc,
>                                                           gushort *reds,
>                                                           gushort *greens,
>                                                           gushort *blues,
>                                                           gint ncolors,
>                                                           gint *used,
>                                                           gulong *colors,
>                                                           gint *nallocated);
>
>gint gdk_color_context_query_color (GdkColorContext *cc,
>                                                           GdkColor *color);
>gint gdk_color_context_query_colors (GdkColorContext *cc,
>                                                           GdkColor *colors,
>                                                           gint num_colors);
>
>gint gdk_color_context_add_palette (GdkColorContext *cc,
>                                                           GdkColor *palette,
>                                                           gint num_palette);
>
>void gdk_color_context_init_dither (GdkColorContext *cc);
>void gdk_color_context_free_dither (GdkColorContext *cc);
>
>gulong gdk_color_context_get_pixel_from_palette (GdkColorContext *cc,
>                                                           gushort *red,
>                                                           gushort *green,
>                                                           gushort *blue,
>                                                           gint *failed);
>guchar gdk_color_context_get_index_from_palette (GdkColorContext *cc,
>                                                           gint *red,
>                                                           gint *green,
>                                                           gint *blue,
>                                                           gint *failed);
>
>
>
>GdkRegion* gdk_region_new (void);
>void gdk_region_destroy (GdkRegion *region);
>
>void gdk_region_get_clipbox(GdkRegion *region,
>                                      GdkRectangle *rectangle);
>
>gboolean gdk_region_empty (GdkRegion *region);
>gboolean gdk_region_equal (GdkRegion *region1,
>                                     GdkRegion *region2);
>gboolean gdk_region_point_in (GdkRegion *region,
>                                     int x,
>                                     int y);
>GdkOverlapType gdk_region_rect_in (GdkRegion *region,
>                                     GdkRectangle *rect);
>
>GdkRegion* gdk_region_polygon (GdkPoint *points,
>                                     gint npoints,
>                                     GdkFillRule fill_rule);
>
>void gdk_region_offset (GdkRegion *region,
>                                    gint dx,
>                                    gint dy);
>void gdk_region_shrink (GdkRegion *region,
>                                    gint dx,
>                                    gint dy);
>
>GdkRegion* gdk_region_union_with_rect (GdkRegion *region,
>                                           GdkRectangle *rect);
>GdkRegion* gdk_regions_intersect (GdkRegion *source1,
>                                           GdkRegion *source2);
>GdkRegion* gdk_regions_union (GdkRegion *source1,
>                                           GdkRegion *source2);
>GdkRegion* gdk_regions_subtract (GdkRegion *source1,
>                                           GdkRegion *source2);
>GdkRegion* gdk_regions_xor (GdkRegion *source1,
>                                           GdkRegion *source2);
>
>
>void gdk_event_send_clientmessage_toall (GdkEvent *event);
>gboolean gdk_event_send_client_message (GdkEvent *event,
>                                        guint32 xid);
>
>
>
>gchar* gdk_keyval_name (guint keyval);
>guint gdk_keyval_from_name (const gchar *keyval_name);
>guint gdk_keyval_to_upper (guint keyval);
>guint gdk_keyval_to_lower (guint keyval);
>gboolean gdk_keyval_is_upper (guint keyval);
>gboolean gdk_keyval_is_lower (guint keyval);
>
>
>
>
>extern GMutex *gdk_threads_mutex;
>
>void gdk_threads_enter (void);
>void gdk_threads_leave (void);
># 1007 "/usr/X11R6/include/gtk12/gdk/gdk.h"
># 1 "/usr/X11R6/include/gtk12/gdk/gdkrgb.h" 1
># 34 "/usr/X11R6/include/gtk12/gdk/gdkrgb.h"
>typedef struct _GdkRgbCmap GdkRgbCmap;
>
>struct _GdkRgbCmap {
>  guint32 colors[256];
>  guchar lut[256];
>};
>
>void
>gdk_rgb_init (void);
>
>gulong
>gdk_rgb_xpixel_from_rgb (guint32 rgb);
>
>void
>gdk_rgb_gc_set_foreground (GdkGC *gc, guint32 rgb);
>
>void
>gdk_rgb_gc_set_background (GdkGC *gc, guint32 rgb);
>
>typedef enum
>{
>  GDK_RGB_DITHER_NONE,
>  GDK_RGB_DITHER_NORMAL,
>  GDK_RGB_DITHER_MAX
>} GdkRgbDither;
>
>void
>gdk_draw_rgb_image (GdkDrawable *drawable,
>                    GdkGC *gc,
>                    gint x,
>                    gint y,
>                    gint width,
>                    gint height,
>                    GdkRgbDither dith,
>                    guchar *rgb_buf,
>                    gint rowstride);
>
>void
>gdk_draw_rgb_image_dithalign (GdkDrawable *drawable,
>                              GdkGC *gc,
>                              gint x,
>                              gint y,
>                              gint width,
>                              gint height,
>                              GdkRgbDither dith,
>                              guchar *rgb_buf,
>                              gint rowstride,
>                              gint xdith,
>                              gint ydith);
>
>void
>gdk_draw_rgb_32_image (GdkDrawable *drawable,
>                       GdkGC *gc,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height,
>                       GdkRgbDither dith,
>                       guchar *buf,
>                       gint rowstride);
>
>void
>gdk_draw_gray_image (GdkDrawable *drawable,
>                     GdkGC *gc,
>                     gint x,
>                     gint y,
>                     gint width,
>                     gint height,
>                     GdkRgbDither dith,
>                     guchar *buf,
>                     gint rowstride);
>
>GdkRgbCmap *
>gdk_rgb_cmap_new (guint32 *colors, gint n_colors);
>
>void
>gdk_rgb_cmap_free (GdkRgbCmap *cmap);
>
>void
>gdk_draw_indexed_image (GdkDrawable *drawable,
>                        GdkGC *gc,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height,
>                        GdkRgbDither dith,
>                        guchar *buf,
>                        gint rowstride,
>                        GdkRgbCmap *cmap);
>
>
>
>
>gboolean
>gdk_rgb_ditherable (void);
>
>void
>gdk_rgb_set_verbose (gboolean verbose);
>
>
>void
>gdk_rgb_set_install (gboolean install);
>
>void
>gdk_rgb_set_min_colors (gint min_colors);
>
>GdkColormap *
>gdk_rgb_get_cmap (void);
>
>GdkVisual *
>gdk_rgb_get_visual (void);
># 1008 "/usr/X11R6/include/gtk12/gdk/gdk.h" 2
># 31 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkaccelgroup.h" 1
># 35 "/usr/X11R6/include/gtk12/gtk/gtkaccelgroup.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkobject.h" 1
># 31 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkarg.h" 1
># 31 "/usr/X11R6/include/gtk12/gtk/gtkarg.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h" 1
># 41 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h"
>typedef enum
>{
>  GTK_TYPE_INVALID,
>  GTK_TYPE_NONE,
>
>
>  GTK_TYPE_CHAR,
>  GTK_TYPE_UCHAR,
>  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_POINTER,
>
>
>  GTK_TYPE_SIGNAL,
>  GTK_TYPE_ARGS,
>  GTK_TYPE_CALLBACK,
>  GTK_TYPE_C_CALLBACK,
>  GTK_TYPE_FOREIGN,
>
>
>  GTK_TYPE_OBJECT
>} GtkFundamentalType;
># 123 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h"
>typedef guint GtkType;
>
>typedef struct _GtkTypeObject GtkTypeObject;
>typedef struct _GtkTypeClass GtkTypeClass;
># 135 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtktypebuiltins.h" 1
>
>
>extern GtkType GTK_TYPE_ACCEL_FLAGS;
>extern GtkType GTK_TYPE_CALENDAR_DISPLAY_OPTIONS;
>extern GtkType GTK_TYPE_CELL_TYPE;
>extern GtkType GTK_TYPE_CLIST_DRAG_POS;
>extern GtkType GTK_TYPE_BUTTON_ACTION;
>extern GtkType GTK_TYPE_CTREE_POS;
>extern GtkType GTK_TYPE_CTREE_LINE_STYLE;
>extern GtkType GTK_TYPE_CTREE_EXPANDER_STYLE;
>extern GtkType GTK_TYPE_CTREE_EXPANSION_TYPE;
>extern GtkType GTK_TYPE_DEBUG_FLAG;
>extern GtkType GTK_TYPE_DEST_DEFAULTS;
>extern GtkType GTK_TYPE_TARGET_FLAGS;
>extern GtkType GTK_TYPE_ARROW_TYPE;
>extern GtkType GTK_TYPE_ATTACH_OPTIONS;
>extern GtkType GTK_TYPE_BUTTON_BOX_STYLE;
>extern GtkType GTK_TYPE_CURVE_TYPE;
>extern GtkType GTK_TYPE_DIRECTION_TYPE;
>extern GtkType GTK_TYPE_JUSTIFICATION;
>extern GtkType GTK_TYPE_MATCH_TYPE;
>extern GtkType GTK_TYPE_MENU_DIRECTION_TYPE;
>extern GtkType GTK_TYPE_MENU_FACTORY_TYPE;
>extern GtkType GTK_TYPE_METRIC_TYPE;
>extern GtkType GTK_TYPE_ORIENTATION;
>extern GtkType GTK_TYPE_CORNER_TYPE;
>extern GtkType GTK_TYPE_PACK_TYPE;
>extern GtkType GTK_TYPE_PATH_PRIORITY_TYPE;
>extern GtkType GTK_TYPE_PATH_TYPE;
>extern GtkType GTK_TYPE_POLICY_TYPE;
>extern GtkType GTK_TYPE_POSITION_TYPE;
>extern GtkType GTK_TYPE_PREVIEW_TYPE;
>extern GtkType GTK_TYPE_RELIEF_STYLE;
>extern GtkType GTK_TYPE_RESIZE_MODE;
>extern GtkType GTK_TYPE_SIGNAL_RUN_TYPE;
>extern GtkType GTK_TYPE_SCROLL_TYPE;
>extern GtkType GTK_TYPE_SELECTION_MODE;
>extern GtkType GTK_TYPE_SHADOW_TYPE;
>extern GtkType GTK_TYPE_STATE_TYPE;
>extern GtkType GTK_TYPE_SUBMENU_DIRECTION;
>extern GtkType GTK_TYPE_SUBMENU_PLACEMENT;
>extern GtkType GTK_TYPE_TOOLBAR_STYLE;
>extern GtkType GTK_TYPE_TROUGH_TYPE;
>extern GtkType GTK_TYPE_UPDATE_TYPE;
>extern GtkType GTK_TYPE_VISIBILITY;
>extern GtkType GTK_TYPE_WINDOW_POSITION;
>extern GtkType GTK_TYPE_WINDOW_TYPE;
>extern GtkType GTK_TYPE_SORT_TYPE;
>extern GtkType GTK_TYPE_FONT_METRIC_TYPE;
>extern GtkType GTK_TYPE_FONT_TYPE;
>extern GtkType GTK_TYPE_FONT_FILTER_TYPE;
>extern GtkType GTK_TYPE_OBJECT_FLAGS;
>extern GtkType GTK_TYPE_ARG_FLAGS;
>extern GtkType GTK_TYPE_PACKER_OPTIONS;
>extern GtkType GTK_TYPE_SIDE_TYPE;
>extern GtkType GTK_TYPE_ANCHOR_TYPE;
>extern GtkType GTK_TYPE_PRIVATE_FLAGS;
>extern GtkType GTK_TYPE_PROGRESS_BAR_STYLE;
>extern GtkType GTK_TYPE_PROGRESS_BAR_ORIENTATION;
>extern GtkType GTK_TYPE_RC_FLAGS;
>extern GtkType GTK_TYPE_RC_TOKEN_TYPE;
>extern GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY;
>extern GtkType GTK_TYPE_SPIN_TYPE;
>extern GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE;
>extern GtkType GTK_TYPE_TOOLBAR_SPACE_STYLE;
>extern GtkType GTK_TYPE_TREE_VIEW_MODE;
>extern GtkType GTK_TYPE_FUNDAMENTAL_TYPE;
>extern GtkType GTK_TYPE_WIDGET_FLAGS;
>extern GtkType GTK_TYPE_GDK_WINDOW_TYPE;
>extern GtkType GTK_TYPE_GDK_WINDOW_CLASS;
>extern GtkType GTK_TYPE_GDK_IMAGE_TYPE;
>extern GtkType GTK_TYPE_GDK_VISUAL_TYPE;
>extern GtkType GTK_TYPE_GDK_FONT_TYPE;
>extern GtkType GTK_TYPE_GDK_WINDOW_ATTRIBUTES_TYPE;
>extern GtkType GTK_TYPE_GDK_WINDOW_HINTS;
>extern GtkType GTK_TYPE_GDK_FUNCTION;
>extern GtkType GTK_TYPE_GDK_FILL;
>extern GtkType GTK_TYPE_GDK_FILL_RULE;
>extern GtkType GTK_TYPE_GDK_LINE_STYLE;
>extern GtkType GTK_TYPE_GDK_CAP_STYLE;
>extern GtkType GTK_TYPE_GDK_JOIN_STYLE;
>extern GtkType GTK_TYPE_GDK_CURSOR_TYPE;
>extern GtkType GTK_TYPE_GDK_FILTER_RETURN;
>extern GtkType GTK_TYPE_GDK_VISIBILITY_STATE;
>extern GtkType GTK_TYPE_GDK_EVENT_TYPE;
>extern GtkType GTK_TYPE_GDK_EVENT_MASK;
>extern GtkType GTK_TYPE_GDK_NOTIFY_TYPE;
>extern GtkType GTK_TYPE_GDK_CROSSING_MODE;
>extern GtkType GTK_TYPE_GDK_MODIFIER_TYPE;
>extern GtkType GTK_TYPE_GDK_SUBWINDOW_MODE;
>extern GtkType GTK_TYPE_GDK_INPUT_CONDITION;
>extern GtkType GTK_TYPE_GDK_STATUS;
>extern GtkType GTK_TYPE_GDK_BYTE_ORDER;
>extern GtkType GTK_TYPE_GDK_GC_VALUES_MASK;
>extern GtkType GTK_TYPE_GDK_SELECTION;
>extern GtkType GTK_TYPE_GDK_PROPERTY_STATE;
>extern GtkType GTK_TYPE_GDK_PROP_MODE;
>extern GtkType GTK_TYPE_GDK_INPUT_SOURCE;
>extern GtkType GTK_TYPE_GDK_INPUT_MODE;
>extern GtkType GTK_TYPE_GDK_AXIS_USE;
>extern GtkType GTK_TYPE_GDK_TARGET;
>extern GtkType GTK_TYPE_GDK_SELECTION_TYPE;
>extern GtkType GTK_TYPE_GDK_EXTENSION_MODE;
>extern GtkType GTK_TYPE_GDK_IM_STYLE;
>extern GtkType GTK_TYPE_GDK_IC_ATTRIBUTES_TYPE;
>extern GtkType GTK_TYPE_GDK_WM_DECORATION;
>extern GtkType GTK_TYPE_GDK_WM_FUNCTION;
>extern GtkType GTK_TYPE_GDK_COLOR_CONTEXT_MODE;
>extern GtkType GTK_TYPE_GDK_OVERLAP_TYPE;
>extern GtkType GTK_TYPE_GDK_DRAG_ACTION;
>extern GtkType GTK_TYPE_GDK_DRAG_PROTOCOL;
>extern GtkType GTK_TYPE_GDK_RGB_DITHER;
>extern GtkType GTK_TYPE_ACCEL_GROUP;
>extern GtkType GTK_TYPE_SELECTION_DATA;
>extern GtkType GTK_TYPE_STYLE;
>extern GtkType GTK_TYPE_CTREE_NODE;
>extern GtkType GTK_TYPE_GDK_COLORMAP;
>extern GtkType GTK_TYPE_GDK_VISUAL;
>extern GtkType GTK_TYPE_GDK_FONT;
>extern GtkType GTK_TYPE_GDK_WINDOW;
>extern GtkType GTK_TYPE_GDK_DRAG_CONTEXT;
>extern GtkType GTK_TYPE_GDK_EVENT;
>extern GtkType GTK_TYPE_GDK_COLOR;
># 136 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h" 2
>
>
>
>
>
>
>GtkType gtk_identifier_get_type (void);
>
>
>
>
>
>
>
>typedef struct _GtkArg GtkArg;
>typedef struct _GtkObject GtkObject;
>typedef struct _GtkTypeInfo GtkTypeInfo;
>typedef struct _GtkTypeQuery GtkTypeQuery;
>typedef struct _GtkEnumValue GtkEnumValue;
>typedef struct _GtkEnumValue GtkFlagValue;
>
>
>
>
>typedef void (*GtkClassInitFunc) (gpointer klass);
>typedef void (*GtkObjectInitFunc) (gpointer object,
>                                    gpointer klass);
>typedef void (*GtkSignalFunc) ();
>typedef gint (*GtkFunction) (gpointer data);
>typedef void (*GtkDestroyNotify) (gpointer data);
>typedef void (*GtkCallbackMarshal) (GtkObject *object,
>                                    gpointer data,
>                                    guint n_args,
>                                    GtkArg *args);
>typedef void (*GtkSignalMarshaller) (GtkObject *object,
>                                     GtkSignalFunc func,
>                                     gpointer func_data,
>                                     GtkArg *args);
>
>
>typedef void (*GtkArgGetFunc) (GtkObject*, GtkArg*, guint);
>typedef void (*GtkArgSetFunc) (GtkObject*, GtkArg*, guint);
>
>
>
>
>
>
>
>struct _GtkTypeObject
>{
>
>
>
>
>  GtkTypeClass *klass;
>};
>
>
>
>
>
>
>
>struct _GtkTypeClass
>{
>
>
>
>  GtkType type;
>};
>
>
>struct _GtkArg
>{
>  GtkType type;
>  gchar *name;
>
>
>
>
>
>
>
>  union {
>
>    gchar char_data;
>    guchar uchar_data;
>    gboolean bool_data;
>    gint int_data;
>    guint uint_data;
>    glong long_data;
>    gulong ulong_data;
>    gfloat float_data;
>    gdouble double_data;
>    gchar *string_data;
>    gpointer pointer_data;
>    GtkObject *object_data;
>
>
>    struct {
>      GtkSignalFunc f;
>      gpointer d;
>    } signal_data;
>    struct {
>      gint n_args;
>      GtkArg *args;
>    } args_data;
>    struct {
>      GtkCallbackMarshal marshal;
>      gpointer data;
>      GtkDestroyNotify notify;
>    } callback_data;
>    struct {
>      GtkFunction func;
>      gpointer func_data;
>    } c_callback_data;
>    struct {
>      gpointer data;
>      GtkDestroyNotify notify;
>    } foreign_data;
>  } d;
>};
># 311 "/usr/X11R6/include/gtk12/gtk/gtktypeutils.h"
>struct _GtkTypeInfo
>{
>  gchar *type_name;
>  guint object_size;
>  guint class_size;
>  GtkClassInitFunc class_init_func;
>  GtkObjectInitFunc object_init_func;
>  gpointer reserved_1;
>  gpointer reserved_2;
>  GtkClassInitFunc base_class_init_func;
>};
>
>struct _GtkTypeQuery
>{
>  GtkType type;
>  const gchar *type_name;
>  guint object_size;
>  guint class_size;
>};
>
>struct _GtkEnumValue
>{
>  guint value;
>  gchar *value_name;
>  gchar *value_nick;
>};
>
>
>void gtk_type_init (void);
>GtkType gtk_type_unique (GtkType parent_type,
>                                                 const GtkTypeInfo *type_info);
>void gtk_type_set_chunk_alloc (GtkType type,
>                                                 guint n_chunks);
>gchar* gtk_type_name (guint type);
>GtkType gtk_type_from_name (const gchar *name);
>GtkType gtk_type_parent (GtkType type);
>gpointer gtk_type_class (GtkType type);
>gpointer gtk_type_parent_class (GtkType type);
>GList* gtk_type_children_types (GtkType type);
>gpointer gtk_type_new (GtkType type);
>void gtk_type_free (GtkType type,
>                                                 gpointer mem);
>void gtk_type_describe_heritage (GtkType type);
>void gtk_type_describe_tree (GtkType type,
>                                                 gboolean show_size);
>gboolean gtk_type_is_a (GtkType type,
>                                                 GtkType is_a_type);
>GtkTypeObject* gtk_type_check_object_cast (GtkTypeObject *type_object,
>                                                 GtkType cast_type);
>GtkTypeClass* gtk_type_check_class_cast (GtkTypeClass *klass,
>                                                 GtkType cast_type);
>GtkType gtk_type_register_enum (const gchar *type_name,
>                                                 GtkEnumValue *values);
>GtkType gtk_type_register_flags (const gchar *type_name,
>                                                 GtkFlagValue *values);
>GtkEnumValue* gtk_type_enum_get_values (GtkType enum_type);
>GtkFlagValue* gtk_type_flags_get_values (GtkType flags_type);
>GtkEnumValue* gtk_type_enum_find_value (GtkType enum_type,
>                                                 const gchar *value_name);
>GtkFlagValue* gtk_type_flags_find_value (GtkType flag_type,
>                                                 const gchar *value_name);
>
>void gtk_type_set_varargs_type (GtkType foreign_type,
>                                                 GtkType varargs_type);
>GtkType gtk_type_get_varargs_type (GtkType foreign_type);
>
>
>
>
>GtkTypeQuery* gtk_type_query (GtkType type);
># 32 "/usr/X11R6/include/gtk12/gtk/gtkarg.h" 2
># 41 "/usr/X11R6/include/gtk12/gtk/gtkarg.h"
>typedef struct _GtkArgInfo GtkArgInfo;
>
>struct _GtkArgInfo
>{
>
>  GtkType class_type;
>  gchar *name;
>
>  GtkType type;
>  guint arg_flags;
>  gchar *full_name;
>
>
>  guint arg_id;
>  guint seq_id;
>};
>
>
>
>
>GtkArg* gtk_arg_new (GtkType arg_type);
>GtkArg* gtk_arg_copy (GtkArg *src_arg,
>                                          GtkArg *dest_arg);
>void gtk_arg_free (GtkArg *arg,
>                                          gboolean free_contents);
>void gtk_arg_reset (GtkArg *arg);
>gboolean gtk_arg_values_equal (const GtkArg *arg1,
>                                          const GtkArg *arg2);
>gchar* gtk_args_collect (GtkType object_type,
>                                          GHashTable *arg_info_hash_table,
>                                          GSList **arg_list_p,
>                                          GSList **info_list_p,
>                                          const gchar *first_arg_name,
>                                          va_list var_args);
>void gtk_args_collect_cleanup (GSList *arg_list,
>                                          GSList *info_list);
>gchar* gtk_arg_get_info (GtkType object_type,
>                                          GHashTable *arg_info_hash_table,
>                                          const gchar *arg_name,
>                                          GtkArgInfo **info_p);
>GtkArgInfo* gtk_arg_type_new_static (GtkType base_class_type,
>                                          const gchar *arg_name,
>                                          guint class_n_args_offset,
>                                          GHashTable *arg_info_hash_table,
>                                          GtkType arg_type,
>                                          guint arg_flags,
>                                          guint arg_id);
>GtkArg* gtk_args_query (GtkType class_type,
>                                          GHashTable *arg_info_hash_table,
>                                          guint32 **arg_flags,
>                                          guint *n_args_p);
>gchar* gtk_arg_name_strip_type (const gchar *arg_name);
>gint gtk_arg_info_equal (gconstpointer arg_info_1,
>                                          gconstpointer arg_info_2);
>guint gtk_arg_info_hash (gconstpointer arg_info);
>void gtk_arg_to_valueloc (GtkArg *arg,
>                                          gpointer value_pointer);
># 32 "/usr/X11R6/include/gtk12/gtk/gtkobject.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkenums.h" 1
># 35 "/usr/X11R6/include/gtk12/gtk/gtkenums.h"
>typedef enum
>{
>  GTK_ARROW_UP,
>  GTK_ARROW_DOWN,
>  GTK_ARROW_LEFT,
>  GTK_ARROW_RIGHT
>} GtkArrowType;
>
>
>typedef enum
>{
>  GTK_EXPAND = 1 << 0,
>  GTK_SHRINK = 1 << 1,
>  GTK_FILL = 1 << 2
>} GtkAttachOptions;
>
>
>typedef enum
>{
>  GTK_BUTTONBOX_DEFAULT_STYLE,
>  GTK_BUTTONBOX_SPREAD,
>  GTK_BUTTONBOX_EDGE,
>  GTK_BUTTONBOX_START,
>  GTK_BUTTONBOX_END
>} GtkButtonBoxStyle;
>
>
>typedef enum
>{
>  GTK_CURVE_TYPE_LINEAR,
>  GTK_CURVE_TYPE_SPLINE,
>  GTK_CURVE_TYPE_FREE
>} GtkCurveType;
>
>
>typedef enum
>{
>  GTK_DIR_TAB_FORWARD,
>  GTK_DIR_TAB_BACKWARD,
>  GTK_DIR_UP,
>  GTK_DIR_DOWN,
>  GTK_DIR_LEFT,
>  GTK_DIR_RIGHT
>} GtkDirectionType;
>
>
>typedef enum
>{
>  GTK_JUSTIFY_LEFT,
>  GTK_JUSTIFY_RIGHT,
>  GTK_JUSTIFY_CENTER,
>  GTK_JUSTIFY_FILL
>} GtkJustification;
>
>
>typedef enum
>{
>  GTK_MATCH_ALL,
>  GTK_MATCH_ALL_TAIL,
>  GTK_MATCH_HEAD,
>  GTK_MATCH_TAIL,
>  GTK_MATCH_EXACT,
>  GTK_MATCH_LAST
>} GtkMatchType;
>
>
>typedef enum
>{
>  GTK_MENU_DIR_PARENT,
>  GTK_MENU_DIR_CHILD,
>  GTK_MENU_DIR_NEXT,
>  GTK_MENU_DIR_PREV
>} GtkMenuDirectionType;
>
>typedef enum
>{
>  GTK_MENU_FACTORY_MENU,
>  GTK_MENU_FACTORY_MENU_BAR,
>  GTK_MENU_FACTORY_OPTION_MENU
>} GtkMenuFactoryType;
>
>typedef enum
>{
>  GTK_PIXELS,
>  GTK_INCHES,
>  GTK_CENTIMETERS
>} GtkMetricType;
>
>
>typedef enum
>{
>  GTK_ORIENTATION_HORIZONTAL,
>  GTK_ORIENTATION_VERTICAL
>} GtkOrientation;
>
>
>typedef enum
>{
>  GTK_CORNER_TOP_LEFT,
>  GTK_CORNER_BOTTOM_LEFT,
>  GTK_CORNER_TOP_RIGHT,
>  GTK_CORNER_BOTTOM_RIGHT
>} GtkCornerType;
>
>
>typedef enum
>{
>  GTK_PACK_START,
>  GTK_PACK_END
>} GtkPackType;
>
>
>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;
>
>
>typedef enum
>{
>  GTK_PATH_WIDGET,
>  GTK_PATH_WIDGET_CLASS,
>  GTK_PATH_CLASS
>} GtkPathType;
>
>
>typedef enum
>{
>  GTK_POLICY_ALWAYS,
>  GTK_POLICY_AUTOMATIC,
>  GTK_POLICY_NEVER
>} GtkPolicyType;
>
>typedef enum
>{
>  GTK_POS_LEFT,
>  GTK_POS_RIGHT,
>  GTK_POS_TOP,
>  GTK_POS_BOTTOM
>} GtkPositionType;
>
>typedef enum
>{
>  GTK_PREVIEW_COLOR,
>  GTK_PREVIEW_GRAYSCALE
>} GtkPreviewType;
>
>
>typedef enum
>{
>  GTK_RELIEF_NORMAL,
>  GTK_RELIEF_HALF,
>  GTK_RELIEF_NONE
>} GtkReliefStyle;
>
>
>typedef enum
>{
>  GTK_RESIZE_PARENT,
>  GTK_RESIZE_QUEUE,
>  GTK_RESIZE_IMMEDIATE
>} GtkResizeMode;
>
>
>typedef enum
>{
>  GTK_RUN_FIRST = 1 << 0,
>  GTK_RUN_LAST = 1 << 1,
>  GTK_RUN_BOTH = (GTK_RUN_FIRST | GTK_RUN_LAST),
>  GTK_RUN_NO_RECURSE = 1 << 2,
>  GTK_RUN_ACTION = 1 << 3,
>  GTK_RUN_NO_HOOKS = 1 << 4
>} GtkSignalRunType;
>
>
>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;
>
>
>typedef enum
>{
>  GTK_SELECTION_SINGLE,
>  GTK_SELECTION_BROWSE,
>  GTK_SELECTION_MULTIPLE,
>  GTK_SELECTION_EXTENDED
>} GtkSelectionMode;
>
>
>typedef enum
>{
>  GTK_SHADOW_NONE,
>  GTK_SHADOW_IN,
>  GTK_SHADOW_OUT,
>  GTK_SHADOW_ETCHED_IN,
>  GTK_SHADOW_ETCHED_OUT
>} GtkShadowType;
>
>
>typedef enum
>{
>  GTK_STATE_NORMAL,
>  GTK_STATE_ACTIVE,
>  GTK_STATE_PRELIGHT,
>  GTK_STATE_SELECTED,
>  GTK_STATE_INSENSITIVE
>} GtkStateType;
>
>
>typedef enum
>{
>  GTK_DIRECTION_LEFT,
>  GTK_DIRECTION_RIGHT
>} GtkSubmenuDirection;
>
>
>typedef enum
>{
>  GTK_TOP_BOTTOM,
>  GTK_LEFT_RIGHT
>} GtkSubmenuPlacement;
>
>
>typedef enum
>{
>  GTK_TOOLBAR_ICONS,
>  GTK_TOOLBAR_TEXT,
>  GTK_TOOLBAR_BOTH
>} GtkToolbarStyle;
>
>
>typedef enum
>{
>  GTK_TROUGH_NONE,
>  GTK_TROUGH_START,
>  GTK_TROUGH_END,
>  GTK_TROUGH_JUMP
>} GtkTroughType;
>
>
>typedef enum
>{
>  GTK_UPDATE_CONTINUOUS,
>  GTK_UPDATE_DISCONTINUOUS,
>  GTK_UPDATE_DELAYED
>} GtkUpdateType;
>
>
>typedef enum
>{
>  GTK_VISIBILITY_NONE,
>  GTK_VISIBILITY_PARTIAL,
>  GTK_VISIBILITY_FULL
>} GtkVisibility;
>
>
>typedef enum
>{
>  GTK_WIN_POS_NONE,
>  GTK_WIN_POS_CENTER,
>  GTK_WIN_POS_MOUSE,
>  GTK_WIN_POS_CENTER_ALWAYS
>} GtkWindowPosition;
>
>
>typedef enum
>{
>  GTK_WINDOW_TOPLEVEL,
>  GTK_WINDOW_DIALOG,
>  GTK_WINDOW_POPUP
>} GtkWindowType;
>
>
>typedef enum
>{
>  GTK_SORT_ASCENDING,
>  GTK_SORT_DESCENDING
>} GtkSortType;
># 33 "/usr/X11R6/include/gtk12/gtk/gtkobject.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkdebug.h" 1
># 34 "/usr/X11R6/include/gtk12/gtk/gtkdebug.h"
>typedef enum {
>  GTK_DEBUG_OBJECTS = 1 << 0,
>  GTK_DEBUG_MISC = 1 << 1,
>  GTK_DEBUG_SIGNALS = 1 << 2,
>  GTK_DEBUG_DND = 1 << 3,
>  GTK_DEBUG_PLUGSOCKET = 1 << 4
>} GtkDebugFlag;
># 54 "/usr/X11R6/include/gtk12/gtk/gtkdebug.h"
>extern guint gtk_debug_flags;
># 35 "/usr/X11R6/include/gtk12/gtk/gtkobject.h" 2
># 80 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>typedef enum
>{
>  GTK_DESTROYED = 1 << 0,
>  GTK_FLOATING = 1 << 1,
>  GTK_CONNECTED = 1 << 2,
>  GTK_CONSTRUCTED = 1 << 3
>} GtkObjectFlags;
># 103 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>typedef enum
>{
>  GTK_ARG_READABLE = 1 << 0,
>  GTK_ARG_WRITABLE = 1 << 1,
>  GTK_ARG_CONSTRUCT = 1 << 2,
>  GTK_ARG_CONSTRUCT_ONLY = 1 << 3,
>  GTK_ARG_CHILD_ARG = 1 << 4,
>  GTK_ARG_MASK = 0x1f,
>
>
>
>  GTK_ARG_READWRITE = GTK_ARG_READABLE | GTK_ARG_WRITABLE
>} GtkArgFlags;
>
>typedef struct _GtkObjectClass GtkObjectClass;
>
>
>
>
>
>
>
>struct _GtkObject
>{
>
>  GtkObjectClass *klass;
>
>
>
>
>
>
>
>  guint32 flags;
>
>
>
>
>  guint ref_count;
>
>
>
>
>  GData *object_data;
>};
># 156 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>struct _GtkObjectClass
>{
>
>  GtkType type;
>
>
>
>
>
>  guint *signals;
>
>
>
>  guint nsignals;
>
>
>
>  guint n_args;
>  GSList *construct_args;
>
>
>  void (*set_arg) (GtkObject *object,
>                   GtkArg *arg,
>                   guint arg_id);
>  void (*get_arg) (GtkObject *object,
>                   GtkArg *arg,
>                   guint arg_id);
># 192 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>  void (* shutdown) (GtkObject *object);
>  void (* destroy) (GtkObject *object);
>
>  void (* finalize) (GtkObject *object);
>};
>
>
>
>
>
>GtkType gtk_object_get_type (void);
>
>
>guint gtk_object_class_user_signal_new (GtkObjectClass *klass,
>                                           const gchar *name,
>                                           GtkSignalRunType signal_flags,
>                                           GtkSignalMarshaller marshaller,
>                                           GtkType return_val,
>                                           guint nparams,
>                                           ...);
>guint gtk_object_class_user_signal_newv (GtkObjectClass *klass,
>                                           const gchar *name,
>                                           GtkSignalRunType signal_flags,
>                                           GtkSignalMarshaller marshaller,
>                                           GtkType return_val,
>                                           guint nparams,
>                                           GtkType *params);
>GtkObject* gtk_object_new (GtkType type,
>                                           const gchar *first_arg_name,
>                                           ...);
>GtkObject* gtk_object_newv (GtkType object_type,
>                                           guint n_args,
>                                           GtkArg *args);
>void gtk_object_default_construct (GtkObject *object);
>void gtk_object_constructed (GtkObject *object);
>void gtk_object_sink (GtkObject *object);
>void gtk_object_ref (GtkObject *object);
>void gtk_object_unref (GtkObject *object);
>void gtk_object_weakref (GtkObject *object,
>                           GtkDestroyNotify notify,
>                           gpointer data);
>void gtk_object_weakunref (GtkObject *object,
>                           GtkDestroyNotify notify,
>                           gpointer data);
>void gtk_object_destroy (GtkObject *object);
>
>
>
>
>
>
>void gtk_object_getv (GtkObject *object,
>                                 guint n_args,
>                                 GtkArg *args);
>
>
>
>
>
>void gtk_object_get (GtkObject *object,
>                                 const gchar *first_arg_name,
>                                 ...);
>
>
>
>
>
>
>void gtk_object_set (GtkObject *object,
>                                 const gchar *first_arg_name,
>                                 ...);
>void gtk_object_setv (GtkObject *object,
>                                 guint n_args,
>                                 GtkArg *args);
># 275 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>GtkArg* gtk_object_query_args (GtkType class_type,
>                                 guint32 **arg_flags,
>                                 guint *n_args);
># 291 "/usr/X11R6/include/gtk12/gtk/gtkobject.h"
>void gtk_object_set_data (GtkObject *object,
>                                      const gchar *key,
>                                      gpointer data);
>void gtk_object_set_data_full (GtkObject *object,
>                                      const gchar *key,
>                                      gpointer data,
>                                      GtkDestroyNotify destroy);
>void gtk_object_remove_data (GtkObject *object,
>                                      const gchar *key);
>gpointer gtk_object_get_data (GtkObject *object,
>                                      const gchar *key);
>void gtk_object_remove_no_notify (GtkObject *object,
>                                      const gchar *key);
>
>
>
>
>
>
>void gtk_object_set_user_data (GtkObject *object,
>                                   gpointer data);
>gpointer gtk_object_get_user_data (GtkObject *object);
>
>
>
>
>
>void gtk_object_class_add_signals (GtkObjectClass *klass,
>                                         guint *signals,
>                                         guint nsignals);
>
>void gtk_object_add_arg_type (const gchar *arg_name,
>                                         GtkType arg_type,
>                                         guint arg_flags,
>                                         guint arg_id);
>
>
>void gtk_object_set_data_by_id (GtkObject *object,
>                                         GQuark data_id,
>                                         gpointer data);
>void gtk_object_set_data_by_id_full (GtkObject *object,
>                                         GQuark data_id,
>                                         gpointer data,
>                                         GtkDestroyNotify destroy);
>gpointer gtk_object_get_data_by_id (GtkObject *object,
>                                         GQuark data_id);
>void gtk_object_remove_data_by_id (GtkObject *object,
>                                         GQuark data_id);
>void gtk_object_remove_no_notify_by_id (GtkObject *object,
>                                         GQuark key_id);
>
>
>
>
>
>
>void gtk_object_arg_set (GtkObject *object,
>                                 GtkArg *arg,
>                                 GtkArgInfo *info);
>void gtk_object_arg_get (GtkObject *object,
>                                 GtkArg *arg,
>                                 GtkArgInfo *info);
>gchar* gtk_object_args_collect (GtkType object_type,
>                                 GSList **arg_list_p,
>                                 GSList **info_list_p,
>                                 const gchar *first_arg_name,
>                                 va_list var_args);
>gchar* gtk_object_arg_get_info (GtkType object_type,
>                                 const gchar *arg_name,
>                                 GtkArgInfo **info_p);
>void gtk_trace_referencing (GtkObject *object,
>                                 const gchar *func,
>                                 guint dummy,
>                                 guint line,
>                                 gboolean do_ref);
># 36 "/usr/X11R6/include/gtk12/gtk/gtkaccelgroup.h" 2
># 44 "/usr/X11R6/include/gtk12/gtk/gtkaccelgroup.h"
>typedef struct _GtkAccelGroup GtkAccelGroup;
>typedef struct _GtkAccelEntry GtkAccelEntry;
>
>typedef enum
>{
>
>
>
>  GTK_ACCEL_VISIBLE = 1 << 0,
>
>
>
>  GTK_ACCEL_SIGNAL_VISIBLE = 1 << 1,
>
>
>
>  GTK_ACCEL_LOCKED = 1 << 2,
>  GTK_ACCEL_MASK = 0x07
>} GtkAccelFlags;
>
>struct _GtkAccelGroup
>{
>  guint ref_count;
>  guint lock_count;
>  GdkModifierType modifier_mask;
>  GSList *attach_objects;
>};
>
>struct _GtkAccelEntry
>{
>
>
>  GtkAccelGroup *accel_group;
>  guint accelerator_key;
>  GdkModifierType accelerator_mods;
>
>  GtkAccelFlags accel_flags;
>  GtkObject *object;
>  guint signal_id;
>};
>
>
>
>
>gboolean gtk_accelerator_valid (guint keyval,
>                                               GdkModifierType modifiers);
>void gtk_accelerator_parse (const gchar *accelerator,
>                                               guint *accelerator_key,
>                                               GdkModifierType *accelerator_mods);
>gchar* gtk_accelerator_name (guint accelerator_key,
>                                               GdkModifierType accelerator_mods);
>void gtk_accelerator_set_default_mod_mask (GdkModifierType default_mod_mask);
>guint gtk_accelerator_get_default_mod_mask (void);
>
>
>
>
>GtkAccelGroup* gtk_accel_group_new (void);
>GtkAccelGroup* gtk_accel_group_get_default (void);
>GtkAccelGroup* gtk_accel_group_ref (GtkAccelGroup *accel_group);
>void gtk_accel_group_unref (GtkAccelGroup *accel_group);
>void gtk_accel_group_lock (GtkAccelGroup *accel_group);
>void gtk_accel_group_unlock (GtkAccelGroup *accel_group);
>gboolean gtk_accel_groups_activate (GtkObject *object,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>
>
>
>gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>void gtk_accel_group_attach (GtkAccelGroup *accel_group,
>                                                 GtkObject *object);
>void gtk_accel_group_detach (GtkAccelGroup *accel_group,
>                                                 GtkObject *object);
>
>
>
>GtkAccelEntry* gtk_accel_group_get_entry (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>void gtk_accel_group_lock_entry (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>void gtk_accel_group_unlock_entry (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>void gtk_accel_group_add (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods,
>                                                 GtkAccelFlags accel_flags,
>                                                 GtkObject *object,
>                                                 const gchar *accel_signal);
>void gtk_accel_group_remove (GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods,
>                                                 GtkObject *object);
>
>
>
>void gtk_accel_group_handle_add (GtkObject *object,
>                                                 guint accel_signal_id,
>                                                 GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods,
>                                                 GtkAccelFlags accel_flags);
>void gtk_accel_group_handle_remove (GtkObject *object,
>                                                 GtkAccelGroup *accel_group,
>                                                 guint accel_key,
>                                                 GdkModifierType accel_mods);
>guint gtk_accel_group_create_add (GtkType class_type,
>                                                 GtkSignalRunType signal_flags,
>                                                 guint handler_offset);
>guint gtk_accel_group_create_remove (GtkType class_type,
>                                                 GtkSignalRunType signal_flags,
>                                                 guint handler_offset);
>
>
>
>GSList* gtk_accel_groups_from_object (GtkObject *object);
>GSList* gtk_accel_group_entries_from_object (GtkObject *object);
># 32 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkadjustment.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkadjustment.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkdata.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkdata.h"
>typedef struct _GtkData GtkData;
>typedef struct _GtkDataClass GtkDataClass;
>
>struct _GtkData
>{
>  GtkObject object;
>};
>
>struct _GtkDataClass
>{
>  GtkObjectClass parent_class;
>
>  void (* disconnect) (GtkData *data);
>};
>
>
>GtkType gtk_data_get_type (void);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkadjustment.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkadjustment.h"
>typedef struct _GtkAdjustment GtkAdjustment;
>typedef struct _GtkAdjustmentClass GtkAdjustmentClass;
>
>struct _GtkAdjustment
>{
>  GtkData data;
>
>  gfloat lower;
>  gfloat upper;
>  gfloat value;
>  gfloat step_increment;
>  gfloat page_increment;
>  gfloat page_size;
>};
>
>struct _GtkAdjustmentClass
>{
>  GtkDataClass parent_class;
>
>  void (* changed) (GtkAdjustment *adjustment);
>  void (* value_changed) (GtkAdjustment *adjustment);
>};
>
>
>GtkType gtk_adjustment_get_type (void);
>GtkObject* gtk_adjustment_new (gfloat value,
>                                                 gfloat lower,
>                                                 gfloat upper,
>                                                 gfloat step_increment,
>                                                 gfloat page_increment,
>                                                 gfloat page_size);
>void gtk_adjustment_changed (GtkAdjustment *adjustment);
>void gtk_adjustment_value_changed (GtkAdjustment *adjustment);
>void gtk_adjustment_clamp_page (GtkAdjustment *adjustment,
>                                                 gfloat lower,
>                                                 gfloat upper);
>void gtk_adjustment_set_value (GtkAdjustment *adjustment,
>                                                 gfloat value);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkstyle.h" 1
># 38 "/usr/X11R6/include/gtk12/gtk/gtkstyle.h"
>typedef struct _GtkStyle GtkStyle;
>typedef struct _GtkStyleClass GtkStyleClass;
>
>
>
>
>typedef struct _GtkThemeEngine GtkThemeEngine;
>typedef struct _GtkRcStyle GtkRcStyle;
>
>
>
>
>
>typedef struct _GtkWidget GtkWidget;
># 60 "/usr/X11R6/include/gtk12/gtk/gtkstyle.h"
>struct _GtkStyle
>{
>  GtkStyleClass *klass;
>
>  GdkColor fg[5];
>  GdkColor bg[5];
>  GdkColor light[5];
>  GdkColor dark[5];
>  GdkColor mid[5];
>  GdkColor text[5];
>  GdkColor base[5];
>
>  GdkColor black;
>  GdkColor white;
>  GdkFont *font;
>
>  GdkGC *fg_gc[5];
>  GdkGC *bg_gc[5];
>  GdkGC *light_gc[5];
>  GdkGC *dark_gc[5];
>  GdkGC *mid_gc[5];
>  GdkGC *text_gc[5];
>  GdkGC *base_gc[5];
>  GdkGC *black_gc;
>  GdkGC *white_gc;
>
>  GdkPixmap *bg_pixmap[5];
>
>
>
>  gint ref_count;
>  gint attach_count;
>
>  gint depth;
>  GdkColormap *colormap;
>
>  GtkThemeEngine *engine;
>
>  gpointer engine_data;
>
>  GtkRcStyle *rc_style;
>
>
>  GSList *styles;
>};
>
>struct _GtkStyleClass
>{
>  gint xthickness;
>  gint ythickness;
>
>  void (*draw_hline) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x1,
>                                 gint x2,
>                                 gint y);
>  void (*draw_vline) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint y1,
>                                 gint y2,
>                                 gint x);
>  void (*draw_shadow) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_polygon) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 GdkPoint *point,
>                                 gint npoints,
>                                 gboolean fill);
>  void (*draw_arrow) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 GtkArrowType arrow_type,
>                                 gboolean fill,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_diamond) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_oval) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_string) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 const gchar *string);
>  void (*draw_box) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_flat_box) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_check) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_option) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_cross) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_ramp) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 GtkArrowType arrow_type,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_tab) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_shadow_gap) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height,
>                                 GtkPositionType gap_side,
>                                 gint gap_x,
>                                 gint gap_width);
>  void (*draw_box_gap) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height,
>                                 GtkPositionType gap_side,
>                                 gint gap_x,
>                                 gint gap_width);
>  void (*draw_extension) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height,
>                                 GtkPositionType gap_side);
>  void (*draw_focus) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height);
>  void (*draw_slider) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height,
>                                 GtkOrientation orientation);
>  void (*draw_handle) (GtkStyle *style,
>                                 GdkWindow *window,
>                                 GtkStateType state_type,
>                                 GtkShadowType shadow_type,
>                                 GdkRectangle *area,
>                                 GtkWidget *widget,
>                                 gchar *detail,
>                                 gint x,
>                                 gint y,
>                                 gint width,
>                                 gint height,
>                                 GtkOrientation orientation);
>};
>
>GtkStyle* gtk_style_new (void);
>GtkStyle* gtk_style_copy (GtkStyle *style);
>GtkStyle* gtk_style_attach (GtkStyle *style,
>                                              GdkWindow *window);
>void gtk_style_detach (GtkStyle *style);
>GtkStyle* gtk_style_ref (GtkStyle *style);
>void gtk_style_unref (GtkStyle *style);
>void gtk_style_set_background (GtkStyle *style,
>                                              GdkWindow *window,
>                                              GtkStateType state_type);
>void gtk_style_apply_default_background (GtkStyle *style,
>                                              GdkWindow *window,
>                                              gboolean set_bg,
>                                              GtkStateType state_type,
>                                              GdkRectangle *area,
>                                              gint x,
>                                              gint y,
>                                              gint width,
>                                              gint height);
>
>void gtk_draw_hline (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       gint x1,
>                       gint x2,
>                       gint y);
>void gtk_draw_vline (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       gint y1,
>                       gint y2,
>                       gint x);
>void gtk_draw_shadow (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_polygon (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       GdkPoint *points,
>                       gint npoints,
>                       gboolean fill);
>void gtk_draw_arrow (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       GtkArrowType arrow_type,
>                       gboolean fill,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_diamond (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_oval (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_string (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       gint x,
>                       gint y,
>                       const gchar *string);
>void gtk_draw_box (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_flat_box (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_draw_check (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_option (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_cross (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_ramp (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       GtkArrowType arrow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_tab (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_shadow_gap (GtkStyle *style,
>                          GdkWindow *window,
>                          GtkStateType state_type,
>                          GtkShadowType shadow_type,
>                          gint x,
>                          gint y,
>                          gint width,
>                          gint height,
>                          GtkPositionType gap_side,
>                          gint gap_x,
>                          gint gap_width);
>void gtk_draw_box_gap (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height,
>                       GtkPositionType gap_side,
>                       gint gap_x,
>                       gint gap_width);
>void gtk_draw_extension (GtkStyle *style,
>                         GdkWindow *window,
>                         GtkStateType state_type,
>                         GtkShadowType shadow_type,
>                         gint x,
>                         gint y,
>                         gint width,
>                         gint height,
>                         GtkPositionType gap_side);
>void gtk_draw_focus (GtkStyle *style,
>                       GdkWindow *window,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height);
>void gtk_draw_slider (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height,
>                       GtkOrientation orientation);
>void gtk_draw_handle (GtkStyle *style,
>                       GdkWindow *window,
>                       GtkStateType state_type,
>                       GtkShadowType shadow_type,
>                       gint x,
>                       gint y,
>                       gint width,
>                       gint height,
>                       GtkOrientation orientation);
>
>void gtk_paint_hline (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x1,
>                        gint x2,
>                        gint y);
>void gtk_paint_vline (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint y1,
>                        gint y2,
>                        gint x);
>void gtk_paint_shadow (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_polygon (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        GdkPoint *points,
>                        gint npoints,
>                        gboolean fill);
>void gtk_paint_arrow (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        GtkArrowType arrow_type,
>                        gboolean fill,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_diamond (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_oval (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_string (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        const gchar *string);
>void gtk_paint_box (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_flat_box (GtkStyle *style,
>                         GdkWindow *window,
>                         GtkStateType state_type,
>                         GtkShadowType shadow_type,
>                         GdkRectangle *area,
>                         GtkWidget *widget,
>                         gchar *detail,
>                         gint x,
>                         gint y,
>                         gint width,
>                         gint height);
>void gtk_paint_check (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_option (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_cross (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_ramp (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        GtkArrowType arrow_type,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_tab (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_shadow_gap (GtkStyle *style,
>                           GdkWindow *window,
>                           GtkStateType state_type,
>                           GtkShadowType shadow_type,
>                           GdkRectangle *area,
>                           GtkWidget *widget,
>                           gchar *detail,
>                           gint x,
>                           gint y,
>                           gint width,
>                           gint height,
>                           GtkPositionType gap_side,
>                           gint gap_x,
>                           gint gap_width);
>void gtk_paint_box_gap (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height,
>                        GtkPositionType gap_side,
>                        gint gap_x,
>                        gint gap_width);
>void gtk_paint_extension (GtkStyle *style,
>                          GdkWindow *window,
>                          GtkStateType state_type,
>                          GtkShadowType shadow_type,
>                          GdkRectangle *area,
>                          GtkWidget *widget,
>                          gchar *detail,
>                          gint x,
>                          gint y,
>                          gint width,
>                          gint height,
>                          GtkPositionType gap_side);
>void gtk_paint_focus (GtkStyle *style,
>                        GdkWindow *window,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height);
>void gtk_paint_slider (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height,
>                        GtkOrientation orientation);
>void gtk_paint_handle (GtkStyle *style,
>                        GdkWindow *window,
>                        GtkStateType state_type,
>                        GtkShadowType shadow_type,
>                        GdkRectangle *area,
>                        GtkWidget *widget,
>                        gchar *detail,
>                        gint x,
>                        gint y,
>                        gint width,
>                        gint height,
>                        GtkOrientation orientation);
>
>
>
>
>
>void gtk_style_set_prop_experimental (GtkStyle *style,
>                                      const gchar *name,
>                                      gint value);
>gint gtk_style_get_prop_experimental (GtkStyle *style,
>                                      const gchar *name,
>                                      gint default_value);
># 35 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h" 2
># 45 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h"
>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_COMPOSITE_CHILD = 1 << 17,
>  GTK_NO_REPARENT = 1 << 18,
>  GTK_APP_PAINTABLE = 1 << 19,
>
>
>
>  GTK_RECEIVES_DEFAULT = 1 << 20
>} GtkWidgetFlags;
># 121 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h"
>typedef struct _GtkRequisition GtkRequisition;
>typedef struct _GtkAllocation GtkAllocation;
>typedef struct _GtkSelectionData GtkSelectionData;
>typedef struct _GtkWidgetClass GtkWidgetClass;
>typedef struct _GtkWidgetAuxInfo GtkWidgetAuxInfo;
>typedef struct _GtkWidgetShapeInfo GtkWidgetShapeInfo;
>
>typedef void (*GtkCallback) (GtkWidget *widget,
>                             gpointer data);
>
>
>
>
>struct _GtkRequisition
>{
>  gint16 width;
>  gint16 height;
>};
>
>
>
>
>
>struct _GtkAllocation
>{
>  gint16 x;
>  gint16 y;
>  guint16 width;
>  guint16 height;
>};
># 161 "/usr/X11R6/include/gtk12/gtk/gtkwidget.h"
>struct _GtkSelectionData
>{
>  GdkAtom selection;
>  GdkAtom target;
>  GdkAtom type;
>  gint format;
>  guchar *data;
>  gint length;
>};
>
>
>
>
>
>
>struct _GtkWidget
>{
>
>
>
>
>
>
>  GtkObject object;
>
>
>
>
>
>
>  guint16 private_flags;
>
>
>
>
>  guint8 state;
>
>
>
>
>
>
>
>  guint8 saved_state;
>
>
>
>
>
>
>
>  gchar *name;
>
>
>
>
>
>
>  GtkStyle *style;
>
>
>
>  GtkRequisition requisition;
>
>
>
>  GtkAllocation allocation;
>
>
>
>
>
>  GdkWindow *window;
>
>
>
>  GtkWidget *parent;
>};
>
>struct _GtkWidgetClass
>{
>
>
>
>
>
>
>  GtkObjectClass parent_class;
>
>
>
>
>
>  guint activate_signal;
>
>
>
>
>
>
>  guint set_scroll_adjustments_signal;
>
>
>  void (* show) (GtkWidget *widget);
>  void (* show_all) (GtkWidget *widget);
>  void (* hide) (GtkWidget *widget);
>  void (* hide_all) (GtkWidget *widget);
>  void (* map) (GtkWidget *widget);
>  void (* unmap) (GtkWidget *widget);
>  void (* realize) (GtkWidget *widget);
>  void (* unrealize) (GtkWidget *widget);
>  void (* draw) (GtkWidget *widget,
>                                GdkRectangle *area);
>  void (* draw_focus) (GtkWidget *widget);
>  void (* draw_default) (GtkWidget *widget);
>  void (* size_request) (GtkWidget *widget,
>                                GtkRequisition *requisition);
>  void (* size_allocate) (GtkWidget *widget,
>                                GtkAllocation *allocation);
>  void (* state_changed) (GtkWidget *widget,
>                                GtkStateType previous_state);
>  void (* parent_set) (GtkWidget *widget,
>                                GtkWidget *previous_parent);
>  void (* style_set) (GtkWidget *widget,
>                                GtkStyle *previous_style);
>
>
>  gint (* add_accelerator) (GtkWidget *widget,
>                                guint accel_signal_id,
>                                GtkAccelGroup *accel_group,
>                                guint accel_key,
>                                GdkModifierType accel_mods,
>                                GtkAccelFlags accel_flags);
>  void (* remove_accelerator) (GtkWidget *widget,
>                                GtkAccelGroup *accel_group,
>                                guint accel_key,
>                                GdkModifierType accel_mods);
>
>
>  void (* grab_focus) (GtkWidget *widget);
>
>
>  gint (* event) (GtkWidget *widget,
>                                    GdkEvent *event);
>  gint (* button_press_event) (GtkWidget *widget,
>                                    GdkEventButton *event);
>  gint (* button_release_event) (GtkWidget *widget,
>                                    GdkEventButton *event);
>  gint (* motion_notify_event) (GtkWidget *widget,
>                                    GdkEventMotion *event);
>  gint (* delete_event) (GtkWidget *widget,
>                                    GdkEventAny *event);
>  gint (* destroy_event) (GtkWidget *widget,
>                                    GdkEventAny *event);
>  gint (* expose_event) (GtkWidget *widget,
>                                    GdkEventExpose *event);
>  gint (* key_press_event) (GtkWidget *widget,
>                                    GdkEventKey *event);
>  gint (* key_release_event) (GtkWidget *widget,
>                                    GdkEventKey *event);
>  gint (* enter_notify_event) (GtkWidget *widget,
>                                    GdkEventCrossing *event);
>  gint (* leave_notify_event) (GtkWidget *widget,
>                                    GdkEventCrossing *event);
>  gint (* configure_event) (GtkWidget *widget,
>                                    GdkEventConfigure *event);
>  gint (* focus_in_event) (GtkWidget *widget,
>                                    GdkEventFocus *event);
>  gint (* focus_out_event) (GtkWidget *widget,
>                                    GdkEventFocus *event);
>  gint (* map_event) (GtkWidget *widget,
>                                    GdkEventAny *event);
>  gint (* unmap_event) (GtkWidget *widget,
>                                    GdkEventAny *event);
>  gint (* property_notify_event) (GtkWidget *widget,
>                                    GdkEventProperty *event);
>  gint (* selection_clear_event) (GtkWidget *widget,
>                                    GdkEventSelection *event);
>  gint (* selection_request_event) (GtkWidget *widget,
>                                    GdkEventSelection *event);
>  gint (* selection_notify_event) (GtkWidget *widget,
>                                    GdkEventSelection *event);
>  gint (* proximity_in_event) (GtkWidget *widget,
>                                    GdkEventProximity *event);
>  gint (* proximity_out_event) (GtkWidget *widget,
>                                    GdkEventProximity *event);
>  gint (* visibility_notify_event) (GtkWidget *widget,
>                                     GdkEventVisibility *event);
>  gint (* client_event) (GtkWidget *widget,
>                                    GdkEventClient *event);
>  gint (* no_expose_event) (GtkWidget *widget,
>                                    GdkEventAny *event);
>
>
>  void (* selection_get) (GtkWidget *widget,
>                                    GtkSelectionData *selection_data,
>                                    guint info,
>                                    guint time);
>  void (* selection_received) (GtkWidget *widget,
>                                    GtkSelectionData *selection_data,
>                                    guint time);
>
>
>  void (* drag_begin) (GtkWidget *widget,
>                                    GdkDragContext *context);
>  void (* drag_end) (GtkWidget *widget,
>                                    GdkDragContext *context);
>  void (* drag_data_get) (GtkWidget *widget,
>                                    GdkDragContext *context,
>                                    GtkSelectionData *selection_data,
>                                    guint info,
>                                    guint time);
>  void (* drag_data_delete) (GtkWidget *widget,
>                                    GdkDragContext *context);
>
>
>  void (* drag_leave) (GtkWidget *widget,
>                                    GdkDragContext *context,
>                                    guint time);
>  gboolean (* drag_motion) (GtkWidget *widget,
>                                    GdkDragContext *context,
>                                    gint x,
>                                    gint y,
>                                    guint time);
>  gboolean (* drag_drop) (GtkWidget *widget,
>                                    GdkDragContext *context,
>                                    gint x,
>                                    gint y,
>                                    guint time);
>  void (* drag_data_received) (GtkWidget *widget,
>                                    GdkDragContext *context,
>                                    gint x,
>                                    gint y,
>                                    GtkSelectionData *selection_data,
>                                    guint info,
>                                    guint time);
>
>
>  void (* debug_msg) (GtkWidget *widget,
>                                    const gchar *string);
>
>
>  GtkFunction pad1;
>  GtkFunction pad2;
>  GtkFunction pad3;
>  GtkFunction pad4;
>};
>
>struct _GtkWidgetAuxInfo
>{
>  gint16 x;
>  gint16 y;
>  gint16 width;
>  gint16 height;
>};
>
>struct _GtkWidgetShapeInfo
>{
>  gint16 offset_x;
>  gint16 offset_y;
>  GdkBitmap *shape_mask;
>};
>
>
>GtkType gtk_widget_get_type (void);
>GtkWidget* gtk_widget_new (GtkType type,
>                                           const gchar *first_arg_name,
>                                           ...);
>GtkWidget* gtk_widget_newv (GtkType type,
>                                           guint nargs,
>                                           GtkArg *args);
>void gtk_widget_ref (GtkWidget *widget);
>void gtk_widget_unref (GtkWidget *widget);
>void gtk_widget_destroy (GtkWidget *widget);
>void gtk_widget_destroyed (GtkWidget *widget,
>                                           GtkWidget **widget_pointer);
>void gtk_widget_get (GtkWidget *widget,
>                                           GtkArg *arg);
>void gtk_widget_getv (GtkWidget *widget,
>                                           guint nargs,
>                                           GtkArg *args);
>void gtk_widget_set (GtkWidget *widget,
>                                           const gchar *first_arg_name,
>                                           ...);
>void gtk_widget_setv (GtkWidget *widget,
>                                           guint nargs,
>                                           GtkArg *args);
>void gtk_widget_unparent (GtkWidget *widget);
>void gtk_widget_show (GtkWidget *widget);
>void gtk_widget_show_now (GtkWidget *widget);
>void gtk_widget_hide (GtkWidget *widget);
>void gtk_widget_show_all (GtkWidget *widget);
>void gtk_widget_hide_all (GtkWidget *widget);
>void gtk_widget_map (GtkWidget *widget);
>void gtk_widget_unmap (GtkWidget *widget);
>void gtk_widget_realize (GtkWidget *widget);
>void gtk_widget_unrealize (GtkWidget *widget);
>
>
>void gtk_widget_queue_draw (GtkWidget *widget);
>void gtk_widget_queue_draw_area (GtkWidget *widget,
>                                           gint x,
>                                           gint y,
>                                           gint width,
>                                           gint height);
>void gtk_widget_queue_clear (GtkWidget *widget);
>void gtk_widget_queue_clear_area (GtkWidget *widget,
>                                           gint x,
>                                           gint y,
>                                           gint width,
>                                           gint height);
>
>
>void gtk_widget_queue_resize (GtkWidget *widget);
>void gtk_widget_draw (GtkWidget *widget,
>                                           GdkRectangle *area);
>void gtk_widget_draw_focus (GtkWidget *widget);
>void gtk_widget_draw_default (GtkWidget *widget);
>void gtk_widget_size_request (GtkWidget *widget,
>                                           GtkRequisition *requisition);
>void gtk_widget_size_allocate (GtkWidget *widget,
>                                           GtkAllocation *allocation);
>void gtk_widget_get_child_requisition (GtkWidget *widget,
>                                             GtkRequisition *requisition);
>void gtk_widget_add_accelerator (GtkWidget *widget,
>                                           const gchar *accel_signal,
>                                           GtkAccelGroup *accel_group,
>                                           guint accel_key,
>                                           guint accel_mods,
>                                           GtkAccelFlags accel_flags);
>void gtk_widget_remove_accelerator (GtkWidget *widget,
>                                           GtkAccelGroup *accel_group,
>                                           guint accel_key,
>                                           guint accel_mods);
>void gtk_widget_remove_accelerators (GtkWidget *widget,
>                                           const gchar *accel_signal,
>                                           gboolean visible_only);
>guint gtk_widget_accelerator_signal (GtkWidget *widget,
>                                           GtkAccelGroup *accel_group,
>                                           guint accel_key,
>                                           guint accel_mods);
>void gtk_widget_lock_accelerators (GtkWidget *widget);
>void gtk_widget_unlock_accelerators (GtkWidget *widget);
>gboolean gtk_widget_accelerators_locked (GtkWidget *widget);
>gint gtk_widget_event (GtkWidget *widget,
>                                           GdkEvent *event);
>
>gboolean gtk_widget_activate (GtkWidget *widget);
>gboolean gtk_widget_set_scroll_adjustments (GtkWidget *widget,
>                                              GtkAdjustment *hadjustment,
>                                              GtkAdjustment *vadjustment);
>
>void gtk_widget_reparent (GtkWidget *widget,
>                                           GtkWidget *new_parent);
>void gtk_widget_popup (GtkWidget *widget,
>                                           gint x,
>                                           gint y);
>gint gtk_widget_intersect (GtkWidget *widget,
>                                           GdkRectangle *area,
>                                           GdkRectangle *intersection);
>
>void gtk_widget_grab_focus (GtkWidget *widget);
>void gtk_widget_grab_default (GtkWidget *widget);
>
>void gtk_widget_set_name (GtkWidget *widget,
>                                           const gchar *name);
>gchar* gtk_widget_get_name (GtkWidget *widget);
>void gtk_widget_set_state (GtkWidget *widget,
>                                           GtkStateType state);
>void gtk_widget_set_sensitive (GtkWidget *widget,
>                                           gboolean sensitive);
>void gtk_widget_set_app_paintable (GtkWidget *widget,
>                                           gboolean app_paintable);
>void gtk_widget_set_parent (GtkWidget *widget,
>                                           GtkWidget *parent);
>void gtk_widget_set_parent_window (GtkWidget *widget,
>                                           GdkWindow *parent_window);
>GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget);
>void gtk_widget_set_uposition (GtkWidget *widget,
>                                           gint x,
>                                           gint y);
>void gtk_widget_set_usize (GtkWidget *widget,
>                                           gint width,
>                                           gint height);
>void gtk_widget_set_events (GtkWidget *widget,
>                                           gint events);
>void gtk_widget_add_events (GtkWidget *widget,
>                                           gint events);
>void gtk_widget_set_extension_events (GtkWidget *widget,
>                                            GdkExtensionMode mode);
>
>GdkExtensionMode gtk_widget_get_extension_events (GtkWidget *widget);
>GtkWidget* gtk_widget_get_toplevel (GtkWidget *widget);
>GtkWidget* gtk_widget_get_ancestor (GtkWidget *widget,
>                                         GtkType widget_type);
>GdkColormap* gtk_widget_get_colormap (GtkWidget *widget);
>GdkVisual* gtk_widget_get_visual (GtkWidget *widget);
>
>
>
>
>
>
>
>void gtk_widget_set_colormap (GtkWidget *widget,
>                                         GdkColormap *colormap);
>void gtk_widget_set_visual (GtkWidget *widget,
>                                         GdkVisual *visual);
>
>
>gint gtk_widget_get_events (GtkWidget *widget);
>void gtk_widget_get_pointer (GtkWidget *widget,
>                                         gint *x,
>                                         gint *y);
>
>gboolean gtk_widget_is_ancestor (GtkWidget *widget,
>                                         GtkWidget *ancestor);
>
>
>
>gint gtk_widget_hide_on_delete (GtkWidget *widget);
>
>
>
>void gtk_widget_set_style (GtkWidget *widget,
>                                         GtkStyle *style);
>void gtk_widget_set_rc_style (GtkWidget *widget);
>void gtk_widget_ensure_style (GtkWidget *widget);
>GtkStyle* gtk_widget_get_style (GtkWidget *widget);
>void gtk_widget_restore_default_style (GtkWidget *widget);
>
>void gtk_widget_modify_style (GtkWidget *widget,
>                                         GtkRcStyle *style);
>
>
>
>
>void gtk_widget_set_composite_name (GtkWidget *widget,
>                                         const gchar *name);
>gchar* gtk_widget_get_composite_name (GtkWidget *widget);
>
>
>void gtk_widget_reset_rc_styles (GtkWidget *widget);
>
>
>
>
>
>void gtk_widget_push_style (GtkStyle *style);
>void gtk_widget_push_colormap (GdkColormap *cmap);
>void gtk_widget_push_visual (GdkVisual *visual);
>void gtk_widget_push_composite_child (void);
>void gtk_widget_pop_composite_child (void);
>void gtk_widget_pop_style (void);
>void gtk_widget_pop_colormap (void);
>void gtk_widget_pop_visual (void);
>
>
>
>void gtk_widget_set_default_style (GtkStyle *style);
>void gtk_widget_set_default_colormap (GdkColormap *colormap);
>void gtk_widget_set_default_visual (GdkVisual *visual);
>GtkStyle* gtk_widget_get_default_style (void);
>GdkColormap* gtk_widget_get_default_colormap (void);
>GdkVisual* gtk_widget_get_default_visual (void);
>
>
>
>void gtk_widget_shape_combine_mask (GtkWidget *widget,
>                                            GdkBitmap *shape_mask,
>                                            gint offset_x,
>                                            gint offset_y);
>
>
>void gtk_widget_reset_shapes (GtkWidget *widget);
>
>
>
>
>void gtk_widget_path (GtkWidget *widget,
>                                            guint *path_length,
>                                            gchar **path,
>                                            gchar **path_reversed);
>void gtk_widget_class_path (GtkWidget *widget,
>                                            guint *path_length,
>                                            gchar **path,
>                                            gchar **path_reversed);
># 23 "gtkcauldron.h" 2
># 1 "../libgnome/gnome-defs.h" 1
># 24 "gtkcauldron.h" 2
>
>
># 55 "gtkcauldron.h"
>typedef void (*GtkCauldronNextArgCallback) (gint cauldron_type, gpointer user_data, void *result);
>
>
>enum {
>    GTK_CAULDRON_TYPE_CHAR_P,
>    GTK_CAULDRON_TYPE_CHAR_P_P,
>    GTK_CAULDRON_TYPE_INT,
>    GTK_CAULDRON_TYPE_INT_P,
>    GTK_CAULDRON_TYPE_USERDATA_P,
>    GTK_CAULDRON_TYPE_DOUBLE,
>    GTK_CAULDRON_TYPE_DOUBLE_P,
>    GTK_CAULDRON_TYPE_CALLBACK
>};
>
>extern gchar *GTK_CAULDRON_ENTER;
>extern gchar *GTK_CAULDRON_ESCAPE;
>
>
>
>typedef GtkWidget *(*GtkCauldronCustomCallback) (GtkWidget * widget, gpointer user_data);
>
>
>gchar *gtk_dialog_cauldron_get_error (void);
>
>
>gchar *gtk_dialog_cauldron (const gchar * title, glong options, ...);
># 89 "gtkcauldron.h"
>gchar *gtk_dialog_cauldron_parse (const gchar * title, glong options,
>                                  const gchar * format,
>                                  GtkCauldronNextArgCallback next_arg,
>                                  gpointer user_data,
>                                  GtkWidget *parent);
>
>
># 21 "gtkcauldron.c" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtk.h" 1
># 33 "/usr/X11R6/include/gtk12/gtk/gtk.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkaccellabel.h" 1
># 34 "/usr/X11R6/include/gtk12/gtk/gtkaccellabel.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtklabel.h" 1
># 31 "/usr/X11R6/include/gtk12/gtk/gtklabel.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmisc.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkmisc.h"
>typedef struct _GtkMisc GtkMisc;
>typedef struct _GtkMiscClass GtkMiscClass;
>
>struct _GtkMisc
>{
>  GtkWidget widget;
>
>  gfloat xalign;
>  gfloat yalign;
>
>  guint16 xpad;
>  guint16 ypad;
>};
>
>struct _GtkMiscClass
>{
>  GtkWidgetClass parent_class;
>};
>
>
>GtkType gtk_misc_get_type (void);
>void gtk_misc_set_alignment (GtkMisc *misc,
>                                gfloat xalign,
>                                gfloat yalign);
>void gtk_misc_set_padding (GtkMisc *misc,
>                                gint xpad,
>                                gint ypad);
># 32 "/usr/X11R6/include/gtk12/gtk/gtklabel.h" 2
># 46 "/usr/X11R6/include/gtk12/gtk/gtklabel.h"
>typedef struct _GtkLabel GtkLabel;
>typedef struct _GtkLabelClass GtkLabelClass;
>
>typedef struct _GtkLabelWord GtkLabelWord;
>
>struct _GtkLabel
>{
>  GtkMisc misc;
>
>  gchar *label;
>  GdkWChar *label_wc;
>  gchar *pattern;
>
>  GtkLabelWord *words;
>
>  guint max_width : 16;
>  guint jtype : 2;
>  gboolean wrap;
>};
>
>struct _GtkLabelClass
>{
>  GtkMiscClass parent_class;
>};
>
>
>GtkType gtk_label_get_type (void);
>GtkWidget* gtk_label_new (const gchar *str);
>void gtk_label_set_text (GtkLabel *label,
>                                    const gchar *str);
>void gtk_label_set_justify (GtkLabel *label,
>                                    GtkJustification jtype);
>void gtk_label_set_pattern (GtkLabel *label,
>                                    const gchar *pattern);
>void gtk_label_set_line_wrap (GtkLabel *label,
>                                    gboolean wrap);
>void gtk_label_get (GtkLabel *label,
>                                    gchar **str);
>
>
>
>
>
>guint gtk_label_parse_uline (GtkLabel *label,
>                                     const gchar *string);
># 35 "/usr/X11R6/include/gtk12/gtk/gtkaccellabel.h" 2
># 49 "/usr/X11R6/include/gtk12/gtk/gtkaccellabel.h"
>typedef struct _GtkAccelLabel GtkAccelLabel;
>typedef struct _GtkAccelLabelClass GtkAccelLabelClass;
>
>struct _GtkAccelLabel
>{
>  GtkLabel label;
>
>  guint queue_id;
>  guint accel_padding;
>  GtkWidget *accel_widget;
>  gchar *accel_string;
>  guint16 accel_string_width;
>};
>
>struct _GtkAccelLabelClass
>{
>  GtkLabelClass parent_class;
>
>  gchar *signal_quote1;
>  gchar *signal_quote2;
>  gchar *mod_name_shift;
>  gchar *mod_name_control;
>  gchar *mod_name_alt;
>  gchar *mod_separator;
>  gchar *accel_seperator;
>  guint latin1_to_char : 1;
>};
>
>
>GtkType gtk_accel_label_get_type (void);
>GtkWidget* gtk_accel_label_new (const gchar *string);
>guint gtk_accel_label_get_accel_width (GtkAccelLabel *accel_label);
>void gtk_accel_label_set_accel_widget (GtkAccelLabel *accel_label,
>                                              GtkWidget *accel_widget);
>gboolean gtk_accel_label_refetch (GtkAccelLabel *accel_label);
># 34 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkalignment.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkalignment.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkbin.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkbin.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcontainer.h" 1
># 51 "/usr/X11R6/include/gtk12/gtk/gtkcontainer.h"
>typedef struct _GtkContainer GtkContainer;
>typedef struct _GtkContainerClass GtkContainerClass;
>
>struct _GtkContainer
>{
>  GtkWidget widget;
>
>  GtkWidget *focus_child;
>
>  guint border_width : 16;
>  guint need_resize : 1;
>  guint resize_mode : 2;
>  guint reallocate_redraws : 1;
>
>
>
>  GSList *resize_widgets;
>};
>
>struct _GtkContainerClass
>{
>  GtkWidgetClass parent_class;
>
>  guint n_child_args;
>
>  void (* add) (GtkContainer *container,
>                                 GtkWidget *widget);
>  void (* remove) (GtkContainer *container,
>                                 GtkWidget *widget);
>  void (* check_resize) (GtkContainer *container);
>  void (* forall) (GtkContainer *container,
>                                 gboolean include_internals,
>                                 GtkCallback callback,
>                                 gpointer callbabck_data);
>  gint (* focus) (GtkContainer *container,
>                                 GtkDirectionType direction);
>  void (* set_focus_child) (GtkContainer *container,
>                                 GtkWidget *widget);
>  GtkType (*child_type) (GtkContainer *container);
>  void (*set_child_arg) (GtkContainer *container,
>                                 GtkWidget *child,
>                                 GtkArg *arg,
>                                 guint arg_id);
>  void (*get_child_arg) (GtkContainer *container,
>                                 GtkWidget *child,
>                                 GtkArg *arg,
>                                 guint arg_id);
>  gchar* (*composite_name) (GtkContainer *container,
>                                 GtkWidget *child);
>
>
>  GtkFunction pad1;
>  GtkFunction pad2;
>};
>
>
>
>GtkType gtk_container_get_type (void);
>void gtk_container_set_border_width (GtkContainer *container,
>                                          guint border_width);
>void gtk_container_add (GtkContainer *container,
>                                          GtkWidget *widget);
>void gtk_container_remove (GtkContainer *container,
>                                          GtkWidget *widget);
>
>void gtk_container_set_resize_mode (GtkContainer *container,
>                                          GtkResizeMode resize_mode);
>
>void gtk_container_check_resize (GtkContainer *container);
>
>void gtk_container_foreach (GtkContainer *container,
>                                          GtkCallback callback,
>                                          gpointer callback_data);
>void gtk_container_foreach_full (GtkContainer *container,
>                                          GtkCallback callback,
>                                          GtkCallbackMarshal marshal,
>                                          gpointer callback_data,
>                                          GtkDestroyNotify notify);
>GList* gtk_container_children (GtkContainer *container);
>gint gtk_container_focus (GtkContainer *container,
>                                            GtkDirectionType direction);
>
>
>
>void gtk_container_set_reallocate_redraws (GtkContainer *container,
>                                             gboolean needs_redraws);
>void gtk_container_set_focus_child (GtkContainer *container,
>                                            GtkWidget *child);
>void gtk_container_set_focus_vadjustment (GtkContainer *container,
>                                            GtkAdjustment *adjustment);
>void gtk_container_set_focus_hadjustment (GtkContainer *container,
>                                            GtkAdjustment *adjustment);
>void gtk_container_register_toplevel (GtkContainer *container);
>void gtk_container_unregister_toplevel (GtkContainer *container);
>GList* gtk_container_get_toplevels (void);
>
>void gtk_container_resize_children (GtkContainer *container);
>
>GtkType gtk_container_child_type (GtkContainer *container);
>
>
>void gtk_container_add_child_arg_type (const gchar *arg_name,
>                                            GtkType arg_type,
>                                            guint arg_flags,
>                                            guint arg_id);
># 166 "/usr/X11R6/include/gtk12/gtk/gtkcontainer.h"
>GtkArg* gtk_container_query_child_args (GtkType class_type,
>                                            guint32 **arg_flags,
>                                            guint *nargs);
>
>
>
>
>
>
>void gtk_container_child_getv (GtkContainer *container,
>                                            GtkWidget *child,
>                                            guint n_args,
>                                            GtkArg *args);
>void gtk_container_child_setv (GtkContainer *container,
>                                            GtkWidget *child,
>                                            guint n_args,
>                                            GtkArg *args);
>
>
>
>
>
>
>void gtk_container_add_with_args (GtkContainer *container,
>                                            GtkWidget *widget,
>                                            const gchar *first_arg_name,
>                                            ...);
>void gtk_container_addv (GtkContainer *container,
>                                            GtkWidget *widget,
>                                            guint n_args,
>                                            GtkArg *args);
>void gtk_container_child_set (GtkContainer *container,
>                                            GtkWidget *child,
>                                            const gchar *first_arg_name,
>                                            ...);
>
>
>
>
>void gtk_container_queue_resize (GtkContainer *container);
>void gtk_container_clear_resize_widgets (GtkContainer *container);
>void gtk_container_arg_set (GtkContainer *container,
>                                              GtkWidget *child,
>                                              GtkArg *arg,
>                                              GtkArgInfo *info);
>void gtk_container_arg_get (GtkContainer *container,
>                                              GtkWidget *child,
>                                              GtkArg *arg,
>                                              GtkArgInfo *info);
>gchar* gtk_container_child_args_collect (GtkType object_type,
>                                              GSList **arg_list_p,
>                                              GSList **info_list_p,
>                                              const gchar *first_arg_name,
>                                              va_list args);
>gchar* gtk_container_child_arg_get_info (GtkType object_type,
>                                              const gchar *arg_name,
>                                              GtkArgInfo **info_p);
>void gtk_container_forall (GtkContainer *container,
>                                              GtkCallback callback,
>                                              gpointer callback_data);
>gchar* gtk_container_child_composite_name (GtkContainer *container,
>                                              GtkWidget *child);
>void gtk_container_dequeue_resize_handler (GtkContainer *container);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkbin.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkbin.h"
>typedef struct _GtkBin GtkBin;
>typedef struct _GtkBinClass GtkBinClass;
>
>struct _GtkBin
>{
>  GtkContainer container;
>
>  GtkWidget *child;
>};
>
>struct _GtkBinClass
>{
>  GtkContainerClass parent_class;
>};
>
>
>GtkType gtk_bin_get_type (void);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkalignment.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkalignment.h"
>typedef struct _GtkAlignment GtkAlignment;
>typedef struct _GtkAlignmentClass GtkAlignmentClass;
>
>struct _GtkAlignment
>{
>  GtkBin bin;
>
>  gfloat xalign;
>  gfloat yalign;
>  gfloat xscale;
>  gfloat yscale;
>};
>
>struct _GtkAlignmentClass
>{
>  GtkBinClass parent_class;
>};
>
>
>GtkType gtk_alignment_get_type (void);
>GtkWidget* gtk_alignment_new (gfloat xalign,
>                                     gfloat yalign,
>                                     gfloat xscale,
>                                     gfloat yscale);
>void gtk_alignment_set (GtkAlignment *alignment,
>                                     gfloat xalign,
>                                     gfloat yalign,
>                                     gfloat xscale,
>                                     gfloat yscale);
># 36 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkaspectframe.h" 1
># 33 "/usr/X11R6/include/gtk12/gtk/gtkaspectframe.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkframe.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkframe.h"
>typedef struct _GtkFrame GtkFrame;
>typedef struct _GtkFrameClass GtkFrameClass;
>
>struct _GtkFrame
>{
>  GtkBin bin;
>
>  gchar *label;
>  gint16 shadow_type;
>  gint16 label_width;
>  gint16 label_height;
>  gfloat label_xalign;
>  gfloat label_yalign;
>};
>
>struct _GtkFrameClass
>{
>  GtkBinClass parent_class;
>};
>
>
>GtkType gtk_frame_get_type (void);
>GtkWidget* gtk_frame_new (const gchar *label);
>void gtk_frame_set_label (GtkFrame *frame,
>                                      const gchar *label);
>void gtk_frame_set_label_align (GtkFrame *frame,
>                                      gfloat xalign,
>                                      gfloat yalign);
>void gtk_frame_set_shadow_type (GtkFrame *frame,
>                                      GtkShadowType type);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkaspectframe.h" 2
># 48 "/usr/X11R6/include/gtk12/gtk/gtkaspectframe.h"
>typedef struct _GtkAspectFrame GtkAspectFrame;
>typedef struct _GtkAspectFrameClass GtkAspectFrameClass;
>
>struct _GtkAspectFrame
>{
>  GtkFrame frame;
>
>  gfloat xalign;
>  gfloat yalign;
>  gfloat ratio;
>  gboolean obey_child;
>
>  GtkAllocation center_allocation;
>};
>
>struct _GtkAspectFrameClass
>{
>  GtkBinClass parent_class;
>};
>
>
>GtkType gtk_aspect_frame_get_type (void);
>GtkWidget* gtk_aspect_frame_new (const gchar *label,
>                                        gfloat xalign,
>                                        gfloat yalign,
>                                        gfloat ratio,
>                                        gboolean obey_child);
>void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame,
>                                        gfloat xalign,
>                                        gfloat yalign,
>                                        gfloat ratio,
>                                        gboolean obey_child);
># 38 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkarrow.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkarrow.h"
>typedef struct _GtkArrow GtkArrow;
>typedef struct _GtkArrowClass GtkArrowClass;
>
>struct _GtkArrow
>{
>  GtkMisc misc;
>
>  gint16 arrow_type;
>  gint16 shadow_type;
>};
>
>struct _GtkArrowClass
>{
>  GtkMiscClass parent_class;
>};
>
>
>GtkType gtk_arrow_get_type (void);
>GtkWidget* gtk_arrow_new (GtkArrowType arrow_type,
>                                 GtkShadowType shadow_type);
>void gtk_arrow_set (GtkArrow *arrow,
>                                 GtkArrowType arrow_type,
>                                 GtkShadowType shadow_type);
># 39 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkbindings.h" 1
># 46 "/usr/X11R6/include/gtk12/gtk/gtkbindings.h"
>typedef struct _GtkPatternSpec GtkPatternSpec;
>
>struct _GtkPatternSpec
>{
>  GtkMatchType match_type;
>  guint pattern_length;
>  gchar *pattern;
>  gchar *pattern_reversed;
>  gpointer user_data;
>  guint seq_id;
>};
>
>void gtk_pattern_spec_init (GtkPatternSpec *pspec,
>                                     const gchar *pattern);
>void gtk_pattern_spec_free_segs (GtkPatternSpec *pspec);
>gboolean gtk_pattern_match (GtkPatternSpec *pspec,
>                                     guint string_length,
>                                     const gchar *string,
>                                     const gchar *string_reversed);
>gboolean gtk_pattern_match_string (GtkPatternSpec *pspec,
>                                     const gchar *string);
>gboolean gtk_pattern_match_simple (const gchar *pattern,
>                                     const gchar *string);
>
>
>
>
>
>typedef struct _GtkBindingSet GtkBindingSet;
>typedef struct _GtkBindingEntry GtkBindingEntry;
>typedef struct _GtkBindingSignal GtkBindingSignal;
>typedef struct _GtkBindingArg GtkBindingArg;
>
>struct _GtkBindingSet
>{
>  gchar *set_name;
>  gint priority;
>  GSList *widget_path_pspecs;
>  GSList *widget_class_pspecs;
>  GSList *class_branch_pspecs;
>  GtkBindingEntry *entries;
>  GtkBindingEntry *current;
>};
>
>struct _GtkBindingEntry
>{
>
>
>  guint keyval;
>  guint modifiers;
>
>  GtkBindingSet *binding_set;
>  guint destroyed : 1;
>  guint in_emission : 1;
>  GtkBindingEntry *set_next;
>  GtkBindingEntry *hash_next;
>  GtkBindingSignal *signals;
>};
>
>struct _GtkBindingSignal
>{
>  GtkBindingSignal *next;
>  gchar *signal_name;
>  guint n_args;
>  GtkBindingArg *args;
>};
>
>struct _GtkBindingArg
>{
>  GtkType arg_type;
>  union {
>    glong long_data;
>    gdouble double_data;
>    gchar *string_data;
>  } d;
>};
>
>
>
>
>GtkBindingSet* gtk_binding_set_new (const gchar *set_name);
>GtkBindingSet* gtk_binding_set_by_class(gpointer object_class);
>GtkBindingSet* gtk_binding_set_find (const gchar *set_name);
>gboolean gtk_bindings_activate (GtkObject *object,
>                                         guint keyval,
>                                         guint modifiers);
>gboolean gtk_binding_set_activate (GtkBindingSet *binding_set,
>                                         guint keyval,
>                                         guint modifiers,
>                                         GtkObject *object);
>
>void gtk_binding_entry_clear (GtkBindingSet *binding_set,
>                                         guint keyval,
>                                         guint modifiers);
>void gtk_binding_entry_add_signal (GtkBindingSet *binding_set,
>                                         guint keyval,
>                                         guint modifiers,
>                                         const gchar *signal_name,
>                                         guint n_args,
>                                         ...);
>void gtk_binding_set_add_path (GtkBindingSet *binding_set,
>                                         GtkPathType path_type,
>                                         const gchar *path_pattern,
>                                         GtkPathPriorityType priority);
>
>
>
>
>void gtk_binding_entry_remove (GtkBindingSet *binding_set,
>                                         guint keyval,
>                                         guint modifiers);
>void gtk_binding_entry_add_signall (GtkBindingSet *binding_set,
>                                         guint keyval,
>                                         guint modifiers,
>                                         const gchar *signal_name,
>                                         GSList *binding_args);
>guint gtk_binding_parse_binding (GScanner *scanner);
># 41 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkbox.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkbox.h"
>typedef struct _GtkBox GtkBox;
>typedef struct _GtkBoxClass GtkBoxClass;
>typedef struct _GtkBoxChild GtkBoxChild;
>
>struct _GtkBox
>{
>  GtkContainer container;
>
>  GList *children;
>  gint16 spacing;
>  guint homogeneous : 1;
>};
>
>struct _GtkBoxClass
>{
>  GtkContainerClass parent_class;
>};
>
>struct _GtkBoxChild
>{
>  GtkWidget *widget;
>  guint16 padding;
>  guint expand : 1;
>  guint fill : 1;
>  guint pack : 1;
>};
>
>
>GtkType gtk_box_get_type (void);
>void gtk_box_pack_start (GtkBox *box,
>                                        GtkWidget *child,
>                                        gboolean expand,
>                                        gboolean fill,
>                                        guint padding);
>void gtk_box_pack_end (GtkBox *box,
>                                        GtkWidget *child,
>                                        gboolean expand,
>                                        gboolean fill,
>                                        guint padding);
>void gtk_box_pack_start_defaults (GtkBox *box,
>                                        GtkWidget *widget);
>void gtk_box_pack_end_defaults (GtkBox *box,
>                                        GtkWidget *widget);
>void gtk_box_set_homogeneous (GtkBox *box,
>                                        gboolean homogeneous);
>void gtk_box_set_spacing (GtkBox *box,
>                                        gint spacing);
>void gtk_box_reorder_child (GtkBox *box,
>                                        GtkWidget *child,
>                                        gint position);
>void gtk_box_query_child_packing (GtkBox *box,
>                                        GtkWidget *child,
>                                        gboolean *expand,
>                                        gboolean *fill,
>                                        guint *padding,
>                                        GtkPackType *pack_type);
>void gtk_box_set_child_packing (GtkBox *box,
>                                        GtkWidget *child,
>                                        gboolean expand,
>                                        gboolean fill,
>                                        guint padding,
>                                        GtkPackType pack_type);
># 42 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkbbox.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkbbox.h"
>typedef struct _GtkButtonBox GtkButtonBox;
>typedef struct _GtkButtonBoxClass GtkButtonBoxClass;
>
>struct _GtkButtonBox
>{
>  GtkBox box;
>  gint spacing;
>  gint child_min_width;
>  gint child_min_height;
>  gint child_ipad_x;
>  gint child_ipad_y;
>  GtkButtonBoxStyle layout_style;
>};
>
>struct _GtkButtonBoxClass
>{
>  GtkBoxClass parent_class;
>};
>
>
>GtkType gtk_button_box_get_type (void);
>
>void gtk_button_box_get_child_size_default (gint *min_width, gint *min_height);
>void gtk_button_box_get_child_ipadding_default (gint *ipad_x, gint *ipad_y);
>
>void gtk_button_box_set_child_size_default (gint min_width, gint min_height);
>void gtk_button_box_set_child_ipadding_default (gint ipad_x, gint ipad_y);
>
>gint gtk_button_box_get_spacing (GtkButtonBox *widget);
>GtkButtonBoxStyle gtk_button_box_get_layout (GtkButtonBox *widget);
>void gtk_button_box_get_child_size (GtkButtonBox *widget,
>                                    gint *min_width, gint *min_height);
>void gtk_button_box_get_child_ipadding (GtkButtonBox *widget, gint *ipad_x, gint *ipad_y);
>
>void gtk_button_box_set_spacing (GtkButtonBox *widget, gint spacing);
>void gtk_button_box_set_layout (GtkButtonBox *widget,
>                                GtkButtonBoxStyle layout_style);
>void gtk_button_box_set_child_size (GtkButtonBox *widget,
>                                    gint min_width, gint min_height);
>void gtk_button_box_set_child_ipadding (GtkButtonBox *widget, gint ipad_x, gint ipad_y);
>
>
>
>void gtk_button_box_child_requisition (GtkWidget *widget,
>                                       int *nvis_children,
>                                       int *width,
>                                       int *height);
># 43 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkbutton.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkbutton.h"
>typedef struct _GtkButton GtkButton;
>typedef struct _GtkButtonClass GtkButtonClass;
>
>struct _GtkButton
>{
>  GtkBin bin;
>
>  GtkWidget *child ;
>
>
>
>  guint in_button : 1;
>  guint button_down : 1;
>  guint relief : 2;
>};
>
>struct _GtkButtonClass
>{
>  GtkBinClass parent_class;
>
>  void (* pressed) (GtkButton *button);
>  void (* released) (GtkButton *button);
>  void (* clicked) (GtkButton *button);
>  void (* enter) (GtkButton *button);
>  void (* leave) (GtkButton *button);
>};
>
>
>GtkType gtk_button_get_type (void);
>GtkWidget* gtk_button_new (void);
>GtkWidget* gtk_button_new_with_label (const gchar *label);
>void gtk_button_pressed (GtkButton *button);
>void gtk_button_released (GtkButton *button);
>void gtk_button_clicked (GtkButton *button);
>void gtk_button_enter (GtkButton *button);
>void gtk_button_leave (GtkButton *button);
>void gtk_button_set_relief (GtkButton *button,
>                                          GtkReliefStyle newstyle);
>GtkReliefStyle gtk_button_get_relief (GtkButton *button);
># 44 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcalendar.h" 1
># 33 "/usr/X11R6/include/gtk12/gtk/gtkcalendar.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtksignal.h" 1
># 34 "/usr/X11R6/include/gtk12/gtk/gtksignal.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmarshal.h" 1
># 14 "/usr/X11R6/include/gtk12/gtk/gtkmarshal.h"
>  void gtk_marshal_BOOL__NONE (GtkObject * object,
>                               GtkSignalFunc func,
>                               gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_BOOL__POINTER (GtkObject * object,
>                                  GtkSignalFunc func,
>                                  gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_BOOL__POINTER_POINTER_INT_INT (GtkObject * object,
>                                                  GtkSignalFunc func,
>                                                  gpointer func_data,
>                                                  GtkArg * args);
>
>  void gtk_marshal_BOOL__POINTER_INT_INT (GtkObject * object,
>                                          GtkSignalFunc func,
>                                          gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_BOOL__POINTER_INT_INT_INT (GtkObject * object,
>                                              GtkSignalFunc func,
>                                              gpointer func_data,
>                                              GtkArg * args);
>
>
>
>  void gtk_marshal_BOOL__POINTER_POINTER_POINTER_POINTER (GtkObject * object,
>                                                          GtkSignalFunc func,
>                                                          gpointer func_data,
>                                                          GtkArg * args);
>
>
>
>  void gtk_marshal_INT__INT (GtkObject * object,
>                             GtkSignalFunc func,
>                             gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_INT__POINTER (GtkObject * object,
>                                 GtkSignalFunc func,
>                                 gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_INT__POINTER_CHAR_CHAR (GtkObject * object,
>                                           GtkSignalFunc func,
>                                           gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__BOOL (GtkObject * object,
>                               GtkSignalFunc func,
>                               gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__POINTER (GtkObject * object,
>                                  GtkSignalFunc func,
>                                  gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__C_CALLBACK (GtkObject * object,
>                                     GtkSignalFunc func,
>                                     gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__C_CALLBACK_C_CALLBACK (GtkObject * object,
>                                                GtkSignalFunc func,
>                                                gpointer func_data,
>                                                GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__INT (GtkObject * object,
>                              GtkSignalFunc func,
>                              gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__INT_FLOAT (GtkObject * object,
>                                    GtkSignalFunc func,
>                                    gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__INT_FLOAT_BOOL (GtkObject * object,
>                                         GtkSignalFunc func,
>                                         gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__INT_INT (GtkObject * object,
>                                  GtkSignalFunc func,
>                                  gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__INT_INT_POINTER (GtkObject * object,
>                                          GtkSignalFunc func,
>                                          gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__NONE (GtkObject * object,
>                               GtkSignalFunc func,
>                               gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__POINTER_INT (GtkObject * object,
>                                      GtkSignalFunc func,
>                                      gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__POINTER_POINTER (GtkObject * object,
>                                          GtkSignalFunc func,
>                                          gpointer func_data, GtkArg * args);
>
>  void gtk_marshal_NONE__POINTER_POINTER_POINTER (GtkObject * object,
>                                                  GtkSignalFunc func,
>                                                  gpointer func_data,
>                                                  GtkArg * args);
>
>
>
>
>
>
>
>  void gtk_marshal_NONE__POINTER_INT_INT (GtkObject * object,
>                                          GtkSignalFunc func,
>                                          gpointer func_data, GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__POINTER_POINTER_INT_INT (GtkObject * object,
>                                                  GtkSignalFunc func,
>                                                  gpointer func_data,
>                                                  GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__POINTER_INT_INT_POINTER_INT_INT (GtkObject * object,
>                                                          GtkSignalFunc func,
>                                                          gpointer func_data,
>                                                          GtkArg * args);
>
>
>
>
>
>
>
>  void gtk_marshal_NONE__POINTER_INT_POINTER (GtkObject * object,
>                                              GtkSignalFunc func,
>                                              gpointer func_data,
>                                              GtkArg * args);
>
>
>
>
>
>  void gtk_marshal_NONE__INT_POINTER_INT_INT_INT_POINTER (GtkObject * object,
>                                                          GtkSignalFunc func,
>                                                          gpointer func_data,
>                                                          GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__INT_POINTER_INT_INT_INT (GtkObject * object,
>                                                  GtkSignalFunc func,
>                                                  gpointer func_data,
>                                                  GtkArg * args);
>
>
>
>  void gtk_marshal_NONE__INT_POINTER (GtkObject * object,
>                                      GtkSignalFunc func,
>                                      gpointer func_data, GtkArg * args);
># 35 "/usr/X11R6/include/gtk12/gtk/gtksignal.h" 2
># 44 "/usr/X11R6/include/gtk12/gtk/gtksignal.h"
>typedef void (*GtkSignalMarshal) (GtkObject *object,
>                                     gpointer data,
>                                     guint nparams,
>                                     GtkArg *args,
>                                     GtkType *arg_types,
>                                     GtkType return_type);
>typedef void (*GtkSignalDestroy) (gpointer data);
>typedef gboolean (*GtkEmissionHook) (GtkObject *object,
>                                     guint signal_id,
>                                     guint n_params,
>                                     GtkArg *params,
>                                     gpointer data);
>
>typedef struct _GtkSignalQuery GtkSignalQuery;
>
>struct _GtkSignalQuery
>{
>  GtkType object_type;
>  guint signal_id;
>  const gchar *signal_name;
>  guint is_user_signal : 1;
>  GtkSignalRunType signal_flags;
>  GtkType return_val;
>  guint nparams;
>  const GtkType *params;
>};
>
>
>
>guint gtk_signal_lookup (const gchar *name,
>                                           GtkType object_type);
>gchar* gtk_signal_name (guint signal_id);
>guint gtk_signal_n_emissions (GtkObject *object,
>                                           guint signal_id);
>guint gtk_signal_n_emissions_by_name (GtkObject *object,
>                                           const gchar *name);
>void gtk_signal_emit_stop (GtkObject *object,
>                                           guint signal_id);
>void gtk_signal_emit_stop_by_name (GtkObject *object,
>                                           const gchar *name);
>guint gtk_signal_connect (GtkObject *object,
>                                           const gchar *name,
>                                           GtkSignalFunc func,
>                                           gpointer func_data);
>guint gtk_signal_connect_after (GtkObject *object,
>                                           const gchar *name,
>                                           GtkSignalFunc func,
>                                           gpointer func_data);
>guint gtk_signal_connect_object (GtkObject *object,
>                                           const gchar *name,
>                                           GtkSignalFunc func,
>                                           GtkObject *slot_object);
>guint gtk_signal_connect_object_after (GtkObject *object,
>                                           const gchar *name,
>                                           GtkSignalFunc func,
>                                           GtkObject *slot_object);
>guint gtk_signal_connect_full (GtkObject *object,
>                                           const gchar *name,
>                                           GtkSignalFunc func,
>                                           GtkCallbackMarshal marshal,
>                                           gpointer data,
>                                           GtkDestroyNotify destroy_func,
>                                           gint object_signal,
>                                           gint after);
>
>void gtk_signal_connect_object_while_alive (GtkObject *object,
>                                              const gchar *signal,
>                                              GtkSignalFunc func,
>                                              GtkObject *alive_object);
>void gtk_signal_connect_while_alive (GtkObject *object,
>                                              const gchar *signal,
>                                              GtkSignalFunc func,
>                                              gpointer func_data,
>                                              GtkObject *alive_object);
>
>void gtk_signal_disconnect (GtkObject *object,
>                                           guint handler_id);
>void gtk_signal_disconnect_by_func (GtkObject *object,
>                                           GtkSignalFunc func,
>                                           gpointer data);
>void gtk_signal_disconnect_by_data (GtkObject *object,
>                                           gpointer data);
>void gtk_signal_handler_block (GtkObject *object,
>                                           guint handler_id);
>void gtk_signal_handler_block_by_func (GtkObject *object,
>                                           GtkSignalFunc func,
>                                           gpointer data);
>void gtk_signal_handler_block_by_data (GtkObject *object,
>                                           gpointer data);
>void gtk_signal_handler_unblock (GtkObject *object,
>                                           guint handler_id);
>void gtk_signal_handler_unblock_by_func (GtkObject *object,
>                                           GtkSignalFunc func,
>                                           gpointer data);
>void gtk_signal_handler_unblock_by_data (GtkObject *object,
>                                           gpointer data);
>guint gtk_signal_handler_pending (GtkObject *object,
>                                           guint signal_id,
>                                           gboolean may_be_blocked);
>guint gtk_signal_handler_pending_by_func (GtkObject *object,
>                                           guint signal_id,
>                                           gboolean may_be_blocked,
>                                           GtkSignalFunc func,
>                                           gpointer data);
>gint gtk_signal_handler_pending_by_id (GtkObject *object,
>                                           guint handler_id,
>                                           gboolean may_be_blocked);
>guint gtk_signal_add_emission_hook (guint signal_id,
>                                           GtkEmissionHook hook_func,
>                                           gpointer data);
>guint gtk_signal_add_emission_hook_full (guint signal_id,
>                                           GtkEmissionHook hook_func,
>                                           gpointer data,
>                                           GDestroyNotify destroy);
>void gtk_signal_remove_emission_hook (guint signal_id,
>                                           guint hook_id);
>
>
>
>
>
>GtkSignalQuery* gtk_signal_query (guint signal_id);
>
>
>
>void gtk_signal_init (void);
>guint gtk_signal_new (const gchar *name,
>                                           GtkSignalRunType signal_flags,
>                                           GtkType object_type,
>                                           guint function_offset,
>                                           GtkSignalMarshaller marshaller,
>                                           GtkType return_val,
>                                           guint nparams,
>                                           ...);
>guint gtk_signal_newv (const gchar *name,
>                                           GtkSignalRunType signal_flags,
>                                           GtkType object_type,
>                                           guint function_offset,
>                                           GtkSignalMarshaller marshaller,
>                                           GtkType return_val,
>                                           guint nparams,
>                                           GtkType *params);
>void gtk_signal_emit (GtkObject *object,
>                                           guint signal_id,
>                                           ...);
>void gtk_signal_emit_by_name (GtkObject *object,
>                                           const gchar *name,
>                                           ...);
>void gtk_signal_emitv (GtkObject *object,
>                                           guint signal_id,
>                                           GtkArg *params);
>void gtk_signal_emitv_by_name (GtkObject *object,
>                                           const gchar *name,
>                                           GtkArg *params);
>
>void gtk_signal_handlers_destroy (GtkObject *object);
>void gtk_signal_set_funcs (GtkSignalMarshal marshal_func,
>                                           GtkSignalDestroy destroy_func);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkcalendar.h" 2
># 49 "/usr/X11R6/include/gtk12/gtk/gtkcalendar.h"
>typedef struct _GtkCalendar GtkCalendar;
>typedef struct _GtkCalendarClass GtkCalendarClass;
>
>typedef enum
>{
>  GTK_CALENDAR_SHOW_HEADING = 1 << 0,
>  GTK_CALENDAR_SHOW_DAY_NAMES = 1 << 1,
>  GTK_CALENDAR_NO_MONTH_CHANGE = 1 << 2,
>  GTK_CALENDAR_SHOW_WEEK_NUMBERS = 1 << 3,
>  GTK_CALENDAR_WEEK_START_MONDAY = 1 << 4
>} GtkCalendarDisplayOptions;
>
>struct _GtkCalendar
>{
>  GtkWidget widget;
>
>  GtkStyle *header_style;
>  GtkStyle *label_style;
>
>  gint month;
>  gint year;
>  gint selected_day;
>
>  gint day_month[6][7];
>  gint day[6][7];
>
>  gint num_marked_dates;
>  gint marked_date[31];
>  GtkCalendarDisplayOptions display_flags;
>  GdkColor marked_date_color[31];
>
>  GdkGC *gc;
>  GdkGC *xor_gc;
>
>  gint focus_row;
>  gint focus_col;
>
>  gint highlight_row;
>  gint highlight_col;
>
>  gpointer private_data;
>  gchar grow_space [32];
>};
>
>struct _GtkCalendarClass
>{
>  GtkWidgetClass parent_class;
>
>
>  void (* month_changed) (GtkCalendar *calendar);
>  void (* day_selected) (GtkCalendar *calendar);
>  void (* day_selected_double_click) (GtkCalendar *calendar);
>  void (* prev_month) (GtkCalendar *calendar);
>  void (* next_month) (GtkCalendar *calendar);
>  void (* prev_year) (GtkCalendar *calendar);
>  void (* next_year) (GtkCalendar *calendar);
>
>};
>
>
>GtkType gtk_calendar_get_type (void);
>GtkWidget* gtk_calendar_new (void);
>
>gint gtk_calendar_select_month (GtkCalendar *calendar,
>                                         guint month,
>                                         guint year);
>void gtk_calendar_select_day (GtkCalendar *calendar,
>                                         guint day);
>
>gint gtk_calendar_mark_day (GtkCalendar *calendar,
>                                         guint day);
>gint gtk_calendar_unmark_day (GtkCalendar *calendar,
>                                         guint day);
>void gtk_calendar_clear_marks (GtkCalendar *calendar);
>
>
>void gtk_calendar_display_options (GtkCalendar *calendar,
>                                         GtkCalendarDisplayOptions flags);
>
>void gtk_calendar_get_date (GtkCalendar *calendar,
>                                         guint *year,
>                                         guint *month,
>                                         guint *day);
>void gtk_calendar_freeze (GtkCalendar *calendar);
>void gtk_calendar_thaw (GtkCalendar *calendar);
># 45 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcheckbutton.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkcheckbutton.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtktogglebutton.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtktogglebutton.h"
>typedef struct _GtkToggleButton GtkToggleButton;
>typedef struct _GtkToggleButtonClass GtkToggleButtonClass;
>
>struct _GtkToggleButton
>{
>  GtkButton button;
>
>  guint active : 1;
>  guint draw_indicator : 1;
>
>  GdkWindow *event_window;
>};
>
>struct _GtkToggleButtonClass
>{
>  GtkButtonClass parent_class;
>
>  void (* toggled) (GtkToggleButton *toggle_button);
>};
>
>
>GtkType gtk_toggle_button_get_type (void);
>GtkWidget* gtk_toggle_button_new (void);
>GtkWidget* gtk_toggle_button_new_with_label (const gchar *label);
>void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
>                                             gboolean draw_indicator);
>void gtk_toggle_button_set_active (GtkToggleButton *toggle_button,
>                                             gboolean is_active);
>gboolean gtk_toggle_button_get_active (GtkToggleButton *toggle_button);
>void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkcheckbutton.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkcheckbutton.h"
>typedef struct _GtkCheckButton GtkCheckButton;
>typedef struct _GtkCheckButtonClass GtkCheckButtonClass;
>
>struct _GtkCheckButton
>{
>  GtkToggleButton toggle_button;
>};
>
>struct _GtkCheckButtonClass
>{
>  GtkToggleButtonClass parent_class;
>
>  guint16 indicator_size;
>  guint16 indicator_spacing;
>
>  void (* draw_indicator) (GtkCheckButton *check_button,
>                           GdkRectangle *area);
>};
>
>
>GtkType gtk_check_button_get_type (void);
>GtkWidget* gtk_check_button_new (void);
>GtkWidget* gtk_check_button_new_with_label (const gchar *label);
>
>void _gtk_check_button_get_props (GtkCheckButton *check_button,
>                                  gint *indicator_size,
>                                  gint *indicator_spacing);
># 46 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcheckmenuitem.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkcheckmenuitem.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmenuitem.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkmenuitem.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkitem.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkitem.h"
>typedef struct _GtkItem GtkItem;
>typedef struct _GtkItemClass GtkItemClass;
>
>struct _GtkItem
>{
>  GtkBin bin;
>};
>
>struct _GtkItemClass
>{
>  GtkBinClass parent_class;
>
>  void (* select) (GtkItem *item);
>  void (* deselect) (GtkItem *item);
>  void (* toggle) (GtkItem *item);
>};
>
>
>GtkType gtk_item_get_type (void);
>void gtk_item_select (GtkItem *item);
>void gtk_item_deselect (GtkItem *item);
>void gtk_item_toggle (GtkItem *item);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkmenuitem.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkmenuitem.h"
>typedef struct _GtkMenuItem GtkMenuItem;
>typedef struct _GtkMenuItemClass GtkMenuItemClass;
>
>struct _GtkMenuItem
>{
>  GtkItem item;
>
>  GtkWidget *submenu;
>
>  guint accelerator_signal;
>  guint16 toggle_size;
>  guint16 accelerator_width;
>
>  guint show_toggle_indicator : 1;
>  guint show_submenu_indicator : 1;
>  guint submenu_placement : 1;
>  guint submenu_direction : 1;
>  guint right_justify: 1;
>  guint timer;
>};
>
>struct _GtkMenuItemClass
>{
>  GtkItemClass parent_class;
>
>  guint toggle_size;
>
>
>
>
>
>
>  guint hide_on_activate : 1;
>
>  void (* activate) (GtkMenuItem *menu_item);
>  void (* activate_item) (GtkMenuItem *menu_item);
>};
>
>
>GtkType gtk_menu_item_get_type (void);
>GtkWidget* gtk_menu_item_new (void);
>GtkWidget* gtk_menu_item_new_with_label (const gchar *label);
>void gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
>                                           GtkWidget *submenu);
>void gtk_menu_item_remove_submenu (GtkMenuItem *menu_item);
>void gtk_menu_item_set_placement (GtkMenuItem *menu_item,
>                                           GtkSubmenuPlacement placement);
>void gtk_menu_item_configure (GtkMenuItem *menu_item,
>                                           gint show_toggle_indicator,
>                                           gint show_submenu_indicator);
>void gtk_menu_item_select (GtkMenuItem *menu_item);
>void gtk_menu_item_deselect (GtkMenuItem *menu_item);
>void gtk_menu_item_activate (GtkMenuItem *menu_item);
>void gtk_menu_item_right_justify (GtkMenuItem *menu_item);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkcheckmenuitem.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkcheckmenuitem.h"
>typedef struct _GtkCheckMenuItem GtkCheckMenuItem;
>typedef struct _GtkCheckMenuItemClass GtkCheckMenuItemClass;
>
>struct _GtkCheckMenuItem
>{
>  GtkMenuItem menu_item;
>
>  guint active : 1;
>  guint always_show_toggle : 1;
>};
>
>struct _GtkCheckMenuItemClass
>{
>  GtkMenuItemClass parent_class;
>
>  void (* toggled) (GtkCheckMenuItem *check_menu_item);
>  void (* draw_indicator) (GtkCheckMenuItem *check_menu_item,
>                           GdkRectangle *area);
>};
>
>
>GtkType gtk_check_menu_item_get_type (void);
>GtkWidget* gtk_check_menu_item_new (void);
>GtkWidget* gtk_check_menu_item_new_with_label (const gchar *label);
>void gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item,
>                                                gboolean is_active);
>void gtk_check_menu_item_set_show_toggle (GtkCheckMenuItem *menu_item,
>                                                gboolean always);
>void gtk_check_menu_item_toggled (GtkCheckMenuItem *check_menu_item);
># 47 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkclist.h" 1
># 36 "/usr/X11R6/include/gtk12/gtk/gtkclist.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhscrollbar.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkhscrollbar.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkscrollbar.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkscrollbar.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkrange.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkrange.h"
>typedef struct _GtkRange GtkRange;
>typedef struct _GtkRangeClass GtkRangeClass;
>
>struct _GtkRange
>{
>  GtkWidget widget;
>
>  GdkWindow *trough;
>  GdkWindow *slider;
>  GdkWindow *step_forw;
>  GdkWindow *step_back;
>
>  gint16 x_click_point;
>  gint16 y_click_point;
>
>  guint8 button;
>  gint8 digits;
>  guint policy : 2;
>  guint scroll_type : 3;
>  guint in_child : 3;
>  guint click_child : 3;
>  guint need_timer : 1;
>
>  guint32 timer;
>
>  gfloat old_value;
>  gfloat old_lower;
>  gfloat old_upper;
>  gfloat old_page_size;
>
>  GtkAdjustment *adjustment;
>};
>
>struct _GtkRangeClass
>{
>  GtkWidgetClass parent_class;
>
>  gint slider_width;
>  gint stepper_size;
>  gint stepper_slider_spacing;
>  gint min_slider_size;
>
>  guint8 trough;
>  guint8 slider;
>  guint8 step_forw;
>  guint8 step_back;
>
>  void (* draw_background) (GtkRange *range);
>  void (* clear_background) (GtkRange *range);
>  void (* draw_trough) (GtkRange *range);
>  void (* draw_slider) (GtkRange *range);
>  void (* draw_step_forw) (GtkRange *range);
>  void (* draw_step_back) (GtkRange *range);
>  void (* slider_update) (GtkRange *range);
>  gint (* trough_click) (GtkRange *range,
>                            gint x,
>                            gint y,
>                            gfloat *jump_perc);
>  gint (* trough_keys) (GtkRange *range,
>                            GdkEventKey *key,
>                            GtkScrollType *scroll,
>                            GtkTroughType *trough);
>  void (* motion) (GtkRange *range,
>                            gint xdelta,
>                            gint ydelta);
>  gint (* timer) (GtkRange *range);
>};
>
>
>GtkType gtk_range_get_type (void);
>GtkAdjustment* gtk_range_get_adjustment (GtkRange *range);
>void gtk_range_set_update_policy (GtkRange *range,
>                                                 GtkUpdateType policy);
>void gtk_range_set_adjustment (GtkRange *range,
>                                                 GtkAdjustment *adjustment);
>
>void gtk_range_draw_background (GtkRange *range);
>void gtk_range_clear_background (GtkRange *range);
>void gtk_range_draw_trough (GtkRange *range);
>void gtk_range_draw_slider (GtkRange *range);
>void gtk_range_draw_step_forw (GtkRange *range);
>void gtk_range_draw_step_back (GtkRange *range);
>void gtk_range_slider_update (GtkRange *range);
>gint gtk_range_trough_click (GtkRange *range,
>                                                 gint x,
>                                                 gint y,
>                                                 gfloat *jump_perc);
>
>void gtk_range_default_hslider_update (GtkRange *range);
>void gtk_range_default_vslider_update (GtkRange *range);
>gint gtk_range_default_htrough_click (GtkRange *range,
>                                                 gint x,
>                                                 gint y,
>                                                 gfloat *jump_perc);
>gint gtk_range_default_vtrough_click (GtkRange *range,
>                                                 gint x,
>                                                 gint y,
>                                                 gfloat *jump_perc);
>void gtk_range_default_hmotion (GtkRange *range,
>                                                 gint xdelta,
>                                                 gint ydelta);
>void gtk_range_default_vmotion (GtkRange *range,
>                                                 gint xdelta,
>                                                 gint ydelta);
>
>void _gtk_range_get_props (GtkRange *range,
>                           gint *slider_width,
>                           gint *trough_border,
>                           gint *stepper_size,
>                           gint *stepper_spacing);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkscrollbar.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkscrollbar.h"
>typedef struct _GtkScrollbar GtkScrollbar;
>typedef struct _GtkScrollbarClass GtkScrollbarClass;
>
>struct _GtkScrollbar
>{
>  GtkRange range;
>};
>
>struct _GtkScrollbarClass
>{
>  GtkRangeClass parent_class;
>};
>
>
>GtkType gtk_scrollbar_get_type (void);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkhscrollbar.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkhscrollbar.h"
>typedef struct _GtkHScrollbar GtkHScrollbar;
>typedef struct _GtkHScrollbarClass GtkHScrollbarClass;
>
>struct _GtkHScrollbar
>{
>  GtkScrollbar scrollbar;
>};
>
>struct _GtkHScrollbarClass
>{
>  GtkScrollbarClass parent_class;
>};
>
>
>GtkType gtk_hscrollbar_get_type (void);
>GtkWidget* gtk_hscrollbar_new (GtkAdjustment *adjustment);
># 37 "/usr/X11R6/include/gtk12/gtk/gtkclist.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvscrollbar.h" 1
># 42 "/usr/X11R6/include/gtk12/gtk/gtkvscrollbar.h"
>typedef struct _GtkVScrollbar GtkVScrollbar;
>typedef struct _GtkVScrollbarClass GtkVScrollbarClass;
>
>struct _GtkVScrollbar
>{
>  GtkScrollbar scrollbar;
>};
>
>struct _GtkVScrollbarClass
>{
>  GtkScrollbarClass parent_class;
>};
>
>
>
>
>
>
>
>GtkType gtk_vscrollbar_get_type (void);
>GtkWidget* gtk_vscrollbar_new (GtkAdjustment *adjustment);
># 38 "/usr/X11R6/include/gtk12/gtk/gtkclist.h" 2
>
>
>
>
>
>
>
>enum {
>  GTK_CLIST_IN_DRAG = 1 << 0,
>  GTK_CLIST_ROW_HEIGHT_SET = 1 << 1,
>  GTK_CLIST_SHOW_TITLES = 1 << 2,
>  GTK_CLIST_CHILD_HAS_FOCUS = 1 << 3,
>  GTK_CLIST_ADD_MODE = 1 << 4,
>  GTK_CLIST_AUTO_SORT = 1 << 5,
>  GTK_CLIST_AUTO_RESIZE_BLOCKED = 1 << 6,
>  GTK_CLIST_REORDERABLE = 1 << 7,
>  GTK_CLIST_USE_DRAG_ICONS = 1 << 8,
>  GTK_CLIST_DRAW_DRAG_LINE = 1 << 9,
>  GTK_CLIST_DRAW_DRAG_RECT = 1 << 10
>};
>
>
>typedef enum
>{
>  GTK_CELL_EMPTY,
>  GTK_CELL_TEXT,
>  GTK_CELL_PIXMAP,
>  GTK_CELL_PIXTEXT,
>  GTK_CELL_WIDGET
>} GtkCellType;
>
>typedef enum
>{
>  GTK_CLIST_DRAG_NONE,
>  GTK_CLIST_DRAG_BEFORE,
>  GTK_CLIST_DRAG_INTO,
>  GTK_CLIST_DRAG_AFTER
>} GtkCListDragPos;
>
>typedef enum
>{
>  GTK_BUTTON_IGNORED = 0,
>  GTK_BUTTON_SELECTS = 1 << 0,
>  GTK_BUTTON_DRAGS = 1 << 1,
>  GTK_BUTTON_EXPANDS = 1 << 2
>} GtkButtonAction;
># 115 "/usr/X11R6/include/gtk12/gtk/gtkclist.h"
>typedef struct _GtkCList GtkCList;
>typedef struct _GtkCListClass GtkCListClass;
>typedef struct _GtkCListColumn GtkCListColumn;
>typedef struct _GtkCListRow GtkCListRow;
>
>typedef struct _GtkCell GtkCell;
>typedef struct _GtkCellText GtkCellText;
>typedef struct _GtkCellPixmap GtkCellPixmap;
>typedef struct _GtkCellPixText GtkCellPixText;
>typedef struct _GtkCellWidget GtkCellWidget;
>
>typedef gint (*GtkCListCompareFunc) (GtkCList *clist,
>                                     gconstpointer ptr1,
>                                     gconstpointer ptr2);
>
>typedef struct _GtkCListCellInfo GtkCListCellInfo;
>typedef struct _GtkCListDestInfo GtkCListDestInfo;
>
>struct _GtkCListCellInfo
>{
>  gint row;
>  gint column;
>};
>
>struct _GtkCListDestInfo
>{
>  GtkCListCellInfo cell;
>  GtkCListDragPos insert_pos;
>};
>
>struct _GtkCList
>{
>  GtkContainer container;
>
>  guint16 flags;
>
>
>  GMemChunk *row_mem_chunk;
>  GMemChunk *cell_mem_chunk;
>
>  guint freeze_count;
>
>
>
>  GdkRectangle internal_allocation;
>
>
>  gint rows;
>  gint row_center_offset;
>  gint row_height;
>  GList *row_list;
>  GList *row_list_end;
>
>
>  gint columns;
>  GdkRectangle column_title_area;
>  GdkWindow *title_window;
>
>
>  GtkCListColumn *column;
>
>
>
>  GdkWindow *clist_window;
>  gint clist_window_width;
>  gint clist_window_height;
>
>
>  gint hoffset;
>  gint voffset;
>
>
>  GtkShadowType shadow_type;
>
>
>  GtkSelectionMode selection_mode;
>
>
>  GList *selection;
>  GList *selection_end;
>
>  GList *undo_selection;
>  GList *undo_unselection;
>  gint undo_anchor;
>
>
>  guint8 button_actions[5];
>
>  guint8 drag_button;
>
>
>  GtkCListCellInfo click_cell;
>
>
>  GtkAdjustment *hadjustment;
>  GtkAdjustment *vadjustment;
>
>
>  GdkGC *xor_gc;
>
>
>  GdkGC *fg_gc;
>  GdkGC *bg_gc;
>
>
>  GdkCursor *cursor_drag;
>
>
>  gint x_drag;
>
>
>  gint focus_row;
>
>
>  gint anchor;
>  GtkStateType anchor_state;
>  gint drag_pos;
>  gint htimer;
>  gint vtimer;
>
>  GtkSortType sort_type;
>  GtkCListCompareFunc compare;
>  gint sort_column;
>};
>
>struct _GtkCListClass
>{
>  GtkContainerClass parent_class;
>
>  void (*set_scroll_adjustments) (GtkCList *clist,
>                                   GtkAdjustment *hadjustment,
>                                   GtkAdjustment *vadjustment);
>  void (*refresh) (GtkCList *clist);
>  void (*select_row) (GtkCList *clist,
>                                 gint row,
>                                 gint column,
>                                 GdkEvent *event);
>  void (*unselect_row) (GtkCList *clist,
>                                 gint row,
>                                 gint column,
>                                 GdkEvent *event);
>  void (*row_move) (GtkCList *clist,
>                                 gint source_row,
>                                 gint dest_row);
>  void (*click_column) (GtkCList *clist,
>                                 gint column);
>  void (*resize_column) (GtkCList *clist,
>                                 gint column,
>                                 gint width);
>  void (*toggle_focus_row) (GtkCList *clist);
>  void (*select_all) (GtkCList *clist);
>  void (*unselect_all) (GtkCList *clist);
>  void (*undo_selection) (GtkCList *clist);
>  void (*start_selection) (GtkCList *clist);
>  void (*end_selection) (GtkCList *clist);
>  void (*extend_selection) (GtkCList *clist,
>                                 GtkScrollType scroll_type,
>                                 gfloat position,
>                                 gboolean auto_start_selection);
>  void (*scroll_horizontal) (GtkCList *clist,
>                                 GtkScrollType scroll_type,
>                                 gfloat position);
>  void (*scroll_vertical) (GtkCList *clist,
>                                 GtkScrollType scroll_type,
>                                 gfloat position);
>  void (*toggle_add_mode) (GtkCList *clist);
>  void (*abort_column_resize) (GtkCList *clist);
>  void (*resync_selection) (GtkCList *clist,
>                                 GdkEvent *event);
>  GList* (*selection_find) (GtkCList *clist,
>                                 gint row_number,
>                                 GList *row_list_element);
>  void (*draw_row) (GtkCList *clist,
>                                 GdkRectangle *area,
>                                 gint row,
>                                 GtkCListRow *clist_row);
>  void (*draw_drag_highlight) (GtkCList *clist,
>                                 GtkCListRow *target_row,
>                                 gint target_row_number,
>                                 GtkCListDragPos drag_pos);
>  void (*clear) (GtkCList *clist);
>  void (*fake_unselect_all) (GtkCList *clist,
>                                 gint row);
>  void (*sort_list) (GtkCList *clist);
>  gint (*insert_row) (GtkCList *clist,
>                                 gint row,
>                                 gchar *text[]);
>  void (*remove_row) (GtkCList *clist,
>                                 gint row);
>  void (*set_cell_contents) (GtkCList *clist,
>                                 GtkCListRow *clist_row,
>                                 gint column,
>                                 GtkCellType type,
>                                 const gchar *text,
>                                 guint8 spacing,
>                                 GdkPixmap *pixmap,
>                                 GdkBitmap *mask);
>  void (*cell_size_request) (GtkCList *clist,
>                                 GtkCListRow *clist_row,
>                                 gint column,
>                                 GtkRequisition *requisition);
>
>};
>
>struct _GtkCListColumn
>{
>  gchar *title;
>  GdkRectangle area;
>
>  GtkWidget *button;
>  GdkWindow *window;
>
>  gint width;
>  gint min_width;
>  gint max_width;
>  GtkJustification justification;
>
>  guint visible : 1;
>  guint width_set : 1;
>  guint resizeable : 1;
>  guint auto_resize : 1;
>  guint button_passive : 1;
>};
>
>struct _GtkCListRow
>{
>  GtkCell *cell;
>  GtkStateType state;
>
>  GdkColor foreground;
>  GdkColor background;
>
>  GtkStyle *style;
>
>  gpointer data;
>  GtkDestroyNotify destroy;
>
>  guint fg_set : 1;
>  guint bg_set : 1;
>  guint selectable : 1;
>};
>
>
>struct _GtkCellText
>{
>  GtkCellType type;
>
>  gint16 vertical;
>  gint16 horizontal;
>
>  GtkStyle *style;
>
>  gchar *text;
>};
>
>struct _GtkCellPixmap
>{
>  GtkCellType type;
>
>  gint16 vertical;
>  gint16 horizontal;
>
>  GtkStyle *style;
>
>  GdkPixmap *pixmap;
>  GdkBitmap *mask;
>};
>
>struct _GtkCellPixText
>{
>  GtkCellType type;
>
>  gint16 vertical;
>  gint16 horizontal;
>
>  GtkStyle *style;
>
>  gchar *text;
>  guint8 spacing;
>  GdkPixmap *pixmap;
>  GdkBitmap *mask;
>};
>
>struct _GtkCellWidget
>{
>  GtkCellType type;
>
>  gint16 vertical;
>  gint16 horizontal;
>
>  GtkStyle *style;
>
>  GtkWidget *widget;
>};
>
>struct _GtkCell
>{
>  GtkCellType type;
>
>  gint16 vertical;
>  gint16 horizontal;
>
>  GtkStyle *style;
>
>  union {
>    gchar *text;
>
>    struct {
>      GdkPixmap *pixmap;
>      GdkBitmap *mask;
>    } pm;
>
>    struct {
>      gchar *text;
>      guint8 spacing;
>      GdkPixmap *pixmap;
>      GdkBitmap *mask;
>    } pt;
>
>    GtkWidget *widget;
>  } u;
>};
>
>GtkType gtk_clist_get_type (void);
>
>
>void gtk_clist_construct (GtkCList *clist,
>                          gint columns,
>                          gchar *titles[]);
>
>
>GtkWidget* gtk_clist_new (gint columns);
>GtkWidget* gtk_clist_new_with_titles (gint columns,
>                                      gchar *titles[]);
>
>
>void gtk_clist_set_hadjustment (GtkCList *clist,
>                                GtkAdjustment *adjustment);
>void gtk_clist_set_vadjustment (GtkCList *clist,
>                                GtkAdjustment *adjustment);
>
>
>GtkAdjustment* gtk_clist_get_hadjustment (GtkCList *clist);
>GtkAdjustment* gtk_clist_get_vadjustment (GtkCList *clist);
>
>
>void gtk_clist_set_shadow_type (GtkCList *clist,
>                                GtkShadowType type);
>
>
>void gtk_clist_set_selection_mode (GtkCList *clist,
>                                   GtkSelectionMode mode);
>
>
>void gtk_clist_set_reorderable (GtkCList *clist,
>                                gboolean reorderable);
>void gtk_clist_set_use_drag_icons (GtkCList *clist,
>                                   gboolean use_icons);
>void gtk_clist_set_button_actions (GtkCList *clist,
>                                   guint button,
>                                   guint8 button_actions);
>
>
>
>
>
>void gtk_clist_freeze (GtkCList *clist);
>void gtk_clist_thaw (GtkCList *clist);
>
>
>void gtk_clist_column_titles_show (GtkCList *clist);
>void gtk_clist_column_titles_hide (GtkCList *clist);
>
>
>
>
>
>void gtk_clist_column_title_active (GtkCList *clist,
>                                      gint column);
>void gtk_clist_column_title_passive (GtkCList *clist,
>                                      gint column);
>void gtk_clist_column_titles_active (GtkCList *clist);
>void gtk_clist_column_titles_passive (GtkCList *clist);
>
>
>void gtk_clist_set_column_title (GtkCList *clist,
>                                 gint column,
>                                 const gchar *title);
>
>
>gchar * gtk_clist_get_column_title (GtkCList *clist,
>                                    gint column);
>
>
>void gtk_clist_set_column_widget (GtkCList *clist,
>                                  gint column,
>                                  GtkWidget *widget);
>
>
>GtkWidget * gtk_clist_get_column_widget (GtkCList *clist,
>                                         gint column);
>
>
>void gtk_clist_set_column_justification (GtkCList *clist,
>                                         gint column,
>                                         GtkJustification justification);
>
>
>void gtk_clist_set_column_visibility (GtkCList *clist,
>                                      gint column,
>                                      gboolean visible);
>
>
>void gtk_clist_set_column_resizeable (GtkCList *clist,
>                                      gint column,
>                                      gboolean resizeable);
>
>
>void gtk_clist_set_column_auto_resize (GtkCList *clist,
>                                       gint column,
>                                       gboolean auto_resize);
>
>gint gtk_clist_columns_autosize (GtkCList *clist);
>
>
>gint gtk_clist_optimal_column_width (GtkCList *clist,
>                                     gint column);
>
>
>
>
>
>void gtk_clist_set_column_width (GtkCList *clist,
>                                 gint column,
>                                 gint width);
>
>
>void gtk_clist_set_column_min_width (GtkCList *clist,
>                                     gint column,
>                                     gint min_width);
>void gtk_clist_set_column_max_width (GtkCList *clist,
>                                     gint column,
>                                     gint max_width);
>
>
>
>
>void gtk_clist_set_row_height (GtkCList *clist,
>                               guint height);
>
>
>
>
>
>
>void gtk_clist_moveto (GtkCList *clist,
>                       gint row,
>                       gint column,
>                       gfloat row_align,
>                       gfloat col_align);
>
>
>GtkVisibility gtk_clist_row_is_visible (GtkCList *clist,
>                                        gint row);
>
>
>GtkCellType gtk_clist_get_cell_type (GtkCList *clist,
>                                     gint row,
>                                     gint column);
>
>
>void gtk_clist_set_text (GtkCList *clist,
>                         gint row,
>                         gint column,
>                         const gchar *text);
>
>
>
>
>gint gtk_clist_get_text (GtkCList *clist,
>                         gint row,
>                         gint column,
>                         gchar **text);
>
>
>void gtk_clist_set_pixmap (GtkCList *clist,
>                           gint row,
>                           gint column,
>                           GdkPixmap *pixmap,
>                           GdkBitmap *mask);
>
>gint gtk_clist_get_pixmap (GtkCList *clist,
>                           gint row,
>                           gint column,
>                           GdkPixmap **pixmap,
>                           GdkBitmap **mask);
>
>
>void gtk_clist_set_pixtext (GtkCList *clist,
>                            gint row,
>                            gint column,
>                            const gchar *text,
>                            guint8 spacing,
>                            GdkPixmap *pixmap,
>                            GdkBitmap *mask);
>
>gint gtk_clist_get_pixtext (GtkCList *clist,
>                            gint row,
>                            gint column,
>                            gchar **text,
>                            guint8 *spacing,
>                            GdkPixmap **pixmap,
>                            GdkBitmap **mask);
>
>
>
>
>void gtk_clist_set_foreground (GtkCList *clist,
>                               gint row,
>                               GdkColor *color);
>
>
>
>
>void gtk_clist_set_background (GtkCList *clist,
>                               gint row,
>                               GdkColor *color);
>
>
>void gtk_clist_set_cell_style (GtkCList *clist,
>                               gint row,
>                               gint column,
>                               GtkStyle *style);
>
>GtkStyle *gtk_clist_get_cell_style (GtkCList *clist,
>                                    gint row,
>                                    gint column);
>
>void gtk_clist_set_row_style (GtkCList *clist,
>                              gint row,
>                              GtkStyle *style);
>
>GtkStyle *gtk_clist_get_row_style (GtkCList *clist,
>                                   gint row);
>
>
>
>
>
>void gtk_clist_set_shift (GtkCList *clist,
>                          gint row,
>                          gint column,
>                          gint vertical,
>                          gint horizontal);
>
>
>void gtk_clist_set_selectable (GtkCList *clist,
>                               gint row,
>                               gboolean selectable);
>gboolean gtk_clist_get_selectable (GtkCList *clist,
>                                   gint row);
>
>
>
>
>gint gtk_clist_prepend (GtkCList *clist,
>                        gchar *text[]);
>gint gtk_clist_append (GtkCList *clist,
>                        gchar *text[]);
>
>
>
>
>gint gtk_clist_insert (GtkCList *clist,
>                       gint row,
>                       gchar *text[]);
>
>
>void gtk_clist_remove (GtkCList *clist,
>                       gint row);
>
>
>void gtk_clist_set_row_data (GtkCList *clist,
>                             gint row,
>                             gpointer data);
>
>
>void gtk_clist_set_row_data_full (GtkCList *clist,
>                                  gint row,
>                                  gpointer data,
>                                  GtkDestroyNotify destroy);
>
>
>gpointer gtk_clist_get_row_data (GtkCList *clist,
>                                 gint row);
>
>
>
>
>gint gtk_clist_find_row_from_data (GtkCList *clist,
>                                   gpointer data);
>
>
>void gtk_clist_select_row (GtkCList *clist,
>                           gint row,
>                           gint column);
>
>
>void gtk_clist_unselect_row (GtkCList *clist,
>                             gint row,
>                             gint column);
>
>
>void gtk_clist_undo_selection (GtkCList *clist);
>
>
>
>
>void gtk_clist_clear (GtkCList *clist);
>
>
>
>
>
>gint gtk_clist_get_selection_info (GtkCList *clist,
>                                   gint x,
>                                   gint y,
>                                   gint *row,
>                                   gint *column);
>
>
>void gtk_clist_select_all (GtkCList *clist);
>
>
>void gtk_clist_unselect_all (GtkCList *clist);
>
>
>void gtk_clist_swap_rows (GtkCList *clist,
>                          gint row1,
>                          gint row2);
>
>
>void gtk_clist_row_move (GtkCList *clist,
>                         gint source_row,
>                         gint dest_row);
>
>
>void gtk_clist_set_compare_func (GtkCList *clist,
>                                 GtkCListCompareFunc cmp_func);
>
>
>void gtk_clist_set_sort_column (GtkCList *clist,
>                                gint column);
>
>
>void gtk_clist_set_sort_type (GtkCList *clist,
>                              GtkSortType sort_type);
>
>
>void gtk_clist_sort (GtkCList *clist);
>
>
>void gtk_clist_set_auto_sort (GtkCList *clist,
>                              gboolean auto_sort);
># 48 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 1
># 30 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkwindow.h" 1
># 49 "/usr/X11R6/include/gtk12/gtk/gtkwindow.h"
>typedef struct _GtkWindow GtkWindow;
>typedef struct _GtkWindowClass GtkWindowClass;
>
>struct _GtkWindow
>{
>  GtkBin bin;
>
>  gchar *title;
>  gchar *wmclass_name;
>  gchar *wmclass_class;
>  GtkWindowType type;
>
>  GtkWidget *focus_widget;
>  GtkWidget *default_widget;
>  GtkWindow *transient_parent;
>
>  gushort resize_count;
>  guint allow_shrink : 1;
>  guint allow_grow : 1;
>  guint auto_shrink : 1;
>  guint handling_resize : 1;
>  guint position : 2;
>
>
>
>
>
>
>
>  guint use_uposition : 1;
>  guint modal : 1;
>
>
>
>  guint window_has_focus : 1;
>
>
>
>
>
>  guint window_has_pointer_focus : 1;
>};
>
>struct _GtkWindowClass
>{
>  GtkBinClass parent_class;
>
>  void (* set_focus) (GtkWindow *window,
>                        GtkWidget *focus);
>};
>
>
>GtkType gtk_window_get_type (void);
>GtkWidget* gtk_window_new (GtkWindowType type);
>void gtk_window_set_title (GtkWindow *window,
>                                                const gchar *title);
>void gtk_window_set_wmclass (GtkWindow *window,
>                                                const gchar *wmclass_name,
>                                                const gchar *wmclass_class);
>void gtk_window_set_policy (GtkWindow *window,
>                                                gint allow_shrink,
>                                                gint allow_grow,
>                                                gint auto_shrink);
>void gtk_window_add_accel_group (GtkWindow *window,
>                                                GtkAccelGroup *accel_group);
>void gtk_window_remove_accel_group (GtkWindow *window,
>                                                GtkAccelGroup *accel_group);
>void gtk_window_set_position (GtkWindow *window,
>                                                GtkWindowPosition position);
>gint gtk_window_activate_focus (GtkWindow *window);
>gint gtk_window_activate_default (GtkWindow *window);
>
>void gtk_window_set_transient_for (GtkWindow *window,
>                                                GtkWindow *parent);
>void gtk_window_set_geometry_hints (GtkWindow *window,
>                                                GtkWidget *geometry_widget,
>                                                GdkGeometry *geometry,
>                                                GdkWindowHints geom_mask);
>
>
>
>
>void gtk_window_set_default_size (GtkWindow *window,
>                                                gint width,
>                                                gint height);
>
>
>void gtk_window_set_modal (GtkWindow *window,
>                                                gboolean modal);
>
>
>void gtk_window_set_focus (GtkWindow *window,
>                                                GtkWidget *focus);
>void gtk_window_set_default (GtkWindow *window,
>                                                GtkWidget *defaultw);
>void gtk_window_remove_embedded_xid (GtkWindow *window,
>                                                guint xid);
>void gtk_window_add_embedded_xid (GtkWindow *window,
>                                                guint xid);
>void gtk_window_reposition (GtkWindow *window,
>                                                gint x,
>                                                gint y);
># 31 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvbox.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkvbox.h"
>typedef struct _GtkVBox GtkVBox;
>typedef struct _GtkVBoxClass GtkVBoxClass;
>
>struct _GtkVBox
>{
>  GtkBox box;
>};
>
>struct _GtkVBoxClass
>{
>  GtkBoxClass parent_class;
>};
>
>
>GtkType gtk_vbox_get_type (void);
>GtkWidget* gtk_vbox_new (gboolean homogeneous,
>                              gint spacing);
># 32 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkpreview.h" 1
># 46 "/usr/X11R6/include/gtk12/gtk/gtkpreview.h"
>typedef struct _GtkPreview GtkPreview;
>typedef struct _GtkPreviewInfo GtkPreviewInfo;
>typedef union _GtkDitherInfo GtkDitherInfo;
>typedef struct _GtkPreviewClass GtkPreviewClass;
>
>struct _GtkPreview
>{
>  GtkWidget widget;
>
>  guchar *buffer;
>  guint16 buffer_width;
>  guint16 buffer_height;
>
>  guint16 bpp;
>  guint16 rowstride;
>
>  GdkRgbDither dither;
>
>  guint type : 1;
>  guint expand : 1;
>};
>
>struct _GtkPreviewInfo
>{
>  GdkVisual *visual;
>  GdkColormap *cmap;
>
>  guchar *lookup;
>
>  gdouble gamma;
>};
>
>union _GtkDitherInfo
>{
>  gushort s[2];
>  guchar c[4];
>};
>
>struct _GtkPreviewClass
>{
>  GtkWidgetClass parent_class;
>
>  GtkPreviewInfo info;
>
>};
>
>
>GtkType gtk_preview_get_type (void);
>void gtk_preview_uninit (void);
>GtkWidget* gtk_preview_new (GtkPreviewType type);
>void gtk_preview_size (GtkPreview *preview,
>                                                gint width,
>                                                gint height);
>void gtk_preview_put (GtkPreview *preview,
>                                                GdkWindow *window,
>                                                GdkGC *gc,
>                                                gint srcx,
>                                                gint srcy,
>                                                gint destx,
>                                                gint desty,
>                                                gint width,
>                                                gint height);
>void gtk_preview_draw_row (GtkPreview *preview,
>                                                guchar *data,
>                                                gint x,
>                                                gint y,
>                                                gint w);
>void gtk_preview_set_expand (GtkPreview *preview,
>                                                gboolean expand);
>
>void gtk_preview_set_gamma (double gamma);
>void gtk_preview_set_color_cube (guint nred_shades,
>                                                guint ngreen_shades,
>                                                guint nblue_shades,
>                                                guint ngray_shades);
>void gtk_preview_set_install_cmap (gint install_cmap);
>void gtk_preview_set_reserved (gint nreserved);
>void gtk_preview_set_dither (GtkPreview *preview,
>                                                GdkRgbDither dither);
>GdkVisual* gtk_preview_get_visual (void);
>GdkColormap* gtk_preview_get_cmap (void);
>GtkPreviewInfo* gtk_preview_get_info (void);
>
>
>
>
>
>
>void gtk_preview_reset (void);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkentry.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkentry.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkeditable.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkeditable.h"
>typedef struct _GtkEditable GtkEditable;
>typedef struct _GtkEditableClass GtkEditableClass;
>
>typedef void (*GtkTextFunction) (GtkEditable *editable, guint32 time);
>
>struct _GtkEditable
>{
>  GtkWidget widget;
>
>
>  guint current_pos;
>
>  guint selection_start_pos;
>  guint selection_end_pos;
>  guint has_selection : 1;
>
>
>  guint editable : 1;
>  guint visible : 1;
>  GdkIC *ic;
>  GdkICAttr *ic_attr;
>
>  gchar *clipboard_text;
>};
>
>struct _GtkEditableClass
>{
>  GtkWidgetClass parent_class;
>
>
>  void (* changed) (GtkEditable *editable);
>  void (* insert_text) (GtkEditable *editable,
>                         const gchar *text,
>                         gint length,
>                         gint *position);
>  void (* delete_text) (GtkEditable *editable,
>                         gint start_pos,
>                         gint end_pos);
>
>
>  void (* activate) (GtkEditable *editable);
>  void (* set_editable) (GtkEditable *editable,
>                            gboolean is_editable);
>  void (* move_cursor) (GtkEditable *editable,
>                            gint x,
>                            gint y);
>  void (* move_word) (GtkEditable *editable,
>                            gint n);
>  void (* move_page) (GtkEditable *editable,
>                            gint x,
>                            gint y);
>  void (* move_to_row) (GtkEditable *editable,
>                            gint row);
>  void (* move_to_column) (GtkEditable *editable,
>                            gint row);
>  void (* kill_char) (GtkEditable *editable,
>                            gint direction);
>  void (* kill_word) (GtkEditable *editable,
>                            gint direction);
>  void (* kill_line) (GtkEditable *editable,
>                            gint direction);
>  void (* cut_clipboard) (GtkEditable *editable);
>  void (* copy_clipboard) (GtkEditable *editable);
>  void (* paste_clipboard) (GtkEditable *editable);
>
>
>
>
>
>
>  void (* update_text) (GtkEditable *editable,
>                         gint start_pos,
>                         gint end_pos);
>  gchar* (* get_chars) (GtkEditable *editable,
>                         gint start_pos,
>                         gint end_pos);
>  void (* set_selection)(GtkEditable *editable,
>                         gint start_pos,
>                         gint end_pos);
>  void (* set_position) (GtkEditable *editable,
>                         gint position);
>};
>
>GtkType gtk_editable_get_type (void);
>void gtk_editable_select_region (GtkEditable *editable,
>                                        gint start,
>                                        gint end);
>void gtk_editable_insert_text (GtkEditable *editable,
>                                        const gchar *new_text,
>                                        gint new_text_length,
>                                        gint *position);
>void gtk_editable_delete_text (GtkEditable *editable,
>                                        gint start_pos,
>                                        gint end_pos);
>gchar* gtk_editable_get_chars (GtkEditable *editable,
>                                        gint start_pos,
>                                        gint end_pos);
>void gtk_editable_cut_clipboard (GtkEditable *editable);
>void gtk_editable_copy_clipboard (GtkEditable *editable);
>void gtk_editable_paste_clipboard (GtkEditable *editable);
>void gtk_editable_claim_selection (GtkEditable *editable,
>                                         gboolean claim,
>                                         guint32 time);
>void gtk_editable_delete_selection (GtkEditable *editable);
>
>void gtk_editable_changed (GtkEditable *editable);
>void gtk_editable_set_position (GtkEditable *editable,
>                                         gint position);
>gint gtk_editable_get_position (GtkEditable *editable);
>void gtk_editable_set_editable (GtkEditable *editable,
>                                         gboolean is_editable);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkentry.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkentry.h"
>typedef struct _GtkEntry GtkEntry;
>typedef struct _GtkEntryClass GtkEntryClass;
>
>struct _GtkEntry
>{
>  GtkEditable editable;
>
>  GdkWindow *text_area;
>  GdkPixmap *backing_pixmap;
>  GdkCursor *cursor;
>  GdkWChar *text;
>
>  guint16 text_size;
>  guint16 text_length;
>  guint16 text_max_length;
>  gint scroll_offset;
>  guint visible : 1;
>  guint32 timer;
>  guint button;
>
>
>
>  gint *char_offset;
>
>
>  gchar *text_mb;
>
>  guint text_mb_dirty : 1;
>
>
>  guint use_wchar : 1;
>};
>
>struct _GtkEntryClass
>{
>  GtkEditableClass parent_class;
>};
>
>GtkType gtk_entry_get_type (void);
>GtkWidget* gtk_entry_new (void);
>GtkWidget* gtk_entry_new_with_max_length (guint16 max);
>void gtk_entry_set_text (GtkEntry *entry,
>                                                 const gchar *text);
>void gtk_entry_append_text (GtkEntry *entry,
>                                                 const gchar *text);
>void gtk_entry_prepend_text (GtkEntry *entry,
>                                                 const gchar *text);
>void gtk_entry_set_position (GtkEntry *entry,
>                                                 gint position);
>
>gchar* gtk_entry_get_text (GtkEntry *entry);
>void gtk_entry_select_region (GtkEntry *entry,
>                                                 gint start,
>                                                 gint end);
>void gtk_entry_set_visibility (GtkEntry *entry,
>                                                 gboolean visible);
>void gtk_entry_set_editable (GtkEntry *entry,
>                                                 gboolean editable);
>
>void gtk_entry_set_max_length (GtkEntry *entry,
>                                                 guint16 max);
># 36 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhbox.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkhbox.h"
>typedef struct _GtkHBox GtkHBox;
>typedef struct _GtkHBoxClass GtkHBoxClass;
>
>struct _GtkHBox
>{
>  GtkBox box;
>};
>
>struct _GtkHBoxClass
>{
>  GtkBoxClass parent_class;
>};
>
>
>GtkType gtk_hbox_get_type (void);
>GtkWidget* gtk_hbox_new (gboolean homogeneous,
>                              gint spacing);
># 37 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmain.h" 1
># 51 "/usr/X11R6/include/gtk12/gtk/gtkmain.h"
>typedef void (*GtkModuleInitFunc) (gint *argc,
>                                         gchar ***argv);
>typedef gint (*GtkKeySnoopFunc) (GtkWidget *grab_widget,
>                                         GdkEventKey *event,
>                                         gpointer func_data);
>
>
>
>extern const guint gtk_major_version;
>extern const guint gtk_minor_version;
>extern const guint gtk_micro_version;
>extern const guint gtk_binary_age;
>extern const guint gtk_interface_age;
>gchar* gtk_check_version (guint required_major,
>                          guint required_minor,
>                          guint required_micro);
>
>
>
>
>void gtk_init (int *argc,
>                                  char ***argv);
>gboolean gtk_init_check (int *argc,
>                                  char ***argv);
>void gtk_exit (gint error_code);
>gchar* gtk_set_locale (void);
>gint gtk_events_pending (void);
>
>
>
>
>
>void gtk_main_do_event (GdkEvent *event);
>
>void gtk_main (void);
>guint gtk_main_level (void);
>void gtk_main_quit (void);
>gint gtk_main_iteration (void);
>
>gint gtk_main_iteration_do (gboolean blocking);
>
>gint gtk_true (void);
>gint gtk_false (void);
>
>void gtk_grab_add (GtkWidget *widget);
>GtkWidget* gtk_grab_get_current (void);
>void gtk_grab_remove (GtkWidget *widget);
>
>void gtk_init_add (GtkFunction function,
>                                    gpointer data);
>void gtk_quit_add_destroy (guint main_level,
>                                    GtkObject *object);
>guint gtk_quit_add (guint main_level,
>                                    GtkFunction function,
>                                    gpointer data);
>guint gtk_quit_add_full (guint main_level,
>                                    GtkFunction function,
>                                    GtkCallbackMarshal marshal,
>                                    gpointer data,
>                                    GtkDestroyNotify destroy);
>void gtk_quit_remove (guint quit_handler_id);
>void gtk_quit_remove_by_data (gpointer data);
>guint gtk_timeout_add (guint32 interval,
>                                    GtkFunction function,
>                                    gpointer data);
>guint gtk_timeout_add_full (guint32 interval,
>                                    GtkFunction function,
>                                    GtkCallbackMarshal marshal,
>                                    gpointer data,
>                                    GtkDestroyNotify destroy);
>void gtk_timeout_remove (guint timeout_handler_id);
>
>guint gtk_idle_add (GtkFunction function,
>                                    gpointer data);
>guint gtk_idle_add_priority (gint priority,
>                                    GtkFunction function,
>                                    gpointer data);
>guint gtk_idle_add_full (gint priority,
>                                    GtkFunction function,
>                                    GtkCallbackMarshal marshal,
>                                    gpointer data,
>                                    GtkDestroyNotify destroy);
>void gtk_idle_remove (guint idle_handler_id);
>void gtk_idle_remove_by_data (gpointer data);
>guint gtk_input_add_full (gint source,
>                                    GdkInputCondition condition,
>                                    GdkInputFunction function,
>                                    GtkCallbackMarshal marshal,
>                                    gpointer data,
>                                    GtkDestroyNotify destroy);
>void gtk_input_remove (guint input_handler_id);
>
>
>guint gtk_key_snooper_install (GtkKeySnoopFunc snooper,
>                                    gpointer func_data);
>void gtk_key_snooper_remove (guint snooper_handler_id);
>
>GdkEvent* gtk_get_current_event (void);
>GtkWidget* gtk_get_event_widget (GdkEvent *event);
>
>
>
>
>void gtk_propagate_event (GtkWidget *widget,
>                                    GdkEvent *event);
># 39 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
>
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkscale.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkscale.h"
>typedef struct _GtkScale GtkScale;
>typedef struct _GtkScaleClass GtkScaleClass;
>
>struct _GtkScale
>{
>  GtkRange range;
>
>  guint draw_value : 1;
>  guint value_pos : 2;
>};
>
>struct _GtkScaleClass
>{
>  GtkRangeClass parent_class;
>
>  gint slider_length;
>  gint value_spacing;
>
>  void (* draw_value) (GtkScale *scale);
>};
>
>
>GtkType gtk_scale_get_type (void);
>void gtk_scale_set_digits (GtkScale *scale,
>                                   gint digits);
>void gtk_scale_set_draw_value (GtkScale *scale,
>                                   gboolean draw_value);
>void gtk_scale_set_value_pos (GtkScale *scale,
>                                   GtkPositionType pos);
>gint gtk_scale_get_value_width (GtkScale *scale);
>
>void gtk_scale_draw_value (GtkScale *scale);
># 43 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhscale.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkhscale.h"
>typedef struct _GtkHScale GtkHScale;
>typedef struct _GtkHScaleClass GtkHScaleClass;
>
>struct _GtkHScale
>{
>  GtkScale scale;
>};
>
>struct _GtkHScaleClass
>{
>  GtkScaleClass parent_class;
>};
>
>
>GtkType gtk_hscale_get_type (void);
>GtkWidget* gtk_hscale_new (GtkAdjustment *adjustment);
># 44 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtktable.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtktable.h"
>typedef struct _GtkTable GtkTable;
>typedef struct _GtkTableClass GtkTableClass;
>typedef struct _GtkTableChild GtkTableChild;
>typedef struct _GtkTableRowCol GtkTableRowCol;
>
>struct _GtkTable
>{
>  GtkContainer container;
>
>  GList *children;
>  GtkTableRowCol *rows;
>  GtkTableRowCol *cols;
>  guint16 nrows;
>  guint16 ncols;
>  guint16 column_spacing;
>  guint16 row_spacing;
>  guint homogeneous : 1;
>};
>
>struct _GtkTableClass
>{
>  GtkContainerClass parent_class;
>};
>
>struct _GtkTableChild
>{
>  GtkWidget *widget;
>  guint16 left_attach;
>  guint16 right_attach;
>  guint16 top_attach;
>  guint16 bottom_attach;
>  guint16 xpadding;
>  guint16 ypadding;
>  guint xexpand : 1;
>  guint yexpand : 1;
>  guint xshrink : 1;
>  guint yshrink : 1;
>  guint xfill : 1;
>  guint yfill : 1;
>};
>
>struct _GtkTableRowCol
>{
>  guint16 requisition;
>  guint16 allocation;
>  guint16 spacing;
>  guint need_expand : 1;
>  guint need_shrink : 1;
>  guint expand : 1;
>  guint shrink : 1;
>  guint empty : 1;
>};
>
>
>GtkType gtk_table_get_type (void);
>GtkWidget* gtk_table_new (guint rows,
>                                       guint columns,
>                                       gboolean homogeneous);
>void gtk_table_resize (GtkTable *table,
>                                       guint rows,
>                                       guint columns);
>void gtk_table_attach (GtkTable *table,
>                                       GtkWidget *child,
>                                       guint left_attach,
>                                       guint right_attach,
>                                       guint top_attach,
>                                       guint bottom_attach,
>                                       GtkAttachOptions xoptions,
>                                       GtkAttachOptions yoptions,
>                                       guint xpadding,
>                                       guint ypadding);
>void gtk_table_attach_defaults (GtkTable *table,
>                                       GtkWidget *widget,
>                                       guint left_attach,
>                                       guint right_attach,
>                                       guint top_attach,
>                                       guint bottom_attach);
>void gtk_table_set_row_spacing (GtkTable *table,
>                                       guint row,
>                                       guint spacing);
>void gtk_table_set_col_spacing (GtkTable *table,
>                                       guint column,
>                                       guint spacing);
>void gtk_table_set_row_spacings (GtkTable *table,
>                                       guint spacing);
>void gtk_table_set_col_spacings (GtkTable *table,
>                                       guint spacing);
>void gtk_table_set_homogeneous (GtkTable *table,
>                                       gboolean homogeneous);
># 45 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkeventbox.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkeventbox.h"
>typedef struct _GtkEventBox GtkEventBox;
>typedef struct _GtkEventBoxClass GtkEventBoxClass;
>
>struct _GtkEventBox
>{
>  GtkBin bin;
>};
>
>struct _GtkEventBoxClass
>{
>  GtkBinClass parent_class;
>};
>
>GtkType gtk_event_box_get_type (void);
>GtkWidget* gtk_event_box_new (void);
># 46 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h" 2
># 65 "/usr/X11R6/include/gtk12/gtk/gtkcolorsel.h"
>typedef struct _GtkColorSelection GtkColorSelection;
>typedef struct _GtkColorSelectionClass GtkColorSelectionClass;
>
>typedef struct _GtkColorSelectionDialog GtkColorSelectionDialog;
>typedef struct _GtkColorSelectionDialogClass GtkColorSelectionDialogClass;
>
>
>struct _GtkColorSelection
>{
>  GtkVBox vbox;
>
>  GtkWidget *wheel_area;
>  GtkWidget *value_area;
>  GtkWidget *sample_area;
>  GtkWidget *sample_area_eb;
>
>  GtkWidget *scales[8];
>  GtkWidget *entries[8];
>  GtkWidget *opacity_label;
>
>  GdkGC *wheel_gc;
>  GdkGC *value_gc;
>  GdkGC *sample_gc;
>
>  GtkUpdateType policy;
>  gint use_opacity;
>  gint timer_active;
>  gint timer_tag;
>  gdouble values[8];
>  gdouble old_values[8];
>
>  guchar *wheel_buf;
>  guchar *value_buf;
>  guchar *sample_buf;
>};
>
>struct _GtkColorSelectionClass
>{
>  GtkVBoxClass parent_class;
>
>  void (* color_changed) (GtkColorSelection *colorsel);
>};
>
>struct _GtkColorSelectionDialog
>{
>  GtkWindow window;
>
>  GtkWidget *colorsel;
>  GtkWidget *main_vbox;
>  GtkWidget *ok_button;
>  GtkWidget *reset_button;
>  GtkWidget *cancel_button;
>  GtkWidget *help_button;
>};
>
>struct _GtkColorSelectionDialogClass
>{
>  GtkWindowClass parent_class;
>};
>
>
>
>
>GtkType gtk_color_selection_get_type (void);
>
>GtkWidget* gtk_color_selection_new (void);
>
>void gtk_color_selection_set_update_policy (GtkColorSelection *colorsel,
>                                                  GtkUpdateType policy);
>
>void gtk_color_selection_set_opacity (GtkColorSelection *colorsel,
>                                                  gint use_opacity);
>
>void gtk_color_selection_set_color (GtkColorSelection *colorsel,
>                                                  gdouble *color);
>
>void gtk_color_selection_get_color (GtkColorSelection *colorsel,
>                                                  gdouble *color);
>
>
>
>GtkType gtk_color_selection_dialog_get_type (void);
>
>GtkWidget* gtk_color_selection_dialog_new (const gchar *title);
># 49 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcombo.h" 1
># 41 "/usr/X11R6/include/gtk12/gtk/gtkcombo.h"
>typedef struct _GtkCombo GtkCombo;
>typedef struct _GtkComboClass GtkComboClass;
>
>
>struct _GtkCombo {
>        GtkHBox hbox;
>        GtkWidget *entry;
>        GtkWidget *button;
>        GtkWidget *popup;
>        GtkWidget *popwin;
>        GtkWidget *list;
>
>        guint entry_change_id;
>        guint list_change_id;
>
>        guint value_in_list:1;
>        guint ok_if_empty:1;
>        guint case_sensitive:1;
>        guint use_arrows:1;
>        guint use_arrows_always:1;
>
>        guint16 current_button;
>        guint activate_id;
>};
>
>struct _GtkComboClass {
>        GtkHBoxClass parent_class;
>};
>
>guint gtk_combo_get_type (void);
>
>GtkWidget *gtk_combo_new (void);
>
>void gtk_combo_set_value_in_list (GtkCombo* combo,
>                                            gint val,
>                                            gint ok_if_empty);
>
>void gtk_combo_set_use_arrows (GtkCombo* combo,
>                                            gint val);
>
>void gtk_combo_set_use_arrows_always (GtkCombo* combo,
>                                            gint val);
>
>void gtk_combo_set_case_sensitive (GtkCombo* combo,
>                                            gint val);
>
>
>void gtk_combo_set_item_string (GtkCombo* combo,
>                                            GtkItem* item,
>                                            const gchar* item_value);
>
>void gtk_combo_set_popdown_strings (GtkCombo* combo,
>                                            GList *strings);
>
>void gtk_combo_disable_activate (GtkCombo* combo);
># 50 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcompat.h" 1
># 51 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkctree.h" 1
># 52 "/usr/X11R6/include/gtk12/gtk/gtkctree.h"
>typedef enum
>{
>  GTK_CTREE_POS_BEFORE,
>  GTK_CTREE_POS_AS_CHILD,
>  GTK_CTREE_POS_AFTER
>} GtkCTreePos;
>
>typedef enum
>{
>  GTK_CTREE_LINES_NONE,
>  GTK_CTREE_LINES_SOLID,
>  GTK_CTREE_LINES_DOTTED,
>  GTK_CTREE_LINES_TABBED
>} GtkCTreeLineStyle;
>
>typedef enum
>{
>  GTK_CTREE_EXPANDER_NONE,
>  GTK_CTREE_EXPANDER_SQUARE,
>  GTK_CTREE_EXPANDER_TRIANGLE,
>  GTK_CTREE_EXPANDER_CIRCULAR
>} GtkCTreeExpanderStyle;
>
>typedef enum
>{
>  GTK_CTREE_EXPANSION_EXPAND,
>  GTK_CTREE_EXPANSION_EXPAND_RECURSIVE,
>  GTK_CTREE_EXPANSION_COLLAPSE,
>  GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE,
>  GTK_CTREE_EXPANSION_TOGGLE,
>  GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE
>} GtkCTreeExpansionType;
>
>typedef struct _GtkCTree GtkCTree;
>typedef struct _GtkCTreeClass GtkCTreeClass;
>typedef struct _GtkCTreeRow GtkCTreeRow;
>typedef struct _GtkCTreeNode GtkCTreeNode;
>
>typedef void (*GtkCTreeFunc) (GtkCTree *ctree,
>                              GtkCTreeNode *node,
>                              gpointer data);
>
>typedef gboolean (*GtkCTreeGNodeFunc) (GtkCTree *ctree,
>                                       guint depth,
>                                       GNode *gnode,
>                                       GtkCTreeNode *cnode,
>                                       gpointer data);
>
>typedef gboolean (*GtkCTreeCompareDragFunc) (GtkCTree *ctree,
>                                             GtkCTreeNode *source_node,
>                                             GtkCTreeNode *new_parent,
>                                             GtkCTreeNode *new_sibling);
>
>struct _GtkCTree
>{
>  GtkCList clist;
>
>  GdkGC *lines_gc;
>
>  gint tree_indent;
>  gint tree_spacing;
>  gint tree_column;
>
>  guint line_style : 2;
>  guint expander_style : 2;
>  guint show_stub : 1;
>
>  GtkCTreeCompareDragFunc drag_compare;
>};
>
>struct _GtkCTreeClass
>{
>  GtkCListClass parent_class;
>
>  void (*tree_select_row) (GtkCTree *ctree,
>                             GtkCTreeNode *row,
>                             gint column);
>  void (*tree_unselect_row) (GtkCTree *ctree,
>                             GtkCTreeNode *row,
>                             gint column);
>  void (*tree_expand) (GtkCTree *ctree,
>                             GtkCTreeNode *node);
>  void (*tree_collapse) (GtkCTree *ctree,
>                             GtkCTreeNode *node);
>  void (*tree_move) (GtkCTree *ctree,
>                             GtkCTreeNode *node,
>                             GtkCTreeNode *new_parent,
>                             GtkCTreeNode *new_sibling);
>  void (*change_focus_row_expansion) (GtkCTree *ctree,
>                                      GtkCTreeExpansionType action);
>};
>
>struct _GtkCTreeRow
>{
>  GtkCListRow row;
>
>  GtkCTreeNode *parent;
>  GtkCTreeNode *sibling;
>  GtkCTreeNode *children;
>
>  GdkPixmap *pixmap_closed;
>  GdkBitmap *mask_closed;
>  GdkPixmap *pixmap_opened;
>  GdkBitmap *mask_opened;
>
>  guint16 level;
>
>  guint is_leaf : 1;
>  guint expanded : 1;
>};
>
>struct _GtkCTreeNode {
>  GList list;
>};
>
>
>
>
>
>
>GtkType gtk_ctree_get_type (void);
>void gtk_ctree_construct (GtkCTree *ctree,
>                                                  gint columns,
>                                                  gint tree_column,
>                                                  gchar *titles[]);
>GtkWidget * gtk_ctree_new_with_titles (gint columns,
>                                                  gint tree_column,
>                                                  gchar *titles[]);
>GtkWidget * gtk_ctree_new (gint columns,
>                                                  gint tree_column);
>GtkCTreeNode * gtk_ctree_insert_node (GtkCTree *ctree,
>                                                  GtkCTreeNode *parent,
>                                                  GtkCTreeNode *sibling,
>                                                  gchar *text[],
>                                                  guint8 spacing,
>                                                  GdkPixmap *pixmap_closed,
>                                                  GdkBitmap *mask_closed,
>                                                  GdkPixmap *pixmap_opened,
>                                                  GdkBitmap *mask_opened,
>                                                  gboolean is_leaf,
>                                                  gboolean expanded);
>void gtk_ctree_remove_node (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>GtkCTreeNode * gtk_ctree_insert_gnode (GtkCTree *ctree,
>                                                  GtkCTreeNode *parent,
>                                                  GtkCTreeNode *sibling,
>                                                  GNode *gnode,
>                                                  GtkCTreeGNodeFunc func,
>                                                  gpointer data);
>GNode * gtk_ctree_export_to_gnode (GtkCTree *ctree,
>                                                  GNode *parent,
>                                                  GNode *sibling,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeGNodeFunc func,
>                                                  gpointer data);
>
>
>
>
>
>
>void gtk_ctree_post_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeFunc func,
>                                                  gpointer data);
>void gtk_ctree_post_recursive_to_depth (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint depth,
>                                                  GtkCTreeFunc func,
>                                                  gpointer data);
>void gtk_ctree_pre_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeFunc func,
>                                                  gpointer data);
>void gtk_ctree_pre_recursive_to_depth (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint depth,
>                                                  GtkCTreeFunc func,
>                                                  gpointer data);
>gboolean gtk_ctree_is_viewable (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>GtkCTreeNode * gtk_ctree_last (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>GtkCTreeNode * gtk_ctree_find_node_ptr (GtkCTree *ctree,
>                                                  GtkCTreeRow *ctree_row);
>GtkCTreeNode * gtk_ctree_node_nth (GtkCTree *ctree,
>                                                  guint row);
>gboolean gtk_ctree_find (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeNode *child);
>gboolean gtk_ctree_is_ancestor (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeNode *child);
>GtkCTreeNode * gtk_ctree_find_by_row_data (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data);
>
>GList * gtk_ctree_find_all_by_row_data (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data);
>GtkCTreeNode * gtk_ctree_find_by_row_data_custom (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data,
>                                                  GCompareFunc func);
>
>GList * gtk_ctree_find_all_by_row_data_custom (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data,
>                                                  GCompareFunc func);
>gboolean gtk_ctree_is_hot_spot (GtkCTree *ctree,
>                                                  gint x,
>                                                  gint y);
>
>
>
>
>
>void gtk_ctree_move (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkCTreeNode *new_parent,
>                                                  GtkCTreeNode *new_sibling);
>void gtk_ctree_expand (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_expand_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_expand_to_depth (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint depth);
>void gtk_ctree_collapse (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_collapse_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_collapse_to_depth (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint depth);
>void gtk_ctree_toggle_expansion (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_toggle_expansion_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_select (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_select_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_unselect (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_unselect_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_real_select_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint state);
>
>
>
>
>
>void gtk_ctree_node_set_text (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  const gchar *text);
>void gtk_ctree_node_set_pixmap (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  GdkPixmap *pixmap,
>                                                  GdkBitmap *mask);
>void gtk_ctree_node_set_pixtext (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  const gchar *text,
>                                                  guint8 spacing,
>                                                  GdkPixmap *pixmap,
>                                                  GdkBitmap *mask);
>void gtk_ctree_set_node_info (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  const gchar *text,
>                                                  guint8 spacing,
>                                                  GdkPixmap *pixmap_closed,
>                                                  GdkBitmap *mask_closed,
>                                                  GdkPixmap *pixmap_opened,
>                                                  GdkBitmap *mask_opened,
>                                                  gboolean is_leaf,
>                                                  gboolean expanded);
>void gtk_ctree_node_set_shift (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  gint vertical,
>                                                  gint horizontal);
>void gtk_ctree_node_set_selectable (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gboolean selectable);
>gboolean gtk_ctree_node_get_selectable (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>GtkCellType gtk_ctree_node_get_cell_type (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column);
>gint gtk_ctree_node_get_text (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  gchar **text);
>gint gtk_ctree_node_get_pixmap (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  GdkPixmap **pixmap,
>                                                  GdkBitmap **mask);
>gint gtk_ctree_node_get_pixtext (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  gchar **text,
>                                                  guint8 *spacing,
>                                                  GdkPixmap **pixmap,
>                                                  GdkBitmap **mask);
>gint gtk_ctree_get_node_info (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gchar **text,
>                                                  guint8 *spacing,
>                                                  GdkPixmap **pixmap_closed,
>                                                  GdkBitmap **mask_closed,
>                                                  GdkPixmap **pixmap_opened,
>                                                  GdkBitmap **mask_opened,
>                                                  gboolean *is_leaf,
>                                                  gboolean *expanded);
>void gtk_ctree_node_set_row_style (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GtkStyle *style);
>GtkStyle * gtk_ctree_node_get_row_style (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_node_set_cell_style (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  GtkStyle *style);
>GtkStyle * gtk_ctree_node_get_cell_style (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column);
>void gtk_ctree_node_set_foreground (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GdkColor *color);
>void gtk_ctree_node_set_background (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  GdkColor *color);
>void gtk_ctree_node_set_row_data (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data);
>void gtk_ctree_node_set_row_data_full (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gpointer data,
>                                                  GtkDestroyNotify destroy);
>gpointer gtk_ctree_node_get_row_data (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_node_moveto (GtkCTree *ctree,
>                                                  GtkCTreeNode *node,
>                                                  gint column,
>                                                  gfloat row_align,
>                                                  gfloat col_align);
>GtkVisibility gtk_ctree_node_is_visible (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>
>
>
>
>
>void gtk_ctree_set_indent (GtkCTree *ctree,
>                                      gint indent);
>void gtk_ctree_set_spacing (GtkCTree *ctree,
>                                      gint spacing);
>void gtk_ctree_set_show_stub (GtkCTree *ctree,
>                                      gboolean show_stub);
>void gtk_ctree_set_line_style (GtkCTree *ctree,
>                                      GtkCTreeLineStyle line_style);
>void gtk_ctree_set_expander_style (GtkCTree *ctree,
>                                      GtkCTreeExpanderStyle expander_style);
>void gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
>                                      GtkCTreeCompareDragFunc cmp_func);
>
>
>
>
>
>void gtk_ctree_sort_node (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
>void gtk_ctree_sort_recursive (GtkCTree *ctree,
>                                                  GtkCTreeNode *node);
># 53 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkcurve.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkcurve.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkdrawingarea.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkdrawingarea.h"
>typedef struct _GtkDrawingArea GtkDrawingArea;
>typedef struct _GtkDrawingAreaClass GtkDrawingAreaClass;
>
>struct _GtkDrawingArea
>{
>  GtkWidget widget;
>
>  gpointer draw_data;
>};
>
>struct _GtkDrawingAreaClass
>{
>  GtkWidgetClass parent_class;
>};
>
>
>GtkType gtk_drawing_area_get_type (void);
>GtkWidget* gtk_drawing_area_new (void);
>void gtk_drawing_area_size (GtkDrawingArea *darea,
>                                        gint width,
>                                        gint height);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkcurve.h" 2
># 46 "/usr/X11R6/include/gtk12/gtk/gtkcurve.h"
>typedef struct _GtkCurve GtkCurve;
>typedef struct _GtkCurveClass GtkCurveClass;
>
>
>struct _GtkCurve
>{
>  GtkDrawingArea graph;
>
>  gint cursor_type;
>  gfloat min_x;
>  gfloat max_x;
>  gfloat min_y;
>  gfloat max_y;
>  GdkPixmap *pixmap;
>  GtkCurveType curve_type;
>  gint height;
>  gint grab_point;
>  gint last;
>
>
>  gint num_points;
>  GdkPoint *point;
>
>
>  gint num_ctlpoints;
>  gfloat (*ctlpoint)[2];
>};
>
>struct _GtkCurveClass
>{
>  GtkDrawingAreaClass parent_class;
>
>  void (* curve_type_changed) (GtkCurve *curve);
>};
>
>
>GtkType gtk_curve_get_type (void);
>GtkWidget* gtk_curve_new (void);
>void gtk_curve_reset (GtkCurve *curve);
>void gtk_curve_set_gamma (GtkCurve *curve, gfloat gamma);
>void gtk_curve_set_range (GtkCurve *curve,
>                                         gfloat min_x, gfloat max_x,
>                                         gfloat min_y, gfloat max_y);
>void gtk_curve_get_vector (GtkCurve *curve,
>                                         int veclen, gfloat vector[]);
>void gtk_curve_set_vector (GtkCurve *curve,
>                                         int veclen, gfloat vector[]);
>void gtk_curve_set_curve_type (GtkCurve *curve, GtkCurveType type);
># 54 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkdialog.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkdialog.h"
>typedef struct _GtkDialog GtkDialog;
>typedef struct _GtkDialogClass GtkDialogClass;
>typedef struct _GtkDialogButton GtkDialogButton;
>
>
>struct _GtkDialog
>{
>  GtkWindow window;
>
>  GtkWidget *vbox;
>  GtkWidget *action_area;
>};
>
>struct _GtkDialogClass
>{
>  GtkWindowClass parent_class;
>};
>
>
>GtkType gtk_dialog_get_type (void);
>GtkWidget* gtk_dialog_new (void);
># 56 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkdnd.h" 1
># 33 "/usr/X11R6/include/gtk12/gtk/gtkdnd.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkselection.h" 1
># 39 "/usr/X11R6/include/gtk12/gtk/gtkselection.h"
>typedef struct _GtkSelectionData GtkSelectioData;
>typedef struct _GtkTargetList GtkTargetList;
>typedef struct _GtkTargetEntry GtkTargetEntry;
>
>struct _GtkTargetEntry {
>  gchar *target;
>  guint flags;
>  guint info;
>};
>
>
>
>
>
>typedef struct _GtkTargetPair GtkTargetPair;
>
>
>struct _GtkTargetList {
>  GList *list;
>  guint ref_count;
>};
>
>struct _GtkTargetPair {
>  GdkAtom target;
>  guint flags;
>  guint info;
>};
>
>GtkTargetList *gtk_target_list_new (const GtkTargetEntry *targets,
>                                          guint ntargets);
>void gtk_target_list_ref (GtkTargetList *list);
>void gtk_target_list_unref (GtkTargetList *list);
>void gtk_target_list_add (GtkTargetList *list,
>                                          GdkAtom target,
>                                          guint flags,
>                                          guint info);
>void gtk_target_list_add_table (GtkTargetList *list,
>                                          const GtkTargetEntry *targets,
>                                          guint ntargets);
>void gtk_target_list_remove (GtkTargetList *list,
>                                          GdkAtom target);
>gboolean gtk_target_list_find (GtkTargetList *list,
>                                          GdkAtom target,
>                                          guint *info);
>
>
>
>gint gtk_selection_owner_set (GtkWidget *widget,
>                              GdkAtom selection,
>                              guint32 time);
>void gtk_selection_add_target (GtkWidget *widget,
>                               GdkAtom selection,
>                               GdkAtom target,
>                               guint info);
>void gtk_selection_add_targets (GtkWidget *widget,
>                                GdkAtom selection,
>                                const GtkTargetEntry *targets,
>                                guint ntargets);
>gint gtk_selection_convert (GtkWidget *widget,
>                              GdkAtom selection,
>                              GdkAtom target,
>                              guint32 time);
>
>
>void gtk_selection_data_set (GtkSelectionData *selection_data,
>                             GdkAtom type,
>                             gint format,
>                             const guchar *data,
>                             gint length);
>
>
>
>void gtk_selection_remove_all (GtkWidget *widget);
>
>
>
>gint gtk_selection_clear (GtkWidget *widget,
>                                    GdkEventSelection *event);
>gint gtk_selection_request (GtkWidget *widget,
>                                    GdkEventSelection *event);
>gint gtk_selection_incr_event (GdkWindow *window,
>                                    GdkEventProperty *event);
>gint gtk_selection_notify (GtkWidget *widget,
>                                    GdkEventSelection *event);
>gint gtk_selection_property_notify (GtkWidget *widget,
>                                    GdkEventProperty *event);
>GtkSelectioData *gtk_selection_data_copy (GtkSelectionData *data);
>void gtk_selection_data_free (GtkSelectionData *data);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkdnd.h" 2
>
>
>
>
>
>typedef enum {
>  GTK_DEST_DEFAULT_MOTION = 1 << 0,
>  GTK_DEST_DEFAULT_HIGHLIGHT = 1 << 1,
>  GTK_DEST_DEFAULT_DROP = 1 << 2,
>  GTK_DEST_DEFAULT_ALL = 0x07
>} GtkDestDefaults;
>
>
>
>typedef enum {
>  GTK_TARGET_SAME_APP = 1 << 0,
>  GTK_TARGET_SAME_WIDGET = 1 << 1
>} GtkTargetFlags;
>
>
>
>void gtk_drag_get_data (GtkWidget *widget,
>                        GdkDragContext *context,
>                        GdkAtom target,
>                        guint32 time);
>void gtk_drag_finish (GdkDragContext *context,
>                        gboolean success,
>                        gboolean del,
>                        guint32 time);
>
>GtkWidget *gtk_drag_get_source_widget (GdkDragContext *context);
>
>void gtk_drag_highlight (GtkWidget *widget);
>void gtk_drag_unhighlight (GtkWidget *widget);
>
>void gtk_drag_dest_set (GtkWidget *widget,
>                          GtkDestDefaults flags,
>                          const GtkTargetEntry *targets,
>                          gint n_targets,
>                          GdkDragAction actions);
>
>void gtk_drag_dest_set_proxy (GtkWidget *widget,
>                              GdkWindow *proxy_window,
>                              GdkDragProtocol protocol,
>                              gboolean use_coordinates);
>
>
>
>
>
>void gtk_drag_dest_unset (GtkWidget *widget);
>
>
>
>void gtk_drag_source_set (GtkWidget *widget,
>                           GdkModifierType start_button_mask,
>                           const GtkTargetEntry *targets,
>                           gint n_targets,
>                           GdkDragAction actions);
>
>void gtk_drag_source_unset (GtkWidget *widget);
>
>void gtk_drag_source_set_icon (GtkWidget *widget,
>                               GdkColormap *colormap,
>                               GdkPixmap *pixmap,
>                               GdkBitmap *mask);
>
>
>
>
>
>GdkDragContext *gtk_drag_begin (GtkWidget *widget,
>                                GtkTargetList *targets,
>                                GdkDragAction actions,
>                                gint button,
>                                GdkEvent *event);
>
>
>
>void gtk_drag_set_icon_widget (GdkDragContext *context,
>                                GtkWidget *widget,
>                                gint hot_x,
>                                gint hot_y);
>
>void gtk_drag_set_icon_pixmap (GdkDragContext *context,
>                                GdkColormap *colormap,
>                                GdkPixmap *pixmap,
>                                GdkBitmap *mask,
>                                gint hot_x,
>                                gint hot_y);
>
>void gtk_drag_set_icon_default (GdkDragContext *context);
>
>void gtk_drag_set_default_icon (GdkColormap *colormap,
>                                GdkPixmap *pixmap,
>                                GdkBitmap *mask,
>                                gint hot_x,
>                                gint hot_y);
>
>
>
>void gtk_drag_source_handle_event (GtkWidget *widget,
>                                   GdkEvent *event);
>void gtk_drag_dest_handle_event (GtkWidget *toplevel,
>                                 GdkEvent *event);
># 57 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
>
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkfeatures.h" 1
># 63 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkfilesel.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkfilesel.h"
>typedef struct _GtkFileSelection GtkFileSelection;
>typedef struct _GtkFileSelectionClass GtkFileSelectionClass;
>
>struct _GtkFileSelection
>{
>  GtkWindow window;
>
>  GtkWidget *dir_list;
>  GtkWidget *file_list;
>  GtkWidget *selection_entry;
>  GtkWidget *selection_text;
>  GtkWidget *main_vbox;
>  GtkWidget *ok_button;
>  GtkWidget *cancel_button;
>  GtkWidget *help_button;
>  GtkWidget *history_pulldown;
>  GtkWidget *history_menu;
>  GList *history_list;
>  GtkWidget *fileop_dialog;
>  GtkWidget *fileop_entry;
>  gchar *fileop_file;
>  gpointer cmpl_state;
>
>  GtkWidget *fileop_c_dir;
>  GtkWidget *fileop_del_file;
>  GtkWidget *fileop_ren_file;
>
>  GtkWidget *button_area;
>  GtkWidget *action_area;
>
>};
>
>struct _GtkFileSelectionClass
>{
>  GtkWindowClass parent_class;
>};
>
>
>GtkType gtk_file_selection_get_type (void);
>GtkWidget* gtk_file_selection_new (const gchar *title);
>void gtk_file_selection_set_filename (GtkFileSelection *filesel,
>                                                   const gchar *filename);
>gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel);
>void gtk_file_selection_complete (GtkFileSelection *filesel,
>                                                   const gchar *pattern);
>void gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel);
>void gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel);
># 64 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkfixed.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkfixed.h"
>typedef struct _GtkFixed GtkFixed;
>typedef struct _GtkFixedClass GtkFixedClass;
>typedef struct _GtkFixedChild GtkFixedChild;
>
>struct _GtkFixed
>{
>  GtkContainer container;
>
>  GList *children;
>};
>
>struct _GtkFixedClass
>{
>  GtkContainerClass parent_class;
>};
>
>struct _GtkFixedChild
>{
>  GtkWidget *widget;
>  gint16 x;
>  gint16 y;
>};
>
>
>GtkType gtk_fixed_get_type (void);
>GtkWidget* gtk_fixed_new (void);
>void gtk_fixed_put (GtkFixed *fixed,
>                                        GtkWidget *widget,
>                                        gint16 x,
>                                        gint16 y);
>void gtk_fixed_move (GtkFixed *fixed,
>                                        GtkWidget *widget,
>                                        gint16 x,
>                                        gint16 y);
># 65 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h" 1
># 37 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtknotebook.h" 1
># 49 "/usr/X11R6/include/gtk12/gtk/gtknotebook.h"
>typedef struct _GtkNotebook GtkNotebook;
>typedef struct _GtkNotebookClass GtkNotebookClass;
>typedef struct _GtkNotebookPage GtkNotebookPage;
>
>struct _GtkNotebook
>{
>  GtkContainer container;
>
>  GtkNotebookPage *cur_page;
>  GList *children;
>  GList *first_tab;
>  GList *focus_tab;
>
>  GtkWidget *menu;
>  GdkWindow *panel;
>
>  guint32 timer;
>
>  guint16 tab_hborder;
>  guint16 tab_vborder;
>
>  guint show_tabs : 1;
>  guint homogeneous : 1;
>  guint show_border : 1;
>  guint tab_pos : 2;
>  guint scrollable : 1;
>  guint in_child : 2;
>  guint click_child : 2;
>  guint button : 2;
>  guint need_timer : 1;
>  guint child_has_focus : 1;
>  guint have_visible_child : 1;
>};
>
>struct _GtkNotebookClass
>{
>  GtkContainerClass parent_class;
>
>  void (* switch_page) (GtkNotebook *notebook,
>                              GtkNotebookPage *page,
>                              guint page_num);
>};
>
>struct _GtkNotebookPage
>{
>  GtkWidget *child;
>  GtkWidget *tab_label;
>  GtkWidget *menu_label;
>
>  guint default_menu : 1;
>  guint default_tab : 1;
>  guint expand : 1;
>  guint fill : 1;
>  guint pack : 1;
>
>  GtkRequisition requisition;
>  GtkAllocation allocation;
>};
>
>
>
>
>
>GtkType gtk_notebook_get_type (void);
>GtkWidget * gtk_notebook_new (void);
>void gtk_notebook_append_page (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label);
>void gtk_notebook_append_page_menu (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label,
>                                     GtkWidget *menu_label);
>void gtk_notebook_prepend_page (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label);
>void gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label,
>                                     GtkWidget *menu_label);
>void gtk_notebook_insert_page (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label,
>                                     gint position);
>void gtk_notebook_insert_page_menu (GtkNotebook *notebook,
>                                     GtkWidget *child,
>                                     GtkWidget *tab_label,
>                                     GtkWidget *menu_label,
>                                     gint position);
>void gtk_notebook_remove_page (GtkNotebook *notebook,
>                                     gint page_num);
>
>
>
>
>
>gint gtk_notebook_get_current_page (GtkNotebook *notebook);
>GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook,
>                                      gint page_num);
>gint gtk_notebook_page_num (GtkNotebook *notebook,
>                                    GtkWidget *child);
>void gtk_notebook_set_page (GtkNotebook *notebook,
>                                    gint page_num);
>void gtk_notebook_next_page (GtkNotebook *notebook);
>void gtk_notebook_prev_page (GtkNotebook *notebook);
>
>
>
>
>
>void gtk_notebook_set_show_border (GtkNotebook *notebook,
>                                        gboolean show_border);
>void gtk_notebook_set_show_tabs (GtkNotebook *notebook,
>                                        gboolean show_tabs);
>void gtk_notebook_set_tab_pos (GtkNotebook *notebook,
>                                        GtkPositionType pos);
>void gtk_notebook_set_homogeneous_tabs (GtkNotebook *notebook,
>                                        gboolean homogeneous);
>void gtk_notebook_set_tab_border (GtkNotebook *notebook,
>                                        guint border_width);
>void gtk_notebook_set_tab_hborder (GtkNotebook *notebook,
>                                        guint tab_hborder);
>void gtk_notebook_set_tab_vborder (GtkNotebook *notebook,
>                                        guint tab_vborder);
>void gtk_notebook_set_scrollable (GtkNotebook *notebook,
>                                        gboolean scrollable);
>
>
>
>
>
>void gtk_notebook_popup_enable (GtkNotebook *notebook);
>void gtk_notebook_popup_disable (GtkNotebook *notebook);
>
>
>
>
>
>GtkWidget * gtk_notebook_get_tab_label (GtkNotebook *notebook,
>                                           GtkWidget *child);
>void gtk_notebook_set_tab_label (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           GtkWidget *tab_label);
>void gtk_notebook_set_tab_label_text (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           const gchar *tab_text);
>GtkWidget * gtk_notebook_get_menu_label (GtkNotebook *notebook,
>                                           GtkWidget *child);
>void gtk_notebook_set_menu_label (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           GtkWidget *menu_label);
>void gtk_notebook_set_menu_label_text (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           const gchar *menu_text);
>void gtk_notebook_query_tab_label_packing (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           gboolean *expand,
>                                           gboolean *fill,
>                                           GtkPackType *pack_type);
>void gtk_notebook_set_tab_label_packing (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           gboolean expand,
>                                           gboolean fill,
>                                           GtkPackType pack_type);
>void gtk_notebook_reorder_child (GtkNotebook *notebook,
>                                           GtkWidget *child,
>                                           gint position);
># 38 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h" 2
># 56 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
>typedef struct _GtkFontSelection GtkFontSelection;
>typedef struct _GtkFontSelectionClass GtkFontSelectionClass;
>
>typedef struct _GtkFontSelectionDialog GtkFontSelectionDialog;
>typedef struct _GtkFontSelectionDialogClass GtkFontSelectionDialogClass;
># 76 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
>typedef enum
>{
>  GTK_FONT_METRIC_PIXELS,
>  GTK_FONT_METRIC_POINTS
>} GtkFontMetricType;
>
>
>
>typedef enum
>{
>  GTK_FONT_BITMAP = 1 << 0,
>  GTK_FONT_SCALABLE = 1 << 1,
>  GTK_FONT_SCALABLE_BITMAP = 1 << 2,
>
>  GTK_FONT_ALL = 0x07
>} GtkFontType;
>
>
>
>
>typedef enum
>{
>  GTK_FONT_FILTER_BASE,
>  GTK_FONT_FILTER_USER
>} GtkFontFilterType;
>
>
>
>
>typedef struct _GtkFontFilter GtkFontFilter;
>struct _GtkFontFilter
>{
>  gint font_type;
>  guint16 *property_filters[6];
>  guint16 property_nfilters[6];
>};
>
>
>struct _GtkFontSelection
>{
>  GtkNotebook notebook;
>
>
>  GtkWidget *main_vbox;
>  GtkWidget *font_label;
>  GtkWidget *font_entry;
>  GtkWidget *font_clist;
>  GtkWidget *font_style_entry;
>  GtkWidget *font_style_clist;
>  GtkWidget *size_entry;
>  GtkWidget *size_clist;
>  GtkWidget *pixels_button;
>  GtkWidget *points_button;
>  GtkWidget *filter_button;
>  GtkWidget *preview_entry;
>  GtkWidget *message_label;
>
>
>  GtkWidget *info_vbox;
>  GtkWidget *info_clist;
>  GtkWidget *requested_font_name;
>  GtkWidget *actual_font_name;
>
>
>  GtkWidget *filter_vbox;
>  GtkWidget *type_bitmaps_button;
>  GtkWidget *type_scalable_button;
>  GtkWidget *type_scaled_bitmaps_button;
>  GtkWidget *filter_clists[6];
>
>  GdkFont *font;
>  gint font_index;
>  gint style;
>  GtkFontMetricType metric;
>
>  gint size;
>
>
>
>  gint selected_size;
>
>
>
>  guint16 property_values[5];
>
>
>  GtkFontFilter filters[2];
>};
>
>
>struct _GtkFontSelectionClass
>{
>  GtkNotebookClass parent_class;
>};
>
>
>struct _GtkFontSelectionDialog
>{
>  GtkWindow window;
>
>  GtkWidget *fontsel;
>
>  GtkWidget *main_vbox;
>  GtkWidget *action_area;
>  GtkWidget *ok_button;
>
>  GtkWidget *apply_button;
>  GtkWidget *cancel_button;
>
>
>  gint dialog_width;
>  gboolean auto_resize;
>};
>
>struct _GtkFontSelectionDialogClass
>{
>  GtkWindowClass parent_class;
>};
># 202 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
>GtkType gtk_font_selection_get_type (void);
>GtkWidget* gtk_font_selection_new (void);
>gchar* gtk_font_selection_get_font_name (GtkFontSelection *fontsel);
>GdkFont* gtk_font_selection_get_font (GtkFontSelection *fontsel);
>gboolean gtk_font_selection_set_font_name (GtkFontSelection *fontsel,
>                                                 const gchar *fontname);
>void gtk_font_selection_set_filter (GtkFontSelection *fontsel,
>                                                 GtkFontFilterType filter_type,
>                                                 GtkFontType font_type,
>                                                 gchar **foundries,
>                                                 gchar **weights,
>                                                 gchar **slants,
>                                                 gchar **setwidths,
>                                                 gchar **spacings,
>                                                 gchar **charsets);
>gchar* gtk_font_selection_get_preview_text (GtkFontSelection *fontsel);
>void gtk_font_selection_set_preview_text (GtkFontSelection *fontsel,
>                                                 const gchar *text);
># 229 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
>GtkType gtk_font_selection_dialog_get_type (void);
>GtkWidget* gtk_font_selection_dialog_new (const gchar *title);
>
>
>
>
>
>
>gchar* gtk_font_selection_dialog_get_font_name (GtkFontSelectionDialog *fsd);
>
>
>
>
>GdkFont* gtk_font_selection_dialog_get_font (GtkFontSelectionDialog *fsd);
>
>
>
>
>
>gboolean gtk_font_selection_dialog_set_font_name (GtkFontSelectionDialog *fsd,
>                                                     const gchar *fontname);
># 273 "/usr/X11R6/include/gtk12/gtk/gtkfontsel.h"
>void gtk_font_selection_dialog_set_filter (GtkFontSelectionDialog *fsd,
>                                                 GtkFontFilterType filter_type,
>                                                 GtkFontType font_type,
>                                                 gchar **foundries,
>                                                 gchar **weights,
>                                                 gchar **slants,
>                                                 gchar **setwidths,
>                                                 gchar **spacings,
>                                                 gchar **charsets);
>
>
>
>gchar* gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd);
>
>
>
>void gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd,
>                                                     const gchar *text);
># 66 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkgamma.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkgamma.h"
>typedef struct _GtkGammaCurve GtkGammaCurve;
>typedef struct _GtkGammaCurveClass GtkGammaCurveClass;
>
>
>struct _GtkGammaCurve
>{
>  GtkVBox vbox;
>
>  GtkWidget *table;
>  GtkWidget *curve;
>  GtkWidget *button[5];
>
>  gfloat gamma;
>  GtkWidget *gamma_dialog;
>  GtkWidget *gamma_text;
>};
>
>struct _GtkGammaCurveClass
>{
>  GtkVBoxClass parent_class;
>};
>
>
>guint gtk_gamma_curve_get_type (void);
>GtkWidget* gtk_gamma_curve_new (void);
># 68 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkgc.h" 1
># 39 "/usr/X11R6/include/gtk12/gtk/gtkgc.h"
>GdkGC* gtk_gc_get (gint depth,
>                       GdkColormap *colormap,
>                       GdkGCValues *values,
>                       GdkGCValuesMask values_mask);
>void gtk_gc_release (GdkGC *gc);
># 69 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhandlebox.h" 1
># 53 "/usr/X11R6/include/gtk12/gtk/gtkhandlebox.h"
>typedef struct _GtkHandleBox GtkHandleBox;
>typedef struct _GtkHandleBoxClass GtkHandleBoxClass;
>
>struct _GtkHandleBox
>{
>  GtkBin bin;
>
>  GdkWindow *bin_window;
>  GdkWindow *float_window;
>  GtkShadowType shadow_type;
>  guint handle_position : 2;
>  guint float_window_mapped : 1;
>  guint child_detached : 1;
>  guint in_drag : 1;
>  guint shrink_on_detach : 1;
>
>  gint snap_edge : 3;
>
>
>
>  gint deskoff_x, deskoff_y;
>
>  GtkAllocation attach_allocation;
>  GtkAllocation float_allocation;
>};
>
>struct _GtkHandleBoxClass
>{
>  GtkBinClass parent_class;
>
>  void (*child_attached) (GtkHandleBox *handle_box,
>                                 GtkWidget *child);
>  void (*child_detached) (GtkHandleBox *handle_box,
>                                 GtkWidget *child);
>};
>
>
>GtkType gtk_handle_box_get_type (void);
>GtkWidget* gtk_handle_box_new (void);
>void gtk_handle_box_set_shadow_type (GtkHandleBox *handle_box,
>                                                 GtkShadowType type);
>void gtk_handle_box_set_handle_position (GtkHandleBox *handle_box,
>                                                 GtkPositionType position);
>void gtk_handle_box_set_snap_edge (GtkHandleBox *handle_box,
>                                                 GtkPositionType edge);
># 70 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhbbox.h" 1
># 44 "/usr/X11R6/include/gtk12/gtk/gtkhbbox.h"
>typedef struct _GtkHButtonBox GtkHButtonBox;
>typedef struct _GtkHButtonBoxClass GtkHButtonBoxClass;
>
>struct _GtkHButtonBox
>{
>  GtkButtonBox button_box;
>};
>
>struct _GtkHButtonBoxClass
>{
>  GtkButtonBoxClass parent_class;
>};
>
>
>guint gtk_hbutton_box_get_type (void);
>GtkWidget *gtk_hbutton_box_new (void);
>
>
>
>gint gtk_hbutton_box_get_spacing_default (void);
>GtkButtonBoxStyle gtk_hbutton_box_get_layout_default (void);
>
>void gtk_hbutton_box_set_spacing_default (gint spacing);
>void gtk_hbutton_box_set_layout_default (GtkButtonBoxStyle layout);
># 72 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhpaned.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkhpaned.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkpaned.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkpaned.h"
>typedef struct _GtkPaned GtkPaned;
>typedef struct _GtkPanedClass GtkPanedClass;
>
>struct _GtkPaned
>{
>  GtkContainer container;
>
>  GtkWidget *child1;
>  GtkWidget *child2;
>
>  GdkWindow *handle;
>  GdkRectangle groove_rectangle;
>  GdkGC *xor_gc;
>
>
>  guint16 handle_size;
>  guint16 gutter_size;
>
>
>  gint child1_size;
>  gint last_allocation;
>  gint min_position;
>  gint max_position;
>
>  guint position_set : 1;
>  guint in_drag : 1;
>  guint child1_shrink : 1;
>  guint child1_resize : 1;
>  guint child2_shrink : 1;
>  guint child2_resize : 1;
>
>  gint16 handle_xpos;
>  gint16 handle_ypos;
>};
>
>struct _GtkPanedClass
>{
>  GtkContainerClass parent_class;
>};
>
>
>GtkType gtk_paned_get_type (void);
>void gtk_paned_add1 (GtkPaned *paned,
>                                   GtkWidget *child);
>void gtk_paned_add2 (GtkPaned *paned,
>                                   GtkWidget *child);
>void gtk_paned_pack1 (GtkPaned *paned,
>                                   GtkWidget *child,
>                                   gboolean resize,
>                                   gboolean shrink);
>void gtk_paned_pack2 (GtkPaned *paned,
>                                   GtkWidget *child,
>                                   gboolean resize,
>                                   gboolean shrink);
>void gtk_paned_set_position (GtkPaned *paned,
>                                   gint position);
>void gtk_paned_set_handle_size (GtkPaned *paned,
>                                   guint16 size);
>void gtk_paned_set_gutter_size (GtkPaned *paned,
>                                   guint16 size);
>
>
>void gtk_paned_compute_position (GtkPaned *paned,
>                                    gint allocation,
>                                    gint child1_req,
>                                    gint child2_req);
>
>gboolean _gtk_paned_is_handle_full_size (GtkPaned *paned);
>void _gtk_paned_get_handle_rect (GtkPaned *paned,
>                                         GdkRectangle *rectangle);
>gint _gtk_paned_get_gutter_size (GtkPaned *paned);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkhpaned.h" 2
># 45 "/usr/X11R6/include/gtk12/gtk/gtkhpaned.h"
>typedef struct _GtkHPaned GtkHPaned;
>typedef struct _GtkHPanedClass GtkHPanedClass;
>
>struct _GtkHPaned
>{
>  GtkPaned paned;
>};
>
>struct _GtkHPanedClass
>{
>  GtkPanedClass parent_class;
>};
>
>
>guint gtk_hpaned_get_type (void);
>GtkWidget* gtk_hpaned_new (void);
># 73 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhruler.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkhruler.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkruler.h" 1
># 46 "/usr/X11R6/include/gtk12/gtk/gtkruler.h"
>typedef struct _GtkRuler GtkRuler;
>typedef struct _GtkRulerClass GtkRulerClass;
>typedef struct _GtkRulerMetric GtkRulerMetric;
>
>
>
>
>struct _GtkRuler
>{
>  GtkWidget widget;
>
>  GdkPixmap *backing_store;
>  GdkGC *non_gr_exp_gc;
>  GtkRulerMetric *metric;
>  gint xsrc, ysrc;
>  gint slider_size;
>
>
>  gfloat lower;
>
>  gfloat upper;
>
>  gfloat position;
>
>  gfloat max_size;
>};
>
>struct _GtkRulerClass
>{
>  GtkWidgetClass parent_class;
>
>  void (* draw_ticks) (GtkRuler *ruler);
>  void (* draw_pos) (GtkRuler *ruler);
>};
>
>struct _GtkRulerMetric
>{
>  gchar *metric_name;
>  gchar *abbrev;
>
>
>  gfloat pixels_per_unit;
>  gfloat ruler_scale[10];
>  gint subdivide[5];
>};
>
>
>GtkType gtk_ruler_get_type (void);
>void gtk_ruler_set_metric (GtkRuler *ruler,
>                              GtkMetricType metric);
>void gtk_ruler_set_range (GtkRuler *ruler,
>                              gfloat lower,
>                              gfloat upper,
>                              gfloat position,
>                              gfloat max_size);
>void gtk_ruler_draw_ticks (GtkRuler *ruler);
>void gtk_ruler_draw_pos (GtkRuler *ruler);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkhruler.h" 2
># 45 "/usr/X11R6/include/gtk12/gtk/gtkhruler.h"
>typedef struct _GtkHRuler GtkHRuler;
>typedef struct _GtkHRulerClass GtkHRulerClass;
>
>struct _GtkHRuler
>{
>  GtkRuler ruler;
>};
>
>struct _GtkHRulerClass
>{
>  GtkRulerClass parent_class;
>};
>
>
>guint gtk_hruler_get_type (void);
>GtkWidget* gtk_hruler_new (void);
># 74 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkhseparator.h" 1
># 32 "/usr/X11R6/include/gtk12/gtk/gtkhseparator.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkseparator.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkseparator.h"
>typedef struct _GtkSeparator GtkSeparator;
>typedef struct _GtkSeparatorClass GtkSeparatorClass;
>
>struct _GtkSeparator
>{
>  GtkWidget widget;
>};
>
>struct _GtkSeparatorClass
>{
>  GtkWidgetClass parent_class;
>};
>
>
>GtkType gtk_separator_get_type (void);
># 33 "/usr/X11R6/include/gtk12/gtk/gtkhseparator.h" 2
># 47 "/usr/X11R6/include/gtk12/gtk/gtkhseparator.h"
>typedef struct _GtkHSeparator GtkHSeparator;
>typedef struct _GtkHSeparatorClass GtkHSeparatorClass;
>
>struct _GtkHSeparator
>{
>  GtkSeparator separator;
>};
>
>struct _GtkHSeparatorClass
>{
>  GtkSeparatorClass parent_class;
>};
>
>
>GtkType gtk_hseparator_get_type (void);
>GtkWidget* gtk_hseparator_new (void);
># 77 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkimage.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkimage.h"
>typedef struct _GtkImage GtkImage;
>typedef struct _GtkImageClass GtkImageClass;
>
>struct _GtkImage
>{
>  GtkMisc misc;
>
>  GdkImage *image;
>  GdkBitmap *mask;
>};
>
>struct _GtkImageClass
>{
>  GtkMiscClass parent_class;
>};
>
>
>GtkType gtk_image_get_type (void);
>GtkWidget* gtk_image_new (GdkImage *val,
>                               GdkBitmap *mask);
>void gtk_image_set (GtkImage *image,
>                               GdkImage *val,
>                               GdkBitmap *mask);
>void gtk_image_get (GtkImage *image,
>                               GdkImage **val,
>                               GdkBitmap **mask);
># 78 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkinputdialog.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkinputdialog.h"
>typedef struct _GtkInputDialog GtkInputDialog;
>typedef struct _GtkInputDialogClass GtkInputDialogClass;
>
>struct _GtkInputDialog
>{
>  GtkDialog dialog;
>
>  GtkWidget *axis_list;
>  GtkWidget *axis_listbox;
>  GtkWidget *mode_optionmenu;
>
>  GtkWidget *close_button;
>  GtkWidget *save_button;
>
>  GtkWidget *axis_items[GDK_AXIS_LAST];
>  guint32 current_device;
>
>  GtkWidget *keys_list;
>  GtkWidget *keys_listbox;
>};
>
>struct _GtkInputDialogClass
>{
>  GtkWindowClass parent_class;
>
>  void (* enable_device) (GtkInputDialog *inputd,
>                                        guint32 devid);
>  void (* disable_device) (GtkInputDialog *inputd,
>                                        guint32 devid);
>};
>
>
>GtkType gtk_input_dialog_get_type (void);
>GtkWidget* gtk_input_dialog_new (void);
># 79 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h" 1
># 35 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmenufactory.h" 1
># 39 "/usr/X11R6/include/gtk12/gtk/gtkmenufactory.h"
>typedef struct _GtkMenuEntry GtkMenuEntry;
>typedef struct _GtkMenuPath GtkMenuPath;
>typedef struct _GtkMenuFactory GtkMenuFactory;
>
>typedef void (*GtkMenuCallback) (GtkWidget *widget,
>                                 gpointer user_data);
>
>struct _GtkMenuEntry
>{
>  gchar *path;
>  gchar *accelerator;
>  GtkMenuCallback callback;
>  gpointer callback_data;
>  GtkWidget *widget;
>};
>
>struct _GtkMenuPath
>{
>  char *path;
>  GtkWidget *widget;
>};
>
>struct _GtkMenuFactory
>{
>  gchar *path;
>  GtkMenuFactoryType type;
>  GtkAccelGroup *accel_group;
>  GtkWidget *widget;
>  GList *subfactories;
>};
>
>
>
>
>
>
>
>GtkMenuFactory* gtk_menu_factory_new (GtkMenuFactoryType type);
>void gtk_menu_factory_destroy (GtkMenuFactory *factory);
>void gtk_menu_factory_add_entries (GtkMenuFactory *factory,
>                                                    GtkMenuEntry *entries,
>                                                    int nentries);
>void gtk_menu_factory_add_subfactory (GtkMenuFactory *factory,
>                                                    GtkMenuFactory *subfactory,
>                                                    const char *path);
>void gtk_menu_factory_remove_paths (GtkMenuFactory *factory,
>                                                    char **paths,
>                                                    int npaths);
>void gtk_menu_factory_remove_entries (GtkMenuFactory *factory,
>                                                    GtkMenuEntry *entries,
>                                                    int nentries);
>void gtk_menu_factory_remove_subfactory (GtkMenuFactory *factory,
>                                                    GtkMenuFactory *subfactory,
>                                                    const char *path);
>GtkMenuPath* gtk_menu_factory_find (GtkMenuFactory *factory,
>                                                    const char *path);
># 36 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h" 2
># 44 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h"
>typedef void (*GtkPrintFunc) (gpointer func_data,
>                                            gchar *str);
>typedef gchar * (*GtkTranslateFunc) (const gchar *path,
>                                            gpointer func_data);
>typedef void (*GtkItemFactoryCallback) ();
>typedef void (*GtkItemFactoryCallback1) (gpointer callback_data,
>                                            guint callback_action,
>                                            GtkWidget *widget);
># 60 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h"
>typedef struct _GtkItemFactory GtkItemFactory;
>typedef struct _GtkItemFactoryClass GtkItemFactoryClass;
>typedef struct _GtkItemFactoryEntry GtkItemFactoryEntry;
>typedef struct _GtkItemFactoryItem GtkItemFactoryItem;
>
>struct _GtkItemFactory
>{
>  GtkObject object;
>
>  gchar *path;
>  GtkAccelGroup *accel_group;
>  GtkWidget *widget;
>  GSList *items;
>
>  GtkTranslateFunc translate_func;
>  gpointer translate_data;
>  GtkDestroyNotify translate_notify;
>};
>
>struct _GtkItemFactoryClass
>{
>  GtkObjectClass object_class;
>
>  gchar *cpair_comment_single;
>
>  GHashTable *item_ht;
>
>  gpointer dummy;
>};
>
>struct _GtkItemFactoryEntry
>{
>  gchar *path;
>  gchar *accelerator;
>
>  GtkItemFactoryCallback callback;
>  guint callback_action;
># 111 "/usr/X11R6/include/gtk12/gtk/gtkitemfactory.h"
>  gchar *item_type;
>};
>
>struct _GtkItemFactoryItem
>{
>  gchar *path;
>  guint accelerator_key;
>  guint accelerator_mods;
>  guint modified : 1;
>  guint in_propagation : 1;
>  gchar *dummy;
>
>  GSList *widgets;
>};
>
>
>GtkType gtk_item_factory_get_type (void);
>
>
>
>
>GtkItemFactory* gtk_item_factory_new (GtkType container_type,
>                                            const gchar *path,
>                                            GtkAccelGroup *accel_group);
>void gtk_item_factory_construct (GtkItemFactory *ifactory,
>                                            GtkType container_type,
>                                            const gchar *path,
>                                            GtkAccelGroup *accel_group);
>
>
>
>void gtk_item_factory_parse_rc (const gchar *file_name);
>void gtk_item_factory_parse_rc_string (const gchar *rc_string);
>void gtk_item_factory_parse_rc_scanner (GScanner *scanner);
>void gtk_item_factory_add_foreign (GtkWidget *accel_widget,
>                                                     const gchar *full_path,
>                                                     GtkAccelGroup *accel_group,
>                                                     guint keyval,
>                                                     GdkModifierType modifiers);
>
>GtkItemFactory* gtk_item_factory_from_widget (GtkWidget *widget);
>gchar* gtk_item_factory_path_from_widget (GtkWidget *widget);
>
>GtkWidget* gtk_item_factory_get_item (GtkItemFactory *ifactory,
>                                                       const gchar *path);
>GtkWidget* gtk_item_factory_get_widget (GtkItemFactory *ifactory,
>                                                       const gchar *path);
>GtkWidget* gtk_item_factory_get_widget_by_action (GtkItemFactory *ifactory,
>                                                       guint action);
>GtkWidget* gtk_item_factory_get_item_by_action (GtkItemFactory *ifactory,
>                                                       guint action);
>
>
>
>
>
>void gtk_item_factory_dump_items (GtkPatternSpec *path_pspec,
>                                         gboolean modified_only,
>                                         GtkPrintFunc print_func,
>                                         gpointer func_data);
>void gtk_item_factory_dump_rc (const gchar *file_name,
>                                         GtkPatternSpec *path_pspec,
>                                         gboolean modified_only);
>void gtk_item_factory_print_func (gpointer FILE_pointer,
>                                         gchar *string);
>void gtk_item_factory_create_item (GtkItemFactory *ifactory,
>                                         GtkItemFactoryEntry *entry,
>                                         gpointer callback_data,
>                                         guint callback_type);
>void gtk_item_factory_create_items (GtkItemFactory *ifactory,
>                                         guint n_entries,
>                                         GtkItemFactoryEntry *entries,
>                                         gpointer callback_data);
>void gtk_item_factory_delete_item (GtkItemFactory *ifactory,
>                                         const gchar *path);
>void gtk_item_factory_delete_entry (GtkItemFactory *ifactory,
>                                         GtkItemFactoryEntry *entry);
>void gtk_item_factory_delete_entries (GtkItemFactory *ifactory,
>                                         guint n_entries,
>                                         GtkItemFactoryEntry *entries);
>void gtk_item_factory_popup (GtkItemFactory *ifactory,
>                                         guint x,
>                                         guint y,
>                                         guint mouse_button,
>                                         guint32 time);
>void gtk_item_factory_popup_with_data(GtkItemFactory *ifactory,
>                                         gpointer popup_data,
>                                         GtkDestroyNotify destroy,
>                                         guint x,
>                                         guint y,
>                                         guint mouse_button,
>                                         guint32 time);
>gpointer gtk_item_factory_popup_data (GtkItemFactory *ifactory);
>gpointer gtk_item_factory_popup_data_from_widget (GtkWidget *widget);
>void gtk_item_factory_set_translate_func (GtkItemFactory *ifactory,
>                                            GtkTranslateFunc func,
>                                            gpointer data,
>                                            GtkDestroyNotify notify);
>
>
>
>GtkItemFactory* gtk_item_factory_from_path (const gchar *path);
>void gtk_item_factory_create_menu_entries (guint n_entries,
>                                              GtkMenuEntry *entries);
>void gtk_item_factories_path_delete (const gchar *ifactory_path,
>                                            const gchar *path);
>typedef void (*GtkItemFactoryCallback2) (GtkWidget *widget,
>                                            gpointer callback_data,
>                                            guint callback_action);
>void gtk_item_factory_create_items_ac (GtkItemFactory *ifactory,
>                                          guint n_entries,
>                                          GtkItemFactoryEntry *entries,
>                                          gpointer callback_data,
>                                          guint callback_type);
># 81 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtklayout.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtklayout.h"
>typedef struct _GtkLayout GtkLayout;
>typedef struct _GtkLayoutClass GtkLayoutClass;
>
>struct _GtkLayout {
>  GtkContainer container;
>
>  GList *children;
>
>  guint width;
>  guint height;
>
>  guint xoffset;
>  guint yoffset;
>
>  GtkAdjustment *hadjustment;
>  GtkAdjustment *vadjustment;
>
>  GdkWindow *bin_window;
>
>  GdkVisibilityState visibility;
>  gulong configure_serial;
>  gint scroll_x;
>  gint scroll_y;
>
>  guint freeze_count;
>};
>
>struct _GtkLayoutClass {
>  GtkContainerClass parent_class;
>
>  void (*set_scroll_adjustments) (GtkLayout *layout,
>                                     GtkAdjustment *hadjustment,
>                                     GtkAdjustment *vadjustment);
>};
>
>GtkType gtk_layout_get_type (void);
>GtkWidget* gtk_layout_new (GtkAdjustment *hadjustment,
>                                           GtkAdjustment *vadjustment);
>void gtk_layout_put (GtkLayout *layout,
>                                           GtkWidget *widget,
>                                           gint x,
>                                           gint y);
>
>void gtk_layout_move (GtkLayout *layout,
>                                           GtkWidget *widget,
>                                           gint x,
>                                           gint y);
>
>void gtk_layout_set_size (GtkLayout *layout,
>                                           guint width,
>                                           guint height);
>
>GtkAdjustment* gtk_layout_get_hadjustment (GtkLayout *layout);
>GtkAdjustment* gtk_layout_get_vadjustment (GtkLayout *layout);
>void gtk_layout_set_hadjustment (GtkLayout *layout,
>                                           GtkAdjustment *adjustment);
>void gtk_layout_set_vadjustment (GtkLayout *layout,
>                                           GtkAdjustment *adjustment);
># 115 "/usr/X11R6/include/gtk12/gtk/gtklayout.h"
>void gtk_layout_freeze (GtkLayout *layout);
>void gtk_layout_thaw (GtkLayout *layout);
># 83 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtklist.h" 1
># 34 "/usr/X11R6/include/gtk12/gtk/gtklist.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtklistitem.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtklistitem.h"
>typedef struct _GtkListItem GtkListItem;
>typedef struct _GtkListItemClass GtkListItemClass;
>
>struct _GtkListItem
>{
>  GtkItem item;
>};
>
>struct _GtkListItemClass
>{
>  GtkItemClass parent_class;
>
>  void (*toggle_focus_row) (GtkListItem *list_item);
>  void (*select_all) (GtkListItem *list_item);
>  void (*unselect_all) (GtkListItem *list_item);
>  void (*undo_selection) (GtkListItem *list_item);
>  void (*start_selection) (GtkListItem *list_item);
>  void (*end_selection) (GtkListItem *list_item);
>  void (*extend_selection) (GtkListItem *list_item,
>                             GtkScrollType scroll_type,
>                             gfloat position,
>                             gboolean auto_start_selection);
>  void (*scroll_horizontal) (GtkListItem *list_item,
>                             GtkScrollType scroll_type,
>                             gfloat position);
>  void (*scroll_vertical) (GtkListItem *list_item,
>                             GtkScrollType scroll_type,
>                             gfloat position);
>  void (*toggle_add_mode) (GtkListItem *list_item);
>};
>
>
>GtkType gtk_list_item_get_type (void);
>GtkWidget* gtk_list_item_new (void);
>GtkWidget* gtk_list_item_new_with_label (const gchar *label);
>void gtk_list_item_select (GtkListItem *list_item);
>void gtk_list_item_deselect (GtkListItem *list_item);
># 35 "/usr/X11R6/include/gtk12/gtk/gtklist.h" 2
># 48 "/usr/X11R6/include/gtk12/gtk/gtklist.h"
>typedef struct _GtkList GtkList;
>typedef struct _GtkListClass GtkListClass;
>
>struct _GtkList
>{
>  GtkContainer container;
>
>  GList *children;
>  GList *selection;
>
>  GList *undo_selection;
>  GList *undo_unselection;
>
>  GtkWidget *last_focus_child;
>  GtkWidget *undo_focus_child;
>
>  guint htimer;
>  guint vtimer;
>
>  gint anchor;
>  gint drag_pos;
>  GtkStateType anchor_state;
>
>  guint selection_mode : 2;
>  guint drag_selection:1;
>  guint add_mode:1;
>};
>
>struct _GtkListClass
>{
>  GtkContainerClass parent_class;
>
>  void (* selection_changed) (GtkList *list);
>  void (* select_child) (GtkList *list,
>                              GtkWidget *child);
>  void (* unselect_child) (GtkList *list,
>                              GtkWidget *child);
>};
>
>
>GtkType gtk_list_get_type (void);
>GtkWidget* gtk_list_new (void);
>void gtk_list_insert_items (GtkList *list,
>                                           GList *items,
>                                           gint position);
>void gtk_list_append_items (GtkList *list,
>                                           GList *items);
>void gtk_list_prepend_items (GtkList *list,
>                                           GList *items);
>void gtk_list_remove_items (GtkList *list,
>                                           GList *items);
>void gtk_list_remove_items_no_unref (GtkList *list,
>                                           GList *items);
>void gtk_list_clear_items (GtkList *list,
>                                           gint start,
>                                           gint end);
>void gtk_list_select_item (GtkList *list,
>                                           gint item);
>void gtk_list_unselect_item (GtkList *list,
>                                           gint item);
>void gtk_list_select_child (GtkList *list,
>                                           GtkWidget *child);
>void gtk_list_unselect_child (GtkList *list,
>                                           GtkWidget *child);
>gint gtk_list_child_position (GtkList *list,
>                                           GtkWidget *child);
>void gtk_list_set_selection_mode (GtkList *list,
>                                           GtkSelectionMode mode);
>
>void gtk_list_extend_selection (GtkList *list,
>                                           GtkScrollType scroll_type,
>                                           gfloat position,
>                                           gboolean auto_start_selection);
>void gtk_list_start_selection (GtkList *list);
>void gtk_list_end_selection (GtkList *list);
>void gtk_list_select_all (GtkList *list);
>void gtk_list_unselect_all (GtkList *list);
>void gtk_list_scroll_horizontal (GtkList *list,
>                                           GtkScrollType scroll_type,
>                                           gfloat position);
>void gtk_list_scroll_vertical (GtkList *list,
>                                           GtkScrollType scroll_type,
>                                           gfloat position);
>void gtk_list_toggle_add_mode (GtkList *list);
>void gtk_list_toggle_focus_row (GtkList *list);
>void gtk_list_toggle_row (GtkList *list,
>                                           GtkWidget *item);
>void gtk_list_undo_selection (GtkList *list);
>void gtk_list_end_drag_selection (GtkList *list);
># 84 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmenu.h" 1
># 33 "/usr/X11R6/include/gtk12/gtk/gtkmenu.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmenushell.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkmenushell.h"
>typedef struct _GtkMenuShell GtkMenuShell;
>typedef struct _GtkMenuShellClass GtkMenuShellClass;
>
>struct _GtkMenuShell
>{
>  GtkContainer container;
>
>  GList *children;
>  GtkWidget *active_menu_item;
>  GtkWidget *parent_menu_shell;
>
>  guint active : 1;
>  guint have_grab : 1;
>  guint have_xgrab : 1;
>  guint button : 2;
>  guint ignore_leave : 1;
>  guint menu_flag : 1;
>  guint ignore_enter : 1;
>
>  guint32 activate_time;
>};
>
>struct _GtkMenuShellClass
>{
>  GtkContainerClass parent_class;
>
>  guint submenu_placement : 1;
>
>  void (*deactivate) (GtkMenuShell *menu_shell);
>  void (*selection_done) (GtkMenuShell *menu_shell);
>
>  void (*move_current) (GtkMenuShell *menu_shell,
>                            GtkMenuDirectionType direction);
>  void (*activate_current) (GtkMenuShell *menu_shell,
>                            gboolean force_hide);
>  void (*cancel) (GtkMenuShell *menu_shell);
>};
>
>
>GtkType gtk_menu_shell_get_type (void);
>void gtk_menu_shell_append (GtkMenuShell *menu_shell,
>                                   GtkWidget *child);
>void gtk_menu_shell_prepend (GtkMenuShell *menu_shell,
>                                   GtkWidget *child);
>void gtk_menu_shell_insert (GtkMenuShell *menu_shell,
>                                   GtkWidget *child,
>                                   gint position);
>void gtk_menu_shell_deactivate (GtkMenuShell *menu_shell);
>void gtk_menu_shell_select_item (GtkMenuShell *menu_shell,
>                                    GtkWidget *menu_item);
>void gtk_menu_shell_deselect (GtkMenuShell *menu_shell);
>void gtk_menu_shell_activate_item (GtkMenuShell *menu_shell,
>                                       GtkWidget *menu_item,
>                                       gboolean force_deactivate);
># 34 "/usr/X11R6/include/gtk12/gtk/gtkmenu.h" 2
># 48 "/usr/X11R6/include/gtk12/gtk/gtkmenu.h"
>typedef struct _GtkMenu GtkMenu;
>typedef struct _GtkMenuClass GtkMenuClass;
>
>typedef void (*GtkMenuPositionFunc) (GtkMenu *menu,
>                                     gint *x,
>                                     gint *y,
>                                     gpointer user_data);
>typedef void (*GtkMenuDetachFunc) (GtkWidget *attach_widget,
>                                     GtkMenu *menu);
>
>struct _GtkMenu
>{
>  GtkMenuShell menu_shell;
>
>  GtkWidget *parent_menu_item;
>  GtkWidget *old_active_menu_item;
>
>  GtkAccelGroup *accel_group;
>  GtkMenuPositionFunc position_func;
>  gpointer position_func_data;
>
>
>
>
>
>  GtkWidget *toplevel;
>  GtkWidget *tearoff_window;
>
>  guint torn_off : 1;
>};
>
>struct _GtkMenuClass
>{
>  GtkMenuShellClass parent_class;
>};
>
>
>GtkType gtk_menu_get_type (void);
>GtkWidget* gtk_menu_new (void);
>
>
>void gtk_menu_append (GtkMenu *menu,
>                                           GtkWidget *child);
>void gtk_menu_prepend (GtkMenu *menu,
>                                           GtkWidget *child);
>void gtk_menu_insert (GtkMenu *menu,
>                                           GtkWidget *child,
>                                           gint position);
>
>
>void gtk_menu_popup (GtkMenu *menu,
>                                           GtkWidget *parent_menu_shell,
>                                           GtkWidget *parent_menu_item,
>                                           GtkMenuPositionFunc func,
>                                           gpointer data,
>                                           guint button,
>                                           guint32 activate_time);
>
>
>
>
>void gtk_menu_reposition (GtkMenu *menu);
>
>void gtk_menu_popdown (GtkMenu *menu);
>
>
>
>
>GtkWidget* gtk_menu_get_active (GtkMenu *menu);
>void gtk_menu_set_active (GtkMenu *menu,
>                                           guint index);
>
>
>
>
>void gtk_menu_set_accel_group (GtkMenu *menu,
>                                           GtkAccelGroup *accel_group);
>GtkAccelGroup* gtk_menu_get_accel_group (GtkMenu *menu);
>
>
>
>
>GtkAccelGroup* gtk_menu_get_uline_accel_group (GtkMenu *menu);
>GtkAccelGroup* gtk_menu_ensure_uline_accel_group (GtkMenu *menu);
>
>
>
>
>
>
>void gtk_menu_attach_to_widget (GtkMenu *menu,
>                                           GtkWidget *attach_widget,
>                                           GtkMenuDetachFunc detacher);
>void gtk_menu_detach (GtkMenu *menu);
>
>
>
>
>
>GtkWidget* gtk_menu_get_attach_widget (GtkMenu *menu);
>
>void gtk_menu_set_tearoff_state (GtkMenu *menu,
>                                           gboolean torn_off);
>
>
>
>
>void gtk_menu_set_title (GtkMenu *menu,
>                                           const gchar *title);
>
>void gtk_menu_reorder_child (GtkMenu *menu,
>                                           GtkWidget *child,
>                                           gint position);
># 87 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkmenubar.h" 1
># 46 "/usr/X11R6/include/gtk12/gtk/gtkmenubar.h"
>typedef struct _GtkMenuBar GtkMenuBar;
>typedef struct _GtkMenuBarClass GtkMenuBarClass;
>
>struct _GtkMenuBar
>{
>  GtkMenuShell menu_shell;
>
>  GtkShadowType shadow_type;
>};
>
>struct _GtkMenuBarClass
>{
>  GtkMenuShellClass parent_class;
>};
>
>
>GtkType gtk_menu_bar_get_type (void);
>GtkWidget* gtk_menu_bar_new (void);
>void gtk_menu_bar_append (GtkMenuBar *menu_bar,
>                                         GtkWidget *child);
>void gtk_menu_bar_prepend (GtkMenuBar *menu_bar,
>                                         GtkWidget *child);
>void gtk_menu_bar_insert (GtkMenuBar *menu_bar,
>                                         GtkWidget *child,
>                                         gint position);
>void gtk_menu_bar_set_shadow_type (GtkMenuBar *menu_bar,
>                                         GtkShadowType type);
># 88 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
>
>
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkoptionmenu.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkoptionmenu.h"
>typedef struct _GtkOptionMenu GtkOptionMenu;
>typedef struct _GtkOptionMenuClass GtkOptionMenuClass;
>
>struct _GtkOptionMenu
>{
>  GtkButton button;
>
>  GtkWidget *menu;
>  GtkWidget *menu_item;
>
>  guint16 width;
>  guint16 height;
>};
>
>struct _GtkOptionMenuClass
>{
>  GtkButtonClass parent_class;
>};
>
>
>GtkType gtk_option_menu_get_type (void);
>GtkWidget* gtk_option_menu_new (void);
>GtkWidget* gtk_option_menu_get_menu (GtkOptionMenu *option_menu);
>void gtk_option_menu_set_menu (GtkOptionMenu *option_menu,
>                                        GtkWidget *menu);
>void gtk_option_menu_remove_menu (GtkOptionMenu *option_menu);
>void gtk_option_menu_set_history (GtkOptionMenu *option_menu,
>                                        guint index);
># 95 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkpacker.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkpacker.h"
>typedef struct _GtkPacker GtkPacker;
>typedef struct _GtkPackerClass GtkPackerClass;
>typedef struct _GtkPackerChild GtkPackerChild;
>
>typedef enum
>{
>    GTK_PACK_EXPAND = 1 << 0,
>    GTK_FILL_X = 1 << 1,
>    GTK_FILL_Y = 1 << 2
>} GtkPackerOptions;
>
>typedef enum
>{
>    GTK_SIDE_TOP,
>    GTK_SIDE_BOTTOM,
>    GTK_SIDE_LEFT,
>    GTK_SIDE_RIGHT
>} GtkSideType;
>
>typedef enum
>{
>  GTK_ANCHOR_CENTER,
>  GTK_ANCHOR_NORTH,
>  GTK_ANCHOR_NORTH_WEST,
>  GTK_ANCHOR_NORTH_EAST,
>  GTK_ANCHOR_SOUTH,
>  GTK_ANCHOR_SOUTH_WEST,
>  GTK_ANCHOR_SOUTH_EAST,
>  GTK_ANCHOR_WEST,
>  GTK_ANCHOR_EAST,
>  GTK_ANCHOR_N = GTK_ANCHOR_NORTH,
>  GTK_ANCHOR_NW = GTK_ANCHOR_NORTH_WEST,
>  GTK_ANCHOR_NE = GTK_ANCHOR_NORTH_EAST,
>  GTK_ANCHOR_S = GTK_ANCHOR_SOUTH,
>  GTK_ANCHOR_SW = GTK_ANCHOR_SOUTH_WEST,
>  GTK_ANCHOR_SE = GTK_ANCHOR_SOUTH_EAST,
>  GTK_ANCHOR_W = GTK_ANCHOR_WEST,
>  GTK_ANCHOR_E = GTK_ANCHOR_EAST
>} GtkAnchorType;
>
>struct _GtkPackerChild
>{
>  GtkWidget *widget;
>
>  GtkAnchorType anchor;
>  GtkSideType side;
>  GtkPackerOptions options;
>
>  guint use_default : 1;
>
>  guint border_width : 16;
>  guint pad_x : 16;
>  guint pad_y : 16;
>  guint i_pad_x : 16;
>  guint i_pad_y : 16;
>};
>
>struct _GtkPacker
>{
>  GtkContainer parent;
>
>  GList *children;
>
>  guint spacing;
>
>  guint default_border_width : 16;
>  guint default_pad_x : 16;
>  guint default_pad_y : 16;
>  guint default_i_pad_x : 16;
>  guint default_i_pad_y : 16;
>};
>
>struct _GtkPackerClass
>{
>  GtkContainerClass parent_class;
>};
>
>
>GtkType gtk_packer_get_type (void);
>GtkWidget* gtk_packer_new (void);
>void gtk_packer_add_defaults (GtkPacker *packer,
>                                                GtkWidget *child,
>                                                GtkSideType side,
>                                                GtkAnchorType anchor,
>                                                GtkPackerOptions options);
>void gtk_packer_add (GtkPacker *packer,
>                                                GtkWidget *child,
>                                                GtkSideType side,
>                                                GtkAnchorType anchor,
>                                                GtkPackerOptions options,
>                                                guint border_width,
>                                                guint pad_x,
>                                                guint pad_y,
>                                                guint i_pad_x,
>                                                guint i_pad_y);
>void gtk_packer_set_child_packing (GtkPacker *packer,
>                                                GtkWidget *child,
>                                                GtkSideType side,
>                                                GtkAnchorType anchor,
>                                                GtkPackerOptions options,
>                                                guint border_width,
>                                                guint pad_x,
>                                                guint pad_y,
>                                                guint i_pad_x,
>                                                guint i_pad_y);
>void gtk_packer_reorder_child (GtkPacker *packer,
>                                                GtkWidget *child,
>                                                gint position);
>void gtk_packer_set_spacing (GtkPacker *packer,
>                                                guint spacing);
>void gtk_packer_set_default_border_width (GtkPacker *packer,
>                                                guint border);
>void gtk_packer_set_default_pad (GtkPacker *packer,
>                                                guint pad_x,
>                                                guint pad_y);
>void gtk_packer_set_default_ipad (GtkPacker *packer,
>                                                guint i_pad_x,
>                                                guint i_pad_y);
># 96 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkpixmap.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkpixmap.h"
>typedef struct _GtkPixmap GtkPixmap;
>typedef struct _GtkPixmapClass GtkPixmapClass;
>
>struct _GtkPixmap
>{
>  GtkMisc misc;
>
>  GdkPixmap *pixmap;
>  GdkBitmap *mask;
>
>  GdkPixmap *pixmap_insensitive;
>  guint build_insensitive : 1;
>};
>
>struct _GtkPixmapClass
>{
>  GtkMiscClass parent_class;
>};
>
>
>GtkType gtk_pixmap_get_type (void);
>GtkWidget* gtk_pixmap_new (GdkPixmap *pixmap,
>                                  GdkBitmap *mask);
>void gtk_pixmap_set (GtkPixmap *pixmap,
>                                  GdkPixmap *val,
>                                  GdkBitmap *mask);
>void gtk_pixmap_get (GtkPixmap *pixmap,
>                                  GdkPixmap **val,
>                                  GdkBitmap **mask);
>
>void gtk_pixmap_set_build_insensitive (GtkPixmap *pixmap,
>                                             guint build);
># 98 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkplug.h" 1
># 44 "/usr/X11R6/include/gtk12/gtk/gtkplug.h"
>typedef struct _GtkPlug GtkPlug;
>typedef struct _GtkPlugClass GtkPlugClass;
>
>
>struct _GtkPlug
>{
>  GtkWindow window;
>
>  GdkWindow *socket_window;
>  gint same_app;
>};
>
>struct _GtkPlugClass
>{
>  GtkWindowClass parent_class;
>};
>
>
>guint gtk_plug_get_type (void);
>void gtk_plug_construct (GtkPlug *plug, guint32 socket_id);
>GtkWidget* gtk_plug_new (guint32 socket_id);
># 99 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkprogress.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkprogress.h"
>typedef struct _GtkProgress GtkProgress;
>typedef struct _GtkProgressClass GtkProgressClass;
>
>
>struct _GtkProgress
>{
>  GtkWidget widget;
>
>  GtkAdjustment *adjustment;
>  GdkPixmap *offscreen_pixmap;
>  gchar *format;
>  gfloat x_align;
>  gfloat y_align;
>
>  guint show_text : 1;
>  guint activity_mode : 1;
>};
>
>struct _GtkProgressClass
>{
>  GtkWidgetClass parent_class;
>
>  void (* paint) (GtkProgress *progress);
>  void (* update) (GtkProgress *progress);
>  void (* act_mode_enter) (GtkProgress *progress);
>};
>
>
>GtkType gtk_progress_get_type (void);
>void gtk_progress_set_show_text (GtkProgress *progress,
>                                             gint show_text);
>void gtk_progress_set_text_alignment (GtkProgress *progress,
>                                             gfloat x_align,
>                                             gfloat y_align);
>void gtk_progress_set_format_string (GtkProgress *progress,
>                                             const gchar *format);
>void gtk_progress_set_adjustment (GtkProgress *progress,
>                                             GtkAdjustment *adjustment);
>void gtk_progress_configure (GtkProgress *progress,
>                                             gfloat value,
>                                             gfloat min,
>                                             gfloat max);
>void gtk_progress_set_percentage (GtkProgress *progress,
>                                             gfloat percentage);
>void gtk_progress_set_value (GtkProgress *progress,
>                                             gfloat value);
>gfloat gtk_progress_get_value (GtkProgress *progress);
>void gtk_progress_set_activity_mode (GtkProgress *progress,
>                                             guint activity_mode);
>gchar* gtk_progress_get_current_text (GtkProgress *progress);
>gchar* gtk_progress_get_text_from_value (GtkProgress *progress,
>                                             gfloat value);
>gfloat gtk_progress_get_current_percentage (GtkProgress *progress);
>gfloat gtk_progress_get_percentage_from_value (GtkProgress *progress,
>                                                   gfloat value);
># 101 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkprogressbar.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkprogressbar.h"
>typedef struct _GtkProgressBar GtkProgressBar;
>typedef struct _GtkProgressBarClass GtkProgressBarClass;
>
>typedef enum
>{
>  GTK_PROGRESS_CONTINUOUS,
>  GTK_PROGRESS_DISCRETE
>} GtkProgressBarStyle;
>
>typedef enum
>{
>  GTK_PROGRESS_LEFT_TO_RIGHT,
>  GTK_PROGRESS_RIGHT_TO_LEFT,
>  GTK_PROGRESS_BOTTOM_TO_TOP,
>  GTK_PROGRESS_TOP_TO_BOTTOM
>} GtkProgressBarOrientation;
>
>struct _GtkProgressBar
>{
>  GtkProgress progress;
>
>  GtkProgressBarStyle bar_style;
>  GtkProgressBarOrientation orientation;
>
>  guint blocks;
>  gint in_block;
>
>  gint activity_pos;
>  guint activity_step;
>  guint activity_blocks;
>  guint activity_dir : 1;
>};
>
>struct _GtkProgressBarClass
>{
>  GtkProgressClass parent_class;
>};
>
>
>GtkType gtk_progress_bar_get_type (void);
>GtkWidget* gtk_progress_bar_new (void);
>GtkWidget* gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment);
>void gtk_progress_bar_set_bar_style (GtkProgressBar *pbar,
>                                                  GtkProgressBarStyle style);
>void gtk_progress_bar_set_discrete_blocks (GtkProgressBar *pbar,
>                                                  guint blocks);
>void gtk_progress_bar_set_activity_step (GtkProgressBar *pbar,
>                                                  guint step);
>void gtk_progress_bar_set_activity_blocks (GtkProgressBar *pbar,
>                                                  guint blocks);
>void gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
>                                                  GtkProgressBarOrientation orientation);
>void gtk_progress_bar_update (GtkProgressBar *pbar,
>                                                  gfloat percentage);
># 102 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkradiobutton.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkradiobutton.h"
>typedef struct _GtkRadioButton GtkRadioButton;
>typedef struct _GtkRadioButtonClass GtkRadioButtonClass;
>
>struct _GtkRadioButton
>{
>  GtkCheckButton check_button;
>
>  GSList *group;
>};
>
>struct _GtkRadioButtonClass
>{
>  GtkCheckButtonClass parent_class;
>};
>
>
>GtkType gtk_radio_button_get_type (void);
>GtkWidget* gtk_radio_button_new (GSList *group);
>GtkWidget* gtk_radio_button_new_from_widget (GtkRadioButton *group);
>GtkWidget* gtk_radio_button_new_with_label (GSList *group,
>                                              const gchar *label);
>GtkWidget* gtk_radio_button_new_with_label_from_widget (GtkRadioButton *group,
>                                                         const gchar *label);
>GSList* gtk_radio_button_group (GtkRadioButton *radio_button);
>void gtk_radio_button_set_group (GtkRadioButton *radio_button,
>                                              GSList *group);
># 103 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkradiomenuitem.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkradiomenuitem.h"
>typedef struct _GtkRadioMenuItem GtkRadioMenuItem;
>typedef struct _GtkRadioMenuItemClass GtkRadioMenuItemClass;
>
>struct _GtkRadioMenuItem
>{
>  GtkCheckMenuItem check_menu_item;
>
>  GSList *group;
>};
>
>struct _GtkRadioMenuItemClass
>{
>  GtkCheckMenuItemClass parent_class;
>};
>
>
>GtkType gtk_radio_menu_item_get_type (void);
>GtkWidget* gtk_radio_menu_item_new (GSList *group);
>GtkWidget* gtk_radio_menu_item_new_with_label (GSList *group,
>                                               const gchar *label);
>GSList* gtk_radio_menu_item_group (GtkRadioMenuItem *radio_menu_item);
>void gtk_radio_menu_item_set_group (GtkRadioMenuItem *radio_menu_item,
>                                               GSList *group);
># 104 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkrc.h" 1
># 39 "/usr/X11R6/include/gtk12/gtk/gtkrc.h"
>typedef enum {
>  GTK_RC_FG = 1 << 0,
>  GTK_RC_BG = 1 << 1,
>  GTK_RC_TEXT = 1 << 2,
>  GTK_RC_BASE = 1 << 3
>} GtkRcFlags;
>
>struct _GtkRcStyle
>{
>  gchar *name;
>  gchar *font_name;
>  gchar *fontset_name;
>  gchar *bg_pixmap_name[5];
>
>  GtkRcFlags color_flags[5];
>  GdkColor fg[5];
>  GdkColor bg[5];
>  GdkColor text[5];
>  GdkColor base[5];
>
>  GtkThemeEngine *engine;
>  gpointer engine_data;
>};
>
>void gtk_rc_init (void);
>void gtk_rc_add_default_file (const gchar *filename);
>void gtk_rc_set_default_files (gchar **filenames);
>gchar** gtk_rc_get_default_files (void);
>void gtk_rc_parse (const gchar *filename);
>void gtk_rc_parse_string (const gchar *rc_string);
>gboolean gtk_rc_reparse_all (void);
>GtkStyle* gtk_rc_get_style (GtkWidget *widget);
>void gtk_rc_add_widget_name_style (GtkRcStyle *rc_style,
>                                         const gchar *pattern);
>void gtk_rc_add_widget_class_style (GtkRcStyle *rc_style,
>                                         const gchar *pattern);
>void gtk_rc_add_class_style (GtkRcStyle *rc_style,
>                                         const gchar *pattern);
>
>GtkRcStyle* gtk_rc_style_new (void);
>void gtk_rc_style_ref (GtkRcStyle *rc_style);
>void gtk_rc_style_unref (GtkRcStyle *rc_style);
>
>
>
>
>typedef GdkPixmap* (*GtkImageLoader) (GdkWindow *window,
>                                                 GdkColormap *colormap,
>                                                 GdkBitmap **mask,
>                                                 GdkColor *transparent_color,
>                                                 const gchar *filename);
>void gtk_rc_set_image_loader (GtkImageLoader loader);
>
>GdkPixmap* gtk_rc_load_image (GdkColormap *colormap,
>                                                 GdkColor *transparent_color,
>                                                 const gchar *filename);
>gchar* gtk_rc_find_pixmap_in_path (GScanner *scanner,
>                                                 const gchar *pixmap_file);
>gchar* gtk_rc_find_module_in_path (const gchar *module_file);
>gchar* gtk_rc_get_theme_dir (void);
>gchar* gtk_rc_get_module_dir (void);
>
>
>typedef enum {
>  GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
>  GTK_RC_TOKEN_INCLUDE,
>  GTK_RC_TOKEN_NORMAL,
>  GTK_RC_TOKEN_ACTIVE,
>  GTK_RC_TOKEN_PRELIGHT,
>  GTK_RC_TOKEN_SELECTED,
>  GTK_RC_TOKEN_INSENSITIVE,
>  GTK_RC_TOKEN_FG,
>  GTK_RC_TOKEN_BG,
>  GTK_RC_TOKEN_BASE,
>  GTK_RC_TOKEN_TEXT,
>  GTK_RC_TOKEN_FONT,
>  GTK_RC_TOKEN_FONTSET,
>  GTK_RC_TOKEN_BG_PIXMAP,
>  GTK_RC_TOKEN_PIXMAP_PATH,
>  GTK_RC_TOKEN_STYLE,
>  GTK_RC_TOKEN_BINDING,
>  GTK_RC_TOKEN_BIND,
>  GTK_RC_TOKEN_WIDGET,
>  GTK_RC_TOKEN_WIDGET_CLASS,
>  GTK_RC_TOKEN_CLASS,
>  GTK_RC_TOKEN_LOWEST,
>  GTK_RC_TOKEN_GTK,
>  GTK_RC_TOKEN_APPLICATION,
>  GTK_RC_TOKEN_RC,
>  GTK_RC_TOKEN_HIGHEST,
>  GTK_RC_TOKEN_ENGINE,
>  GTK_RC_TOKEN_MODULE_PATH,
>  GTK_RC_TOKEN_LAST
>} GtkRcTokenType;
>
>guint gtk_rc_parse_color (GScanner *scanner,
>                                 GdkColor *color);
>guint gtk_rc_parse_state (GScanner *scanner,
>                                 GtkStateType *state);
>guint gtk_rc_parse_priority (GScanner *scanner,
>                                 GtkPathPriorityType *priority);
># 106 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkscrolledwindow.h" 1
># 34 "/usr/X11R6/include/gtk12/gtk/gtkscrolledwindow.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtkviewport.h" 1
># 48 "/usr/X11R6/include/gtk12/gtk/gtkviewport.h"
>typedef struct _GtkViewport GtkViewport;
>typedef struct _GtkViewportClass GtkViewportClass;
>
>struct _GtkViewport
>{
>  GtkBin bin;
>
>  GtkShadowType shadow_type;
>  GdkWindow *view_window;
>  GdkWindow *bin_window;
>  GtkAdjustment *hadjustment;
>  GtkAdjustment *vadjustment;
>};
>
>struct _GtkViewportClass
>{
>  GtkBinClass parent_class;
>
>  void (*set_scroll_adjustments) (GtkViewport *viewport,
>                                         GtkAdjustment *hadjustment,
>                                         GtkAdjustment *vadjustment);
>};
>
>
>GtkType gtk_viewport_get_type (void);
>GtkWidget* gtk_viewport_new (GtkAdjustment *hadjustment,
>                                             GtkAdjustment *vadjustment);
>GtkAdjustment* gtk_viewport_get_hadjustment (GtkViewport *viewport);
>GtkAdjustment* gtk_viewport_get_vadjustment (GtkViewport *viewport);
>void gtk_viewport_set_hadjustment (GtkViewport *viewport,
>                                             GtkAdjustment *adjustment);
>void gtk_viewport_set_vadjustment (GtkViewport *viewport,
>                                             GtkAdjustment *adjustment);
>void gtk_viewport_set_shadow_type (GtkViewport *viewport,
>                                             GtkShadowType type);
># 35 "/usr/X11R6/include/gtk12/gtk/gtkscrolledwindow.h" 2
># 49 "/usr/X11R6/include/gtk12/gtk/gtkscrolledwindow.h"
>typedef struct _GtkScrolledWindow GtkScrolledWindow;
>typedef struct _GtkScrolledWindowClass GtkScrolledWindowClass;
>
>struct _GtkScrolledWindow
>{
>  GtkBin container;
>
>  GtkWidget *hscrollbar;
>  GtkWidget *vscrollbar;
>
>  guint hscrollbar_policy : 2;
>  guint vscrollbar_policy : 2;
>  guint hscrollbar_visible : 1;
>  guint vscrollbar_visible : 1;
>  guint window_placement : 2;
>};
>
>struct _GtkScrolledWindowClass
>{
>  GtkBinClass parent_class;
>
>  gint scrollbar_spacing;
>};
>
>
>GtkType gtk_scrolled_window_get_type (void);
>GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
>                                                      GtkAdjustment *vadjustment);
>void gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
>                                                      GtkAdjustment *hadjustment);
>void gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
>                                                      GtkAdjustment *hadjustment);
>GtkAdjustment* gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window);
>GtkAdjustment* gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window);
>void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
>                                                      GtkPolicyType hscrollbar_policy,
>                                                      GtkPolicyType vscrollbar_policy);
>void gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
>                                                      GtkCornerType window_placement);
>void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
>                                                      GtkWidget *child);
># 110 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtksocket.h" 1
># 41 "/usr/X11R6/include/gtk12/gtk/gtksocket.h"
>typedef struct _GtkSocket GtkSocket;
>typedef struct _GtkSocketClass GtkSocketClass;
>
>struct _GtkSocket
>{
>  GtkContainer container;
>
>  guint16 request_width;
>  guint16 request_height;
>  guint16 current_width;
>  guint16 current_height;
>
>  GdkWindow *plug_window;
>  guint same_app : 1;
>  guint focus_in : 1;
>  guint have_size : 1;
>  guint need_map : 1;
>};
>
>struct _GtkSocketClass
>{
>  GtkContainerClass parent_class;
>};
>
>
>GtkWidget* gtk_socket_new (void);
>guint gtk_socket_get_type (void );
>void gtk_socket_steal (GtkSocket *socket,
>                                    guint32 wid);
># 114 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkspinbutton.h" 1
># 51 "/usr/X11R6/include/gtk12/gtk/gtkspinbutton.h"
>typedef enum
>{
>  GTK_UPDATE_ALWAYS,
>  GTK_UPDATE_IF_VALID
>} GtkSpinButtonUpdatePolicy;
>
>typedef enum
>{
>  GTK_SPIN_STEP_FORWARD,
>  GTK_SPIN_STEP_BACKWARD,
>  GTK_SPIN_PAGE_FORWARD,
>  GTK_SPIN_PAGE_BACKWARD,
>  GTK_SPIN_HOME,
>  GTK_SPIN_END,
>  GTK_SPIN_USER_DEFINED
>} GtkSpinType;
>
>
>typedef struct _GtkSpinButton GtkSpinButton;
>typedef struct _GtkSpinButtonClass GtkSpinButtonClass;
>
>
>struct _GtkSpinButton
>{
>  GtkEntry entry;
>
>  GtkAdjustment *adjustment;
>
>  GdkWindow *panel;
>  GtkShadowType shadow_type;
>
>  guint32 timer;
>  guint32 ev_time;
>
>  gfloat climb_rate;
>  gfloat timer_step;
>
>  GtkSpinButtonUpdatePolicy update_policy;
>
>  guint in_child : 2;
>  guint click_child : 2;
>  guint button : 2;
>  guint need_timer : 1;
>  guint timer_calls : 3;
>  guint digits : 3;
>  guint numeric : 1;
>  guint wrap : 1;
>  guint snap_to_ticks : 1;
>};
>
>struct _GtkSpinButtonClass
>{
>  GtkEntryClass parent_class;
>};
>
>
>GtkType gtk_spin_button_get_type (void);
>
>void gtk_spin_button_configure (GtkSpinButton *spin_button,
>                                                    GtkAdjustment *adjustment,
>                                                    gfloat climb_rate,
>                                                    guint digits);
>
>GtkWidget* gtk_spin_button_new (GtkAdjustment *adjustment,
>                                                    gfloat climb_rate,
>                                                    guint digits);
>
>void gtk_spin_button_set_adjustment (GtkSpinButton *spin_button,
>                                                    GtkAdjustment *adjustment);
>
>GtkAdjustment* gtk_spin_button_get_adjustment (GtkSpinButton *spin_button);
>
>void gtk_spin_button_set_digits (GtkSpinButton *spin_button,
>                                                    guint digits);
>
>gfloat gtk_spin_button_get_value_as_float (GtkSpinButton *spin_button);
>
>gint gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button);
>
>void gtk_spin_button_set_value (GtkSpinButton *spin_button,
>                                                    gfloat value);
>
>void gtk_spin_button_set_update_policy (GtkSpinButton *spin_button,
>                                                    GtkSpinButtonUpdatePolicy policy);
>
>void gtk_spin_button_set_numeric (GtkSpinButton *spin_button,
>                                                    gboolean numeric);
>
>void gtk_spin_button_spin (GtkSpinButton *spin_button,
>                                                    GtkSpinType direction,
>                                                    gfloat increment);
>
>void gtk_spin_button_set_wrap (GtkSpinButton *spin_button,
>                                                    gboolean wrap);
>
>void gtk_spin_button_set_shadow_type (GtkSpinButton *spin_button,
>                                                    GtkShadowType shadow_type);
>
>void gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button,
>                                                    gboolean snap_to_ticks);
>void gtk_spin_button_update (GtkSpinButton *spin_button);
># 115 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkstatusbar.h" 1
># 41 "/usr/X11R6/include/gtk12/gtk/gtkstatusbar.h"
>typedef struct _GtkStatusbar GtkStatusbar;
>typedef struct _GtkStatusbarClass GtkStatusbarClass;
>typedef struct _GtkStatusbarMsg GtkStatusbarMsg;
>
>struct _GtkStatusbar
>{
>  GtkHBox parent_widget;
>
>  GtkWidget *frame;
>  GtkWidget *label;
>
>  GSList *messages;
>  GSList *keys;
>
>  guint seq_context_id;
>  guint seq_message_id;
>};
>
>struct _GtkStatusbarClass
>{
>  GtkHBoxClass parent_class;
>
>  GMemChunk *messages_mem_chunk;
>
>  void (*text_pushed) (GtkStatusbar *statusbar,
>                         guint context_id,
>                         const gchar *text);
>  void (*text_popped) (GtkStatusbar *statusbar,
>                         guint context_id,
>                         const gchar *text);
>};
>
>struct _GtkStatusbarMsg
>{
>  gchar *text;
>  guint context_id;
>  guint message_id;
>};
>
>guint gtk_statusbar_get_type (void);
>GtkWidget* gtk_statusbar_new (void);
>guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
>                                         const gchar *context_description);
>
>guint gtk_statusbar_push (GtkStatusbar *statusbar,
>                                         guint context_id,
>                                         const gchar *text);
>void gtk_statusbar_pop (GtkStatusbar *statusbar,
>                                         guint context_id);
>void gtk_statusbar_remove (GtkStatusbar *statusbar,
>                                         guint context_id,
>                                         guint message_id);
># 117 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtktearoffmenuitem.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtktearoffmenuitem.h"
>typedef struct _GtkTearoffMenuItem GtkTearoffMenuItem;
>typedef struct _GtkTearoffMenuItemClass GtkTearoffMenuItemClass;
>
>struct _GtkTearoffMenuItem
>{
>  GtkMenuItem menu_item;
>
>  guint torn_off : 1;
>};
>
>struct _GtkTearoffMenuItemClass
>{
>  GtkMenuItemClass parent_class;
>};
>
>
>GtkType gtk_tearoff_menu_item_get_type (void);
>GtkWidget* gtk_tearoff_menu_item_new (void);
># 119 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtktext.h" 1
># 46 "/usr/X11R6/include/gtk12/gtk/gtktext.h"
>typedef struct _GtkTextFont GtkTextFont;
>typedef struct _GtkPropertyMark GtkPropertyMark;
>typedef struct _GtkText GtkText;
>typedef struct _GtkTextClass GtkTextClass;
>
>struct _GtkPropertyMark
>{
>
>  GList* property;
>
>
>  guint offset;
>
>
>  guint index;
>};
>
>struct _GtkText
>{
>  GtkEditable editable;
>
>  GdkWindow *text_area;
>
>  GtkAdjustment *hadj;
>  GtkAdjustment *vadj;
>
>  GdkGC *gc;
>
>  GdkPixmap* line_wrap_bitmap;
>  GdkPixmap* line_arrow_bitmap;
>
>
>
>
>
>  union { GdkWChar *wc; guchar *ch; } text;
>
>  guint text_len;
>
>
>  guint gap_position;
>
>
>  guint gap_size;
>
>
>
>  guint text_end;
>
>
>
>  GList *line_start_cache;
>
>  guint first_line_start_index;
>
>  guint first_cut_pixels;
>
>  guint first_onscreen_hor_pixel;
>
>  guint first_onscreen_ver_pixel;
>
>
>
>
>
>  guint line_wrap : 1;
>  guint word_wrap : 1;
>
>
>  guint use_wchar : 1;
>
>
>  guint freeze_count;
>
>
>
>  GList *text_properties;
>
>  GList *text_properties_end;
>
>
>
>
>  GtkPropertyMark point;
>
>
>
>  union { GdkWChar *wc; guchar *ch; } scratch_buffer;
>  guint scratch_buffer_len;
>
>
>
>  gint last_ver_value;
>
>
>
>  gint cursor_pos_x;
>  gint cursor_pos_y;
>  GtkPropertyMark cursor_mark;
>  GdkWChar cursor_char;
>  gchar cursor_char_offset;
>  gint cursor_virtual_x;
>  gint cursor_drawn_level;
>
>
>
>  GList *current_line;
>
>
>
>  GList *tab_stops;
>  gint default_tab_width;
>
>  GtkTextFont *current_font;
>
>
>  gint timer;
>
>  guint button;
>  GdkGC *bg_gc;
>};
>
>struct _GtkTextClass
>{
>  GtkEditableClass parent_class;
>
>  void (*set_scroll_adjustments) (GtkText *text,
>                                     GtkAdjustment *hadjustment,
>                                     GtkAdjustment *vadjustment);
>};
>
>
>GtkType gtk_text_get_type (void);
>GtkWidget* gtk_text_new (GtkAdjustment *hadj,
>                                     GtkAdjustment *vadj);
>void gtk_text_set_editable (GtkText *text,
>                                     gboolean editable);
>void gtk_text_set_word_wrap (GtkText *text,
>                                     gint word_wrap);
>void gtk_text_set_line_wrap (GtkText *text,
>                                     gint line_wrap);
>void gtk_text_set_adjustments (GtkText *text,
>                                     GtkAdjustment *hadj,
>                                     GtkAdjustment *vadj);
>void gtk_text_set_point (GtkText *text,
>                                     guint index);
>guint gtk_text_get_point (GtkText *text);
>guint gtk_text_get_length (GtkText *text);
>void gtk_text_freeze (GtkText *text);
>void gtk_text_thaw (GtkText *text);
>void gtk_text_insert (GtkText *text,
>                                     GdkFont *font,
>                                     GdkColor *fore,
>                                     GdkColor *back,
>                                     const char *chars,
>                                     gint length);
>gint gtk_text_backward_delete (GtkText *text,
>                                     guint nchars);
>gint gtk_text_forward_delete (GtkText *text,
>                                     guint nchars);
># 120 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkthemes.h" 1
># 41 "/usr/X11R6/include/gtk12/gtk/gtkthemes.h"
>struct _GtkThemeEngine {
>
>
>
>
>  guint (*parse_rc_style) (GScanner *scanner, GtkRcStyle *rc_style);
>
>
>
>
>
>  void (*merge_rc_style) (GtkRcStyle *dest, GtkRcStyle *src);
>
>
>  void (*rc_style_to_style) (GtkStyle *style, GtkRcStyle *rc_style);
>
>
>
>
>
>  void (*duplicate_style) (GtkStyle *dest, GtkStyle *src);
>
>
>
>
>
>
>  void (*realize_style) (GtkStyle *new_style);
>
>
>
>
>  void (*unrealize_style) (GtkStyle *new_style);
>
>
>  void (*destroy_rc_style) (GtkRcStyle *rc_style);
>
>
>  void (*destroy_style) (GtkStyle *style);
>
>  void (*set_background) (GtkStyle *style,
>                          GdkWindow *window,
>                          GtkStateType state_type);
>};
>
>GtkThemeEngine *gtk_theme_engine_get (const gchar *name);
>void gtk_theme_engine_ref (GtkThemeEngine *engine);
>void gtk_theme_engine_unref (GtkThemeEngine *engine);
># 121 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtktipsquery.h" 1
># 51 "/usr/X11R6/include/gtk12/gtk/gtktipsquery.h"
>typedef struct _GtkTipsQuery GtkTipsQuery;
>typedef struct _GtkTipsQueryClass GtkTipsQueryClass;
>
>
>
>struct _GtkTipsQuery
>{
>  GtkLabel label;
>
>  guint emit_always : 1;
>  guint in_query : 1;
>  gchar *label_inactive;
>  gchar *label_no_tip;
>
>  GtkWidget *caller;
>  GtkWidget *last_crossed;
>
>  GdkCursor *query_cursor;
>};
>
>struct _GtkTipsQueryClass
>{
>  GtkLabelClass parent_class;
>
>  void (*start_query) (GtkTipsQuery *tips_query);
>  void (*stop_query) (GtkTipsQuery *tips_query);
>  void (*widget_entered) (GtkTipsQuery *tips_query,
>                                 GtkWidget *widget,
>                                 const gchar *tip_text,
>                                 const gchar *tip_private);
>  gint (*widget_selected) (GtkTipsQuery *tips_query,
>                                 GtkWidget *widget,
>                                 const gchar *tip_text,
>                                 const gchar *tip_private,
>                                 GdkEventButton *event);
>};
>
>
>
>GtkType gtk_tips_query_get_type (void);
>GtkWidget* gtk_tips_query_new (void);
>void gtk_tips_query_start_query (GtkTipsQuery *tips_query);
>void gtk_tips_query_stop_query (GtkTipsQuery *tips_query);
>void gtk_tips_query_set_caller (GtkTipsQuery *tips_query,
>                                                 GtkWidget *caller);
>void gtk_tips_query_set_labels (GtkTipsQuery *tips_query,
>                                                 const gchar *label_inactive,
>                                                 const gchar *label_no_tip);
># 122 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtktoolbar.h" 1
># 37 "/usr/X11R6/include/gtk12/gtk/gtktoolbar.h"
># 1 "/usr/X11R6/include/gtk12/gtk/gtktooltips.h" 1
># 44 "/usr/X11R6/include/gtk12/gtk/gtktooltips.h"
>typedef struct _GtkTooltips GtkTooltips;
>typedef struct _GtkTooltipsClass GtkTooltipsClass;
>typedef struct _GtkTooltipsData GtkTooltipsData;
>
>struct _GtkTooltipsData
>{
>  GtkTooltips *tooltips;
>  GtkWidget *widget;
>  gchar *tip_text;
>  gchar *tip_private;
>  GdkFont *font;
>  gint width;
>  GList *row;
>};
>
>struct _GtkTooltips
>{
>  GtkData data;
>
>  GtkWidget *tip_window;
>  GtkTooltipsData *active_tips_data;
>  GList *tips_data_list;
>
>  GdkGC *gc;
>  GdkColor *foreground;
>  GdkColor *background;
>
>  guint delay : 30;
>  guint enabled : 1;
>  gint timer_tag;
>};
>
>struct _GtkTooltipsClass
>{
>  GtkDataClass parent_class;
>};
>
>GtkType gtk_tooltips_get_type (void);
>GtkTooltips* gtk_tooltips_new (void);
>
>void gtk_tooltips_enable (GtkTooltips *tooltips);
>void gtk_tooltips_disable (GtkTooltips *tooltips);
>void gtk_tooltips_set_delay (GtkTooltips *tooltips,
>                                            guint delay);
>void gtk_tooltips_set_tip (GtkTooltips *tooltips,
>                                            GtkWidget *widget,
>                                            const gchar *tip_text,
>                                            const gchar *tip_private);
>void gtk_tooltips_set_colors (GtkTooltips *tooltips,
>                                            GdkColor *background,
>                                            GdkColor *foreground);
>GtkTooltipsData* gtk_tooltips_data_get (GtkWidget *widget);
>void gtk_tooltips_force_window (GtkTooltips *tooltips);
># 38 "/usr/X11R6/include/gtk12/gtk/gtktoolbar.h" 2
># 51 "/usr/X11R6/include/gtk12/gtk/gtktoolbar.h"
>typedef enum
>{
>  GTK_TOOLBAR_CHILD_SPACE,
>  GTK_TOOLBAR_CHILD_BUTTON,
>  GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
>  GTK_TOOLBAR_CHILD_RADIOBUTTON,
>  GTK_TOOLBAR_CHILD_WIDGET
>} GtkToolbarChildType;
>
>typedef enum
>{
>  GTK_TOOLBAR_SPACE_EMPTY,
>  GTK_TOOLBAR_SPACE_LINE
>} GtkToolbarSpaceStyle;
>
>typedef struct _GtkToolbarChild GtkToolbarChild;
>typedef struct _GtkToolbar GtkToolbar;
>typedef struct _GtkToolbarClass GtkToolbarClass;
>
>struct _GtkToolbarChild
>{
>  GtkToolbarChildType type;
>  GtkWidget *widget;
>  GtkWidget *icon;
>  GtkWidget *label;
>};
>
>struct _GtkToolbar
>{
>  GtkContainer container;
>
>  gint num_children;
>  GList *children;
>  GtkOrientation orientation;
>  GtkToolbarStyle style;
>  gint space_size;
>  GtkToolbarSpaceStyle space_style;
>
>  GtkTooltips *tooltips;
>
>  gint button_maxw;
>  gint button_maxh;
>  GtkReliefStyle relief;
>};
>
>struct _GtkToolbarClass
>{
>  GtkContainerClass parent_class;
>
>  void (* orientation_changed) (GtkToolbar *toolbar,
>                                GtkOrientation orientation);
>  void (* style_changed) (GtkToolbar *toolbar,
>                                GtkToolbarStyle style);
>};
>
>
>GtkType gtk_toolbar_get_type (void);
>GtkWidget* gtk_toolbar_new (GtkOrientation orientation,
>                                        GtkToolbarStyle style);
>
>
>GtkWidget* gtk_toolbar_append_item (GtkToolbar *toolbar,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data);
>GtkWidget* gtk_toolbar_prepend_item (GtkToolbar *toolbar,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data);
>GtkWidget* gtk_toolbar_insert_item (GtkToolbar *toolbar,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data,
>                                        gint position);
>
>
>void gtk_toolbar_append_space (GtkToolbar *toolbar);
>void gtk_toolbar_prepend_space (GtkToolbar *toolbar);
>void gtk_toolbar_insert_space (GtkToolbar *toolbar,
>                                        gint position);
>
>
>GtkWidget* gtk_toolbar_append_element (GtkToolbar *toolbar,
>                                        GtkToolbarChildType type,
>                                        GtkWidget *widget,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data);
>
>GtkWidget* gtk_toolbar_prepend_element (GtkToolbar *toolbar,
>                                        GtkToolbarChildType type,
>                                        GtkWidget *widget,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data);
>
>GtkWidget* gtk_toolbar_insert_element (GtkToolbar *toolbar,
>                                        GtkToolbarChildType type,
>                                        GtkWidget *widget,
>                                        const char *text,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        GtkWidget *icon,
>                                        GtkSignalFunc callback,
>                                        gpointer user_data,
>                                        gint position);
>
>
>void gtk_toolbar_append_widget (GtkToolbar *toolbar,
>                                        GtkWidget *widget,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text);
>void gtk_toolbar_prepend_widget (GtkToolbar *toolbar,
>                                        GtkWidget *widget,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text);
>void gtk_toolbar_insert_widget (GtkToolbar *toolbar,
>                                        GtkWidget *widget,
>                                        const char *tooltip_text,
>                                        const char *tooltip_private_text,
>                                        gint position);
>
>
>void gtk_toolbar_set_orientation (GtkToolbar *toolbar,
>                                              GtkOrientation orientation);
>void gtk_toolbar_set_style (GtkToolbar *toolbar,
>                                              GtkToolbarStyle style);
>void gtk_toolbar_set_space_size (GtkToolbar *toolbar,
>                                              gint space_size);
>void gtk_toolbar_set_space_style (GtkToolbar *toolbar,
>                                              GtkToolbarSpaceStyle space_style);
>void gtk_toolbar_set_tooltips (GtkToolbar *toolbar,
>                                              gint enable);
>void gtk_toolbar_set_button_relief (GtkToolbar *toolbar,
>                                              GtkReliefStyle relief);
>GtkReliefStyle gtk_toolbar_get_button_relief (GtkToolbar *toolbar);
># 124 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtktree.h" 1
># 52 "/usr/X11R6/include/gtk12/gtk/gtktree.h"
>typedef enum
>{
>  GTK_TREE_VIEW_LINE,
>  GTK_TREE_VIEW_ITEM
>} GtkTreeViewMode;
>
>typedef struct _GtkTree GtkTree;
>typedef struct _GtkTreeClass GtkTreeClass;
>
>struct _GtkTree
>{
>  GtkContainer container;
>
>  GList *children;
>
>  GtkTree* root_tree;
>  GtkWidget* tree_owner;
>  GList *selection;
>  guint level;
>  guint indent_value;
>  guint current_indent;
>  guint selection_mode : 2;
>  guint view_mode : 1;
>  guint view_line : 1;
>};
>
>struct _GtkTreeClass
>{
>  GtkContainerClass parent_class;
>
>  void (* selection_changed) (GtkTree *tree);
>  void (* select_child) (GtkTree *tree,
>                              GtkWidget *child);
>  void (* unselect_child) (GtkTree *tree,
>                              GtkWidget *child);
>};
>
>
>GtkType gtk_tree_get_type (void);
>GtkWidget* gtk_tree_new (void);
>void gtk_tree_append (GtkTree *tree,
>                                        GtkWidget *tree_item);
>void gtk_tree_prepend (GtkTree *tree,
>                                        GtkWidget *tree_item);
>void gtk_tree_insert (GtkTree *tree,
>                                        GtkWidget *tree_item,
>                                        gint position);
>void gtk_tree_remove_items (GtkTree *tree,
>                                        GList *items);
>void gtk_tree_clear_items (GtkTree *tree,
>                                        gint start,
>                                        gint end);
>void gtk_tree_select_item (GtkTree *tree,
>                                        gint item);
>void gtk_tree_unselect_item (GtkTree *tree,
>                                        gint item);
>void gtk_tree_select_child (GtkTree *tree,
>                                        GtkWidget *tree_item);
>void gtk_tree_unselect_child (GtkTree *tree,
>                                        GtkWidget *tree_item);
>gint gtk_tree_child_position (GtkTree *tree,
>                                        GtkWidget *child);
>void gtk_tree_set_selection_mode (GtkTree *tree,
>                                        GtkSelectionMode mode);
>void gtk_tree_set_view_mode (GtkTree *tree,
>                                        GtkTreeViewMode mode);
>void gtk_tree_set_view_lines (GtkTree *tree,
>                                        guint flag);
>
>
>
>void gtk_tree_remove_item (GtkTree *tree,
>                                        GtkWidget *child);
># 126 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtktreeitem.h" 1
># 49 "/usr/X11R6/include/gtk12/gtk/gtktreeitem.h"
>typedef struct _GtkTreeItem GtkTreeItem;
>typedef struct _GtkTreeItemClass GtkTreeItemClass;
>
>struct _GtkTreeItem
>{
>  GtkItem item;
>
>  GtkWidget *subtree;
>  GtkWidget *pixmaps_box;
>  GtkWidget *plus_pix_widget, *minus_pix_widget;
>
>  GList *pixmaps;
>
>  guint expanded : 1;
>};
>
>struct _GtkTreeItemClass
>{
>  GtkItemClass parent_class;
>
>  void (* expand) (GtkTreeItem *tree_item);
>  void (* collapse) (GtkTreeItem *tree_item);
>};
>
>
>GtkType gtk_tree_item_get_type (void);
>GtkWidget* gtk_tree_item_new (void);
>GtkWidget* gtk_tree_item_new_with_label (const gchar *label);
>void gtk_tree_item_set_subtree (GtkTreeItem *tree_item,
>                                         GtkWidget *subtree);
>void gtk_tree_item_remove_subtree (GtkTreeItem *tree_item);
>void gtk_tree_item_select (GtkTreeItem *tree_item);
>void gtk_tree_item_deselect (GtkTreeItem *tree_item);
>void gtk_tree_item_expand (GtkTreeItem *tree_item);
>void gtk_tree_item_collapse (GtkTreeItem *tree_item);
># 127 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvbbox.h" 1
># 44 "/usr/X11R6/include/gtk12/gtk/gtkvbbox.h"
>typedef struct _GtkVButtonBox GtkVButtonBox;
>typedef struct _GtkVButtonBoxClass GtkVButtonBoxClass;
>
>struct _GtkVButtonBox
>{
>  GtkButtonBox button_box;
>};
>
>struct _GtkVButtonBoxClass
>{
>  GtkButtonBoxClass parent_class;
>};
>
>
>guint gtk_vbutton_box_get_type (void);
>GtkWidget *gtk_vbutton_box_new (void);
>
>
>
>gint gtk_vbutton_box_get_spacing_default (void);
>void gtk_vbutton_box_set_spacing_default (gint spacing);
>
>GtkButtonBoxStyle gtk_vbutton_box_get_layout_default (void);
>void gtk_vbutton_box_set_layout_default (GtkButtonBoxStyle layout);
># 130 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvpaned.h" 1
># 45 "/usr/X11R6/include/gtk12/gtk/gtkvpaned.h"
>typedef struct _GtkVPaned GtkVPaned;
>typedef struct _GtkVPanedClass GtkVPanedClass;
>
>struct _GtkVPaned
>{
>  GtkPaned paned;
>};
>
>struct _GtkVPanedClass
>{
>  GtkPanedClass parent_class;
>};
>
>
>guint gtk_vpaned_get_type (void);
>GtkWidget* gtk_vpaned_new (void);
># 132 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvruler.h" 1
># 45 "/usr/X11R6/include/gtk12/gtk/gtkvruler.h"
>typedef struct _GtkVRuler GtkVRuler;
>typedef struct _GtkVRulerClass GtkVRulerClass;
>
>struct _GtkVRuler
>{
>  GtkRuler ruler;
>};
>
>struct _GtkVRulerClass
>{
>  GtkRulerClass parent_class;
>};
>
>
>guint gtk_vruler_get_type (void);
>GtkWidget* gtk_vruler_new (void);
># 133 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvscale.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkvscale.h"
>typedef struct _GtkVScale GtkVScale;
>typedef struct _GtkVScaleClass GtkVScaleClass;
>
>struct _GtkVScale
>{
>  GtkScale scale;
>};
>
>struct _GtkVScaleClass
>{
>  GtkScaleClass parent_class;
>};
>
>
>GtkType gtk_vscale_get_type (void);
>GtkWidget* gtk_vscale_new (GtkAdjustment *adjustment);
># 134 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
>
># 1 "/usr/X11R6/include/gtk12/gtk/gtkvseparator.h" 1
># 47 "/usr/X11R6/include/gtk12/gtk/gtkvseparator.h"
>typedef struct _GtkVSeparator GtkVSeparator;
>typedef struct _GtkVSeparatorClass GtkVSeparatorClass;
>
>struct _GtkVSeparator
>{
>  GtkSeparator separator;
>};
>
>struct _GtkVSeparatorClass
>{
>  GtkSeparatorClass parent_class;
>};
>
>
>GtkType gtk_vseparator_get_type (void);
>GtkWidget* gtk_vseparator_new (void);
># 136 "/usr/X11R6/include/gtk12/gtk/gtk.h" 2
># 23 "gtkcauldron.c" 2
>
># 1 "/usr/include/time.h" 1 3 4
># 67 "/usr/include/time.h" 3 4
>typedef __clock_t clock_t;
>
>
>
>
>typedef __time_t time_t;
>
>
>
>
>typedef __size_t size_t;
># 86 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
>
>
>
>
>typedef __timer_t timer_t;
>
>
>
># 1 "/usr/include/sys/timespec.h" 1 3 4
># 50 "/usr/include/sys/timespec.h" 3 4
>struct timespec {
>        time_t tv_sec;
>        long tv_nsec;
>};
># 96 "/usr/include/time.h" 2 3 4
>
>
>struct tm {
>        int tm_sec;
>        int tm_min;
>        int tm_hour;
>        int tm_mday;
>        int tm_mon;
>        int tm_year;
>        int tm_wday;
>        int tm_yday;
>        int tm_isdst;
>        long tm_gmtoff;
>        char *tm_zone;
>};
>
>
>extern char *tzname[];
>
>
>
>char *asctime(const struct tm *);
>clock_t clock(void);
>char *ctime(const time_t *);
>double difftime(time_t, time_t);
>struct tm *gmtime(const time_t *);
>struct tm *localtime(const time_t *);
>time_t mktime(struct tm *);
>size_t strftime(char * , size_t, const char * ,
>    const struct tm * );
>time_t time(time_t *);
>
>
>void tzset(void);
>
>
>
>int clock_getres(clockid_t, struct timespec *);
>int clock_gettime(clockid_t, struct timespec *);
>int clock_settime(clockid_t, const struct timespec *);
>int nanosleep(const struct timespec *, struct timespec *);
>
>
>
>char *asctime_r(const struct tm *, char *);
>char *ctime_r(const time_t *, char *);
>struct tm *gmtime_r(const time_t *, struct tm *);
>struct tm *localtime_r(const time_t *, struct tm *);
>
>
>
>char *strptime(const char * , const char * ,
>    struct tm * );
>
>
>
>char *timezone(int, int);
>void tzsetwall(void);
>time_t timelocal(struct tm * const);
>time_t timegm(struct tm * const);
>
>
># 25 "gtkcauldron.c" 2
># 1 "../libgnomeui/gnome-preferences.h" 1
># 11 "../libgnomeui/gnome-preferences.h"
># 1 "../libgnome/gnome-defs.h" 1
># 12 "../libgnomeui/gnome-preferences.h" 2
>
>
># 1 "../libgnomeui/gnome-mdi.h" 1
># 30 "../libgnomeui/gnome-mdi.h"
># 1 "../libgnomeui/gnome-app.h" 1
># 20 "../libgnomeui/gnome-app.h"
># 1 "../libgnome/gnome-defs.h" 1
># 21 "../libgnomeui/gnome-app.h" 2
>
># 1 "../libgnomeui/gnome-dock.h" 1
># 28 "../libgnomeui/gnome-dock.h"
># 1 "../libgnome/gnome-defs.h" 1
># 29 "../libgnomeui/gnome-dock.h" 2
>
>
>
>
>
>
>
>
>
>typedef enum
>{
>  GNOME_DOCK_TOP,
>  GNOME_DOCK_RIGHT,
>  GNOME_DOCK_BOTTOM,
>  GNOME_DOCK_LEFT,
>  GNOME_DOCK_FLOATING
>} GnomeDockPlacement;
>
>typedef struct _GnomeDock GnomeDock;
>typedef struct _GnomeDockClass GnomeDockClass;
>
># 1 "../libgnomeui/gnome-dock-band.h" 1
># 28 "../libgnomeui/gnome-dock-band.h"
># 1 "../libgnome/gnome-defs.h" 1
># 29 "../libgnomeui/gnome-dock-band.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct _GnomeDockBand GnomeDockBand;
>typedef struct _GnomeDockBandClass GnomeDockBandClass;
>typedef struct _GnomeDockBandChild GnomeDockBandChild;
>
># 1 "../libgnomeui/gnome-dock.h" 1
># 43 "../libgnomeui/gnome-dock-band.h" 2
># 1 "../libgnomeui/gnome-dock-item.h" 1
># 31 "../libgnomeui/gnome-dock-item.h"
># 1 "../libgnome/gnome-defs.h" 1
># 32 "../libgnomeui/gnome-dock-item.h" 2
>
>
>
>
>
>
>
>
>
>typedef enum
>{
>  GNOME_DOCK_ITEM_BEH_NORMAL = 0,
>  GNOME_DOCK_ITEM_BEH_EXCLUSIVE = 1 << 0,
>  GNOME_DOCK_ITEM_BEH_NEVER_FLOATING = 1 << 1,
>  GNOME_DOCK_ITEM_BEH_NEVER_VERTICAL = 1 << 2,
>  GNOME_DOCK_ITEM_BEH_NEVER_HORIZONTAL = 1 << 3,
>  GNOME_DOCK_ITEM_BEH_LOCKED = 1 << 4
>} GnomeDockItemBehavior;
>
>
>
>
>
>
>
>typedef struct _GnomeDockItem GnomeDockItem;
>typedef struct _GnomeDockItemClass GnomeDockItemClass;
>
>struct _GnomeDockItem
>{
>  GtkBin bin;
>
>  gchar *name;
>
>  GdkWindow *bin_window;
>  GdkWindow *float_window;
>  GtkShadowType shadow_type;
>
>  GtkOrientation orientation;
>  GnomeDockItemBehavior behavior;
>
>  guint float_window_mapped : 1;
>  guint is_floating : 1;
>  guint in_drag : 1;
>
>
>  gint dragoff_x, dragoff_y;
>
>
>  gint float_x, float_y;
>
>
>  guint grab_on_map_event;
>};
>
>struct _GnomeDockItemClass
>{
>  GtkBinClass parent_class;
>
>  void (* dock_drag_begin) (GnomeDockItem *item);
>  void (* dock_drag_motion) (GnomeDockItem *item, gint x, gint y);
>  void (* dock_drag_end) (GnomeDockItem *item);
>  void (* dock_detach) (GnomeDockItem *item);
>};
>
>
>guint gnome_dock_item_get_type (void);
>GtkWidget *gnome_dock_item_new (const gchar *name,
>                                                GnomeDockItemBehavior behavior);
>void gnome_dock_item_construct (GnomeDockItem *new_dock_item,
>                                                const gchar *name,
>                                                GnomeDockItemBehavior behavior);
>
>GtkWidget *gnome_dock_item_get_child (GnomeDockItem *dock_item);
>
>char *gnome_dock_item_get_name (GnomeDockItem *dock_item);
>
>void gnome_dock_item_set_shadow_type (GnomeDockItem *dock_item,
>                                                GtkShadowType type);
>
>GtkShadowType gnome_dock_item_get_shadow_type (GnomeDockItem *dock_item);
>
>gboolean gnome_dock_item_set_orientation (GnomeDockItem *dock_item,
>                                                GtkOrientation orientation);
>
>GtkOrientation gnome_dock_item_get_orientation (GnomeDockItem *dock_item);
>
>GnomeDockItemBehavior
>               gnome_dock_item_get_behavior (GnomeDockItem *dock_item);
>
>
>gboolean gnome_dock_item_detach (GnomeDockItem *item,
>                                                gint x, gint y);
>
>void gnome_dock_item_attach (GnomeDockItem *item,
>                                                GtkWidget *parent,
>                                                gint x, gint y);
>
>void gnome_dock_item_grab_pointer (GnomeDockItem *item);
>
>void gnome_dock_item_drag_floating (GnomeDockItem *item,
>                                                gint x, gint y);
>
>void gnome_dock_item_handle_size_request
>                                               (GnomeDockItem *item,
>                                                GtkRequisition *requisition);
>
>void gnome_dock_item_get_floating_position
>                                               (GnomeDockItem *item,
>                                                gint *x, gint *y);
>
>
># 44 "../libgnomeui/gnome-dock-band.h" 2
># 1 "../libgnomeui/gnome-dock-layout.h" 1
># 28 "../libgnomeui/gnome-dock-layout.h"
># 1 "../libgnome/gnome-defs.h" 1
># 29 "../libgnomeui/gnome-dock-layout.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct _GnomeDockLayoutItem GnomeDockLayoutItem;
>typedef struct _GnomeDockLayoutClass GnomeDockLayoutClass;
>typedef struct _GnomeDockLayout GnomeDockLayout;
>
>
>
>
>struct _GnomeDockLayoutItem
>{
>  GnomeDockItem *item;
>
>  GnomeDockPlacement placement;
>
>  union
>  {
>    struct
>    {
>      gint x;
>      gint y;
>      GtkOrientation orientation;
>    } floating;
>
>    struct
>    {
>      gint band_num;
>      gint band_position;
>      gint offset;
>    } docked;
>
>  } position;
>};
>
>struct _GnomeDockLayout
>{
>  GtkObject object;
>
>  GList *items;
>};
>
>struct _GnomeDockLayoutClass
>{
>  GtkObjectClass parent_class;
>};
>
>
>
>GnomeDockLayout *gnome_dock_layout_new (void);
>guint gnome_dock_layout_get_type (void);
>
>gboolean gnome_dock_layout_add_item (GnomeDockLayout *layout,
>                                                 GnomeDockItem *item,
>                                                 GnomeDockPlacement placement,
>                                                 gint band_num,
>                                                 gint band_position,
>                                                 gint offset);
>
>gboolean gnome_dock_layout_add_floating_item
>                                                (GnomeDockLayout *layout,
>                                                 GnomeDockItem *item,
>                                                 gint x, gint y,
>                                                 GtkOrientation orientation);
>
>GnomeDockLayoutItem *gnome_dock_layout_get_item (GnomeDockLayout *layout,
>                                                 GnomeDockItem *item);
>GnomeDockLayoutItem *gnome_dock_layout_get_item_by_name
>                                                (GnomeDockLayout *layout,
>                                                 const gchar *name);
>
>gboolean gnome_dock_layout_remove_item
>                                                (GnomeDockLayout *layout,
>                                                 GnomeDockItem *item);
>gboolean gnome_dock_layout_remove_item_by_name
>                                                (GnomeDockLayout *layout,
>                                                 const gchar *name);
>
>gchar *gnome_dock_layout_create_string
>                                                (GnomeDockLayout *layout);
>gboolean gnome_dock_layout_parse_string
>                                                (GnomeDockLayout *layout,
>                                                 const gchar *string);
>
>gboolean gnome_dock_layout_add_to_dock
>                                                (GnomeDockLayout *layout,
>                                                 GnomeDock *dock);
>
>
># 45 "../libgnomeui/gnome-dock-band.h" 2
>
>struct _GnomeDockBand
>{
>  GtkContainer container;
>
>  GtkOrientation orientation;
>
>  GList *children;
>  guint num_children;
>
>  GList *floating_child;
>
>  gboolean doing_drag;
>
>  guint max_space_requisition;
>  guint tot_offsets;
>
>
>
>
>
>
>  GtkAllocation drag_allocation;
>
>  guint new_for_drag : 1;
>};
>
>struct _GnomeDockBandClass
>{
>  GtkContainerClass parent_class;
>};
>
>struct _GnomeDockBandChild
>{
>  GtkWidget *widget;
>
>
>  guint offset;
>
>
>  guint real_offset;
>
>  guint drag_offset;
>
>  GtkAllocation drag_allocation;
>
>  guint prev_space, foll_space;
>  guint drag_prev_space, drag_foll_space;
>
>  guint max_space_requisition;
>};
>
>GtkWidget *gnome_dock_band_new (void);
>guint gnome_dock_band_get_type (void);
>
>void gnome_dock_band_set_orientation (GnomeDockBand *band,
>                                                 GtkOrientation orientation);
>GtkOrientation gnome_dock_band_get_orientation (GnomeDockBand *band);
>
>gboolean gnome_dock_band_insert (GnomeDockBand *band,
>                                                 GtkWidget *child,
>                                                 guint offset,
>                                                 gint position);
>gboolean gnome_dock_band_prepend (GnomeDockBand *band,
>                                                 GtkWidget *child,
>                                                 guint offset);
>gboolean gnome_dock_band_append (GnomeDockBand *band,
>                                                 GtkWidget *child,
>                                                 guint offset);
>
>void gnome_dock_band_set_child_offset (GnomeDockBand *band,
>                                                 GtkWidget *child,
>                                                 guint offset);
>guint gnome_dock_band_get_child_offset (GnomeDockBand *band,
>                                                 GtkWidget *child);
>void gnome_dock_band_move_child (GnomeDockBand *band,
>                                                 GList *old_child,
>                                                 guint new_num);
>
>guint gnome_dock_band_get_num_children (GnomeDockBand *band);
>
>void gnome_dock_band_drag_begin (GnomeDockBand *band,
>                                                 GnomeDockItem *item);
>gboolean gnome_dock_band_drag_to (GnomeDockBand *band,
>                                                 GnomeDockItem *item,
>                                                 gint x, gint y);
>void gnome_dock_band_drag_end (GnomeDockBand *band,
>                                                 GnomeDockItem *item);
>
>GnomeDockItem *gnome_dock_band_get_item_by_name (GnomeDockBand *band,
>                                                 const char *name,
>                                                 guint *position_return,
>                                                 guint *offset_return);
>
>void gnome_dock_band_layout_add (GnomeDockBand *band,
>                                                 GnomeDockLayout *layout,
>                                                 GnomeDockPlacement placement,
>                                                 guint band_num);
>
># 51 "../libgnomeui/gnome-dock.h" 2
>
>
>struct _GnomeDock
>{
>  GtkContainer container;
>
>  GtkWidget *client_area;
>
>
>  GList *top_bands;
>  GList *bottom_bands;
>  GList *right_bands;
>  GList *left_bands;
>
>
>  GList *floating_children;
>
>
>  GtkAllocation client_rect;
>
>  gboolean floating_items_allowed : 1;
>};
>
>struct _GnomeDockClass
>{
>  GtkContainerClass parent_class;
>
>  void (* layout_changed) (GnomeDock *dock);
>};
>
>GtkWidget *gnome_dock_new (void);
>guint gnome_dock_get_type (void);
>
>void gnome_dock_allow_floating_items
>                                            (GnomeDock *dock,
>                                             gboolean enable);
>
>void gnome_dock_add_item (GnomeDock *dock,
>                                             GnomeDockItem *item,
>                                             GnomeDockPlacement placement,
>                                             guint band_num,
>                                             gint position,
>                                             guint offset,
>                                             gboolean in_new_band);
>
>void gnome_dock_add_floating_item (GnomeDock *dock,
>                                             GnomeDockItem *widget,
>                                             gint x, gint y,
>                                             GtkOrientation orientation);
>
>void gnome_dock_set_client_area (GnomeDock *dock,
>                                             GtkWidget *widget);
>
>GtkWidget *gnome_dock_get_client_area (GnomeDock *dock);
>
>GnomeDockItem *gnome_dock_get_item_by_name (GnomeDock *dock,
>                                             const gchar *name,
>                                             GnomeDockPlacement *placement_return,
>                                             guint *num_band_return,
>                                             guint *band_position_return,
>                                             guint *offset_return);
>
>GnomeDockLayout *gnome_dock_get_layout (GnomeDock *dock);
>
>gboolean gnome_dock_add_from_layout (GnomeDock *dock,
>                                             GnomeDockLayout *layout);
>
>
># 23 "../libgnomeui/gnome-app.h" 2
>
>
># 37 "../libgnomeui/gnome-app.h"
>typedef struct _GnomeApp GnomeApp;
>typedef struct _GnomeAppClass GnomeAppClass;
>
>struct _GnomeApp {
>        GtkWindow parent_object;
>
>
>        gchar *name;
>
>
>        gchar *prefix;
>
>
>        GtkWidget *dock;
>
>
>        GtkWidget *statusbar;
>
>
>        GtkWidget *vbox;
>
>
>
>        GtkWidget *menubar;
>
>
>        GtkWidget *contents;
>
>
>        GnomeDockLayout *layout;
>
>
>        GtkAccelGroup *accel_group;
>
>
>
>        gboolean enable_layout_config : 1;
>};
>
>struct _GnomeAppClass {
>        GtkWindowClass parent_class;
>};
>
>
>
>GtkType gnome_app_get_type (void);
>
>
>
>
>
>GtkWidget *gnome_app_new (const gchar *appname, const gchar *title);
>
>
>void gnome_app_construct (GnomeApp *app, const gchar *appname, const gchar *title);
>
>
>void gnome_app_set_menus (GnomeApp *app, GtkMenuBar *menubar);
>
>
>void gnome_app_set_toolbar (GnomeApp *app, GtkToolbar *toolbar);
>
>
>void gnome_app_set_statusbar (GnomeApp *app, GtkWidget *statusbar);
>
>
>
>void gnome_app_set_statusbar_custom (GnomeApp *app,
>                                     GtkWidget *container,
>                                     GtkWidget *statusbar);
>
>
>void gnome_app_set_contents (GnomeApp *app, GtkWidget *contents);
>
>void gnome_app_add_toolbar (GnomeApp *app,
>                            GtkToolbar *toolbar,
>                            const gchar *name,
>                            GnomeDockItemBehavior behavior,
>                            GnomeDockPlacement placement,
>                            gint band_num,
>                            gint band_position,
>                            gint offset);
>
>void gnome_app_add_docked (GnomeApp *app,
>                           GtkWidget *widget,
>                           const gchar *name,
>                           GnomeDockItemBehavior behavior,
>                           GnomeDockPlacement placement,
>                           gint band_num,
>                           gint band_position,
>                           gint offset);
>
>void gnome_app_add_dock_item (GnomeApp *app,
>                              GnomeDockItem *item,
>                              GnomeDockPlacement placement,
>                              gint band_num,
>                              gint band_position,
>                              gint offset);
>
>void gnome_app_enable_layout_config (GnomeApp *app, gboolean enable);
>
>GnomeDock *gnome_app_get_dock (GnomeApp *app);
>
>GnomeDockItem *gnome_app_get_dock_item_by_name (GnomeApp *app,
>                                                const gchar *name);
>
>
># 31 "../libgnomeui/gnome-mdi.h" 2
># 1 "../libgnomeui/gnome-app-helper.h" 1
># 20 "../libgnomeui/gnome-app-helper.h"
># 1 "../libgnome/gnome-defs.h" 1
># 21 "../libgnomeui/gnome-app-helper.h" 2
># 1 "../libgnomeui/gnome-appbar.h" 1
># 30 "../libgnomeui/gnome-appbar.h"
># 1 "../libgnome/gnome-defs.h" 1
># 31 "../libgnomeui/gnome-appbar.h" 2
># 1 "../libgnomeui/gnome-types.h" 1
>
>
>
>
>
>
># 1 "../libgnome/gnome-defs.h" 1
># 8 "../libgnomeui/gnome-types.h" 2
>
>
>
>
>
>typedef void (* GnomeStringCallback)(gchar * string, gpointer data);
>
>
>
>typedef void (* GnomeReplyCallback)(gint reply, gpointer data);
>
>
>typedef enum {
>  GNOME_PREFERENCES_NEVER,
>  GNOME_PREFERENCES_USER,
>  GNOME_PREFERENCES_ALWAYS
>} GnomePreferencesType;
>
>
># 32 "../libgnomeui/gnome-appbar.h" 2
>
>
># 45 "../libgnomeui/gnome-appbar.h"
>typedef struct _GnomeAppBar GnomeAppBar;
>typedef struct _GnomeAppBarClass GnomeAppBarClass;
>typedef struct _GnomeAppBarMsg GnomeAppBarMsg;
>
>struct _GnomeAppBar
>{
>  GtkHBox parent_widget;
>
>
>
>
>
>  GtkWidget * progress;
>  GtkWidget * status;
>  guint interactive : 1;
>
>  gint editable_start;
>
>  gchar * prompt;
>
>
>
>
>
>
>  GSList * status_stack;
>  gchar * default_status;
>};
>
>struct _GnomeAppBarClass
>{
>  GtkHBoxClass parent_class;
>
>
>  void (* user_response) (GnomeAppBar * ab);
>
>  void (* clear_prompt) (GnomeAppBar * ab);
>};
>
>
>
>guint gnome_appbar_get_type (void);
>
>GtkWidget* gnome_appbar_new (gboolean has_progress,
>                                         gboolean has_status,
>                                         GnomePreferencesType interactivity);
>
>
>
>void gnome_appbar_set_status (GnomeAppBar * appbar,
>                                          const gchar * status);
>
>
>void gnome_appbar_set_default (GnomeAppBar * appbar,
>                                          const gchar * default_status);
>
>void gnome_appbar_push (GnomeAppBar * appbar,
>                                          const gchar * status);
>
>void gnome_appbar_pop (GnomeAppBar * appbar);
>
>
>void gnome_appbar_clear_stack (GnomeAppBar * appbar);
>
>
>
>
>void gnome_appbar_set_progress (GnomeAppBar *appbar,
>                                           gfloat percentage);
>
>GtkProgress* gnome_appbar_get_progress (GnomeAppBar * appbar);
>
>
>
>void gnome_appbar_refresh (GnomeAppBar * appbar);
>
>
>
>void gnome_appbar_set_prompt (GnomeAppBar * appbar,
>                                             const gchar * prompt,
>                                             gboolean modal);
>
>void gnome_appbar_clear_prompt (GnomeAppBar * appbar);
>
>
>gchar * gnome_appbar_get_response (GnomeAppBar * appbar);
>
>
>
>void gnome_appbar_construct(GnomeAppBar * ab,
>                                  gboolean has_progress,
>                                  gboolean has_status,
>                                  GnomePreferencesType interactivity);
>
>
># 22 "../libgnomeui/gnome-app-helper.h" 2
>
>
># 33 "../libgnomeui/gnome-app-helper.h"
>typedef enum {
>        GNOME_APP_UI_ENDOFINFO,
>
>        GNOME_APP_UI_ITEM,
>
>        GNOME_APP_UI_TOGGLEITEM,
>        GNOME_APP_UI_RADIOITEMS,
>        GNOME_APP_UI_SUBTREE,
>
>        GNOME_APP_UI_SEPARATOR,
>
>        GNOME_APP_UI_HELP,
>
>        GNOME_APP_UI_BUILDER_DATA,
>
>
>        GNOME_APP_UI_ITEM_CONFIGURABLE,
>
>
>
>
>
>        GNOME_APP_UI_SUBTREE_STOCK
>
>
>
>
>} GnomeUIInfoType;
>
>
>
>
>typedef enum {
>
>        GNOME_APP_CONFIGURABLE_ITEM_NEW,
>        GNOME_APP_CONFIGURABLE_ITEM_OPEN,
>        GNOME_APP_CONFIGURABLE_ITEM_SAVE,
>        GNOME_APP_CONFIGURABLE_ITEM_SAVE_AS,
>        GNOME_APP_CONFIGURABLE_ITEM_REVERT,
>        GNOME_APP_CONFIGURABLE_ITEM_PRINT,
>        GNOME_APP_CONFIGURABLE_ITEM_PRINT_SETUP,
>        GNOME_APP_CONFIGURABLE_ITEM_CLOSE,
>        GNOME_APP_CONFIGURABLE_ITEM_EXIT,
>        GNOME_APP_CONFIGURABLE_ITEM_CUT,
>
>        GNOME_APP_CONFIGURABLE_ITEM_COPY,
>        GNOME_APP_CONFIGURABLE_ITEM_PASTE,
>        GNOME_APP_CONFIGURABLE_ITEM_CLEAR,
>        GNOME_APP_CONFIGURABLE_ITEM_UNDO,
>        GNOME_APP_CONFIGURABLE_ITEM_REDO,
>        GNOME_APP_CONFIGURABLE_ITEM_FIND,
>        GNOME_APP_CONFIGURABLE_ITEM_FIND_AGAIN,
>        GNOME_APP_CONFIGURABLE_ITEM_REPLACE,
>        GNOME_APP_CONFIGURABLE_ITEM_PROPERTIES,
>        GNOME_APP_CONFIGURABLE_ITEM_PREFERENCES,
>
>        GNOME_APP_CONFIGURABLE_ITEM_ABOUT,
>        GNOME_APP_CONFIGURABLE_ITEM_SELECT_ALL,
>        GNOME_APP_CONFIGURABLE_ITEM_NEW_WINDOW,
>        GNOME_APP_CONFIGURABLE_ITEM_CLOSE_WINDOW,
>        GNOME_APP_CONFIGURABLE_ITEM_NEW_GAME,
>        GNOME_APP_CONFIGURABLE_ITEM_PAUSE_GAME,
>        GNOME_APP_CONFIGURABLE_ITEM_RESTART_GAME,
>        GNOME_APP_CONFIGURABLE_ITEM_UNDO_MOVE,
>        GNOME_APP_CONFIGURABLE_ITEM_REDO_MOVE,
>        GNOME_APP_CONFIGURABLE_ITEM_HINT,
>
>        GNOME_APP_CONFIGURABLE_ITEM_SCORES,
>        GNOME_APP_CONFIGURABLE_ITEM_END_GAME
>} GnomeUIInfoConfigurableTypes;
>
>
>
>typedef enum {
>        GNOME_APP_PIXMAP_NONE,
>        GNOME_APP_PIXMAP_STOCK,
>        GNOME_APP_PIXMAP_DATA,
>        GNOME_APP_PIXMAP_FILENAME
>
>} GnomeUIPixmapType;
>
>
>
>
>
>typedef struct {
>        GnomeUIInfoType type;
>        gchar *label;
>        gchar *hint;
>
>        gpointer moreinfo;
># 138 "../libgnomeui/gnome-app-helper.h"
>        gpointer user_data;
>        gpointer unused_data;
>
>        GnomeUIPixmapType pixmap_type;
>        gconstpointer pixmap_info;
># 153 "../libgnomeui/gnome-app-helper.h"
>        guint accelerator_key;
>        GdkModifierType ac_mods;
>
>
>        GtkWidget *widget;
>
>
>} GnomeUIInfo;
># 472 "../libgnomeui/gnome-app-helper.h"
>gchar * gnome_app_helper_gettext (const gchar *string);
># 527 "../libgnomeui/gnome-app-helper.h"
>typedef struct _GnomeUIBuilderData GnomeUIBuilderData;
>
>typedef void (* GnomeUISignalConnectFunc) (GnomeUIInfo *uiinfo,
>                                           gchar *signal_name,
>                                           GnomeUIBuilderData *uibdata);
>
>struct _GnomeUIBuilderData {
>        GnomeUISignalConnectFunc connect_func;
>        gpointer data;
>        gboolean is_interp;
>        GtkCallbackMarshal relay_func;
>        GtkDestroyNotify destroy_func;
>};
>
>
>
>
>void gnome_accelerators_sync (void);
># 555 "../libgnomeui/gnome-app-helper.h"
>void gnome_app_fill_menu (GtkMenuShell *menu_shell,
>                          GnomeUIInfo *uiinfo,
>                          GtkAccelGroup *accel_group,
>                          gboolean uline_accels,
>                          gint pos);
>
>
>
>
>void gnome_app_fill_menu_with_data (GtkMenuShell *menu_shell,
>                                    GnomeUIInfo *uiinfo,
>                                    GtkAccelGroup *accel_group,
>                                    gboolean uline_accels,
>                                    gint pos,
>                                    gpointer user_data);
># 580 "../libgnomeui/gnome-app-helper.h"
>void gnome_app_fill_menu_custom (GtkMenuShell *menu_shell,
>                                 GnomeUIInfo *uiinfo,
>                                 GnomeUIBuilderData *uibdata,
>                                 GtkAccelGroup *accel_group,
>                                 gboolean uline_accels,
>                                 gint pos);
># 594 "../libgnomeui/gnome-app-helper.h"
>void gnome_app_ui_configure_configurable (GnomeUIInfo* uiinfo);
>
>
>
>void gnome_app_create_menus (GnomeApp *app, GnomeUIInfo *uiinfo);
>
>
>
>
>void gnome_app_create_menus_interp (GnomeApp *app, GnomeUIInfo *uiinfo,
>                                    GtkCallbackMarshal relay_func, gpointer data,
>                                    GtkDestroyNotify destroy_func);
>
>
>
>
>void gnome_app_create_menus_with_data (GnomeApp *app, GnomeUIInfo *uiinfo, gpointer user_data);
>
>
>
>
>void gnome_app_create_menus_custom (GnomeApp *app, GnomeUIInfo *uiinfo, GnomeUIBuilderData *uibdata);
>
>
>
>
>void gnome_app_fill_toolbar (GtkToolbar *toolbar, GnomeUIInfo *uiinfo, GtkAccelGroup *accel_group);
>
>
>
>
>void gnome_app_fill_toolbar_with_data (GtkToolbar *toolbar, GnomeUIInfo *uiinfo,
>                                       GtkAccelGroup *accel_group, gpointer user_data);
>
>
>
>
>
>void gnome_app_fill_toolbar_custom (GtkToolbar *toolbar, GnomeUIInfo *uiinfo, GnomeUIBuilderData *uibdata,
>                                    GtkAccelGroup *accel_group);
>
>
>void gnome_app_create_toolbar (GnomeApp *app, GnomeUIInfo *uiinfo);
>
>
>
>
>void gnome_app_create_toolbar_interp (GnomeApp *app, GnomeUIInfo *uiinfo,
>                                      GtkCallbackMarshal relay_func, gpointer data,
>                                      GtkDestroyNotify destroy_func);
>
>
>
>
>void gnome_app_create_toolbar_with_data (GnomeApp *app, GnomeUIInfo *uiinfo, gpointer user_data);
>
>
>
>
>void gnome_app_create_toolbar_custom (GnomeApp *app, GnomeUIInfo *uiinfo, GnomeUIBuilderData *uibdata);
># 665 "../libgnomeui/gnome-app-helper.h"
>GtkWidget *gnome_app_find_menu_pos (GtkWidget *parent, const gchar *path, gint *pos);
>
>
>
>
>void gnome_app_remove_menus (GnomeApp *app, const gchar *path, gint items);
>
>
>
>
>
>
>void gnome_app_remove_menu_range (GnomeApp *app, const gchar *path, gint start, gint items);
>
>
>
>void gnome_app_insert_menus_custom (GnomeApp *app, const gchar *path, GnomeUIInfo *menuinfo, GnomeUIBuilderData *uibdata);
>
>
>void gnome_app_insert_menus (GnomeApp *app, const gchar *path, GnomeUIInfo *menuinfo);
>
>
>void gnome_app_insert_menus_with_data (GnomeApp *app, const gchar *path, GnomeUIInfo *menuinfo, gpointer data);
>
>
>void gnome_app_insert_menus_interp (GnomeApp *app, const gchar *path, GnomeUIInfo *menuinfo,
>                                    GtkCallbackMarshal relay_func, gpointer data,
>                                    GtkDestroyNotify destroy_func);
>
>
>
>
>
>void gnome_app_install_appbar_menu_hints (GnomeAppBar* appbar,
>                                             GnomeUIInfo* uiinfo);
>
>void gnome_app_install_statusbar_menu_hints (GtkStatusbar* bar,
>                                             GnomeUIInfo* uiinfo);
>
>
>void gnome_app_install_menu_hints (GnomeApp *app,
>                                             GnomeUIInfo *uinfo);
>
>
># 32 "../libgnomeui/gnome-mdi.h" 2
># 1 "../libgnomeui/gnome-mdi-child.h" 1
># 33 "../libgnomeui/gnome-mdi-child.h"
>
>
>
>
>
>
>
>
>typedef struct _GnomeMDIChild GnomeMDIChild;
>typedef struct _GnomeMDIChildClass GnomeMDIChildClass;
># 51 "../libgnomeui/gnome-mdi-child.h"
>struct _GnomeMDIChild
>{
>        GtkObject object;
>
>        GtkObject *parent;
>
>        gchar *name;
>
>        GList *views;
>
>        GnomeUIInfo *menu_template;
>};
>
>typedef GtkWidget *(*GnomeMDIChildViewCreator) (GnomeMDIChild *, gpointer);
>typedef GList *(*GnomeMDIChildMenuCreator) (GnomeMDIChild *, GtkWidget *, gpointer);
>typedef gchar *(*GnomeMDIChildConfigFunc) (GnomeMDIChild *, gpointer);
>typedef GtkWidget *(*GnomeMDIChildLabelFunc) (GnomeMDIChild *, GtkWidget *, gpointer);
>
>
>
>
>
>
>
>struct _GnomeMDIChildClass
>{
>        GtkObjectClass parent_class;
>
>
>        GnomeMDIChildViewCreator create_view;
>        GnomeMDIChildMenuCreator create_menus;
>        GnomeMDIChildConfigFunc get_config_string;
>        GnomeMDIChildLabelFunc set_label;
>};
>
>guint gnome_mdi_child_get_type (void);
>
>GtkWidget *gnome_mdi_child_add_view (GnomeMDIChild *mdi_child);
>
>void gnome_mdi_child_remove_view (GnomeMDIChild *mdi_child, GtkWidget *view);
>
>void gnome_mdi_child_set_name (GnomeMDIChild *mdi_child, const gchar *name);
>
>void gnome_mdi_child_set_menu_template(GnomeMDIChild *mdi_child, GnomeUIInfo *menu_tmpl);
>
>
># 33 "../libgnomeui/gnome-mdi.h" 2
>
>
>
>
>
>
>
>
>
>typedef struct _GnomeMDI GnomeMDI;
>typedef struct _GnomeMDIClass GnomeMDIClass;
>
>typedef enum {
>        GNOME_MDI_NOTEBOOK,
>        GNOME_MDI_TOPLEVEL,
>        GNOME_MDI_MODAL,
>        GNOME_MDI_DEFAULT_MODE = 42
>} GnomeMDIMode;
>
>struct _GnomeMDI {
>        GtkObject object;
>
>        GnomeMDIMode mode;
>
>        GtkPositionType tab_pos;
>
>        guint signal_id;
>        gint in_drag : 1;
>
>        gchar *appname, *title;
>
>        GnomeUIInfo *menu_template;
>        GnomeUIInfo *toolbar_template;
>
>
>        GnomeMDIChild *active_child;
>        GtkWidget *active_view;
>        GnomeApp *active_window;
>
>        GList *windows;
>        GList *children;
>
>        GSList *registered;
>
>
>
>        gchar *child_menu_path;
>        gchar *child_list_path;
>};
>
>struct _GnomeMDIClass {
>        GtkObjectClass parent_class;
>
>        gint (*add_child)(GnomeMDI *, GnomeMDIChild *);
>        gint (*remove_child)(GnomeMDI *, GnomeMDIChild *);
>        gint (*add_view)(GnomeMDI *, GtkWidget *);
>        gint (*remove_view)(GnomeMDI *, GtkWidget *);
>        void (*child_changed)(GnomeMDI *, GnomeMDIChild *);
>        void (*view_changed)(GnomeMDI *, GtkWidget *);
>        void (*app_created)(GnomeMDI *, GnomeApp *);
>};
># 127 "../libgnomeui/gnome-mdi.h"
>guint gnome_mdi_get_type (void);
>
>GtkObject *gnome_mdi_new (const gchar *appname, const gchar *title);
>
>void gnome_mdi_set_mode (GnomeMDI *mdi, GnomeMDIMode mode);
>
>
>void gnome_mdi_set_menubar_template(GnomeMDI *mdi, GnomeUIInfo *menu_tmpl);
>void gnome_mdi_set_toolbar_template(GnomeMDI *mdi, GnomeUIInfo *tbar_tmpl);
>void gnome_mdi_set_child_menu_path (GnomeMDI *mdi, const gchar *path);
>void gnome_mdi_set_child_list_path (GnomeMDI *mdi, const gchar *path);
>
>
>gint gnome_mdi_add_view (GnomeMDI *mdi, GnomeMDIChild *child);
>gint gnome_mdi_add_toplevel_view (GnomeMDI *mdi, GnomeMDIChild *child);
>gint gnome_mdi_remove_view (GnomeMDI *mdi, GtkWidget *view, gint force);
>
>GtkWidget *gnome_mdi_get_active_view (GnomeMDI *mdi);
>void gnome_mdi_set_active_view (GnomeMDI *mdi, GtkWidget *view);
>
>
>gint gnome_mdi_add_child (GnomeMDI *mdi, GnomeMDIChild *child);
>gint gnome_mdi_remove_child (GnomeMDI *mdi, GnomeMDIChild *child, gint force);
>gint gnome_mdi_remove_all (GnomeMDI *mdi, gint force);
>
>void gnome_mdi_open_toplevel (GnomeMDI *mdi);
>
>void gnome_mdi_update_child (GnomeMDI *mdi, GnomeMDIChild *child);
>
>GnomeMDIChild *gnome_mdi_get_active_child (GnomeMDI *mdi);
>GnomeMDIChild *gnome_mdi_find_child (GnomeMDI *mdi, const gchar *name);
>
>GnomeApp *gnome_mdi_get_active_window (GnomeMDI *mdi);
># 170 "../libgnomeui/gnome-mdi.h"
>void gnome_mdi_register (GnomeMDI *mdi, GtkObject *object);
>void gnome_mdi_unregister (GnomeMDI *mdi, GtkObject *object);
>
>
>
>
>
>
>GnomeApp *gnome_mdi_get_app_from_view (GtkWidget *view);
>GnomeMDIChild *gnome_mdi_get_child_from_view (GtkWidget *view);
>GtkWidget *gnome_mdi_get_view_from_window (GnomeMDI *mdi, GnomeApp *app);
># 189 "../libgnomeui/gnome-mdi.h"
>GnomeUIInfo *gnome_mdi_get_menubar_info (GnomeApp *app);
>GnomeUIInfo *gnome_mdi_get_toolbar_info (GnomeApp *app);
>GnomeUIInfo *gnome_mdi_get_child_menu_info (GnomeApp *app);
>
>
># 15 "../libgnomeui/gnome-preferences.h" 2
>
>
>
>
>
>typedef struct _GnomePreferences GnomePreferences;
>
>struct _GnomePreferences {
>  GtkButtonBoxStyle dialog_buttons_style;
>  int property_box_buttons_ok : 1;
>  int property_box_buttons_apply : 1;
>  int property_box_buttons_close : 1;
>  int property_box_buttons_help : 1;
>  int statusbar_not_dialog : 1;
>  int statusbar_is_interactive : 1;
>  int statusbar_meter_on_right : 1;
>  int menubar_detachable : 1;
>  int menubar_relief : 1;
>  int toolbar_detachable : 1;
>  int toolbar_relief : 1;
>  int toolbar_relief_btn : 1;
>  int toolbar_lines : 1;
>  int toolbar_labels : 1;
>  int dialog_centered : 1;
>  int menus_have_tearoff : 1;
>  int menus_have_icons : 1;
>  int disable_imlib_cache : 1;
>  GtkWindowType dialog_type;
>  GtkWindowPosition dialog_position;
>  GnomeMDIMode mdi_mode;
>  GtkPositionType mdi_tab_pos;
>};
>
>
>void gnome_preferences_load(void);
>void gnome_preferences_save(void);
>
>void gnome_preferences_load_custom(GnomePreferences *settings);
>void gnome_preferences_save_custom(GnomePreferences *settings);
>
>
>GtkButtonBoxStyle gnome_preferences_get_button_layout (void);
>void gnome_preferences_set_button_layout (GtkButtonBoxStyle style);
>
>
>
>gboolean gnome_preferences_get_statusbar_dialog (void);
>void gnome_preferences_set_statusbar_dialog (gboolean statusbar);
>
>
>
>gboolean gnome_preferences_get_statusbar_interactive(void);
>void gnome_preferences_set_statusbar_interactive(gboolean b);
>
>
>gboolean gnome_preferences_get_statusbar_meter_on_right (void);
>void gnome_preferences_set_statusbar_meter_on_right (gboolean status_meter_on_right);
>
>
>
>gboolean gnome_preferences_get_menubar_detachable (void);
>void gnome_preferences_set_menubar_detachable (gboolean b);
>
>
>gboolean gnome_preferences_get_menubar_relief (void);
>void gnome_preferences_set_menubar_relief (gboolean b);
>
>
>gboolean gnome_preferences_get_toolbar_detachable (void);
>void gnome_preferences_set_toolbar_detachable (gboolean b);
>
>
>gboolean gnome_preferences_get_toolbar_relief (void);
>void gnome_preferences_set_toolbar_relief (gboolean b);
>
>
>gboolean gnome_preferences_get_toolbar_relief_btn (void);
>void gnome_preferences_set_toolbar_relief_btn (gboolean b);
>
>
>gboolean gnome_preferences_get_toolbar_lines (void);
>void gnome_preferences_set_toolbar_lines (gboolean b);
>
>
>gboolean gnome_preferences_get_toolbar_labels (void);
>void gnome_preferences_set_toolbar_labels (gboolean b);
>
>
>
>
>gboolean gnome_preferences_get_dialog_centered (void);
>void gnome_preferences_set_dialog_centered (gboolean b);
>
>
>GtkWindowType gnome_preferences_get_dialog_type (void);
>void gnome_preferences_set_dialog_type (GtkWindowType t);
>
>
>
>GtkWindowPosition gnome_preferences_get_dialog_position (void);
>void gnome_preferences_set_dialog_position (GtkWindowPosition p);
>
>
>GnomeMDIMode gnome_preferences_get_mdi_mode (void);
>void gnome_preferences_set_mdi_mode (GnomeMDIMode m);
>GtkPositionType gnome_preferences_get_mdi_tab_pos (void);
>void gnome_preferences_set_mdi_tab_pos (GtkPositionType p);
>
>
>int gnome_preferences_get_property_box_apply (void);
>void gnome_preferences_set_property_box_button_apply (int v);
>
>
>gboolean gnome_preferences_get_menus_have_tearoff (void);
>void gnome_preferences_set_menus_have_tearoff (gboolean b);
>
>
>int gnome_preferences_get_menus_have_icons (void);
>void gnome_preferences_set_menus_have_icons (int have_icons);
>
>
>int gnome_preferences_get_disable_imlib_cache (void);
>void gnome_preferences_set_disable_imlib_cache (int disable_imlib_cache);
>
>
># 26 "gtkcauldron.c" 2
># 1 "../libgnomeui/gnome-file-entry.h" 1
># 12 "../libgnomeui/gnome-file-entry.h"
># 1 "../libgnome/gnome-defs.h" 1
># 13 "../libgnomeui/gnome-file-entry.h" 2
># 1 "../libgnomeui/gnome-entry.h" 1
># 12 "../libgnomeui/gnome-entry.h"
># 1 "../libgnome/gnome-defs.h" 1
># 13 "../libgnomeui/gnome-entry.h" 2
>
>
>
># 25 "../libgnomeui/gnome-entry.h"
>typedef struct _GnomeEntry GnomeEntry;
>typedef struct _GnomeEntryClass GnomeEntryClass;
>
>struct _GnomeEntry {
>        GtkCombo combo;
>
>        gboolean changed;
>        gchar *history_id;
>        GList *items;
>        guint max_saved;
>};
>
>struct _GnomeEntryClass {
>        GtkComboClass parent_class;
>};
>
>
>guint gnome_entry_get_type (void);
>GtkWidget *gnome_entry_new (const gchar *history_id);
>
>GtkWidget *gnome_entry_gtk_entry (GnomeEntry *gentry);
>void gnome_entry_set_history_id (GnomeEntry *gentry, const gchar *history_id);
>void gnome_entry_set_max_saved (GnomeEntry *gentry, guint max_saved);
>
>void gnome_entry_prepend_history (GnomeEntry *gentry, gint save, const gchar *text);
>void gnome_entry_append_history (GnomeEntry *gentry, gint save, const gchar *text);
>void gnome_entry_load_history (GnomeEntry *gentry);
>void gnome_entry_save_history (GnomeEntry *gentry);
>
>
># 14 "../libgnomeui/gnome-file-entry.h" 2
>
>
>
># 26 "../libgnomeui/gnome-file-entry.h"
>typedef struct _GnomeFileEntry GnomeFileEntry;
>typedef struct _GnomeFileEntryClass GnomeFileEntryClass;
>
>struct _GnomeFileEntry {
>        GtkHBox hbox;
>
>        char *browse_dialog_title;
>        char *default_path;
>
>
>        GtkWidget *fsw;
>
>        gboolean is_modal;
>
>        gboolean directory_entry;
>
>        GtkWidget *gentry;
>};
>
>struct _GnomeFileEntryClass {
>        GtkHBoxClass parent_class;
>
>
>
>
>
>        void (* browse_clicked)(GnomeFileEntry *fentry);
>};
>
>
>guint gnome_file_entry_get_type (void);
>GtkWidget *gnome_file_entry_new (const char *history_id,
>                                         const char *browse_dialog_title);
>void gnome_file_entry_construct (GnomeFileEntry *fentry,
>                                        const char *history_id,
>                                        const char *browse_dialog_title);
>
>GtkWidget *gnome_file_entry_gnome_entry (GnomeFileEntry *fentry);
>GtkWidget *gnome_file_entry_gtk_entry (GnomeFileEntry *fentry);
>void gnome_file_entry_set_title (GnomeFileEntry *fentry,
>                                         const char *browse_dialog_title);
>
>
>void gnome_file_entry_set_default_path(GnomeFileEntry *fentry,
>                                             const char *path);
>
>
>void gnome_file_entry_set_directory(GnomeFileEntry *fentry,
>                                          gboolean directory_entry);
>
>
>
>
>
>char *gnome_file_entry_get_full_path(GnomeFileEntry *fentry,
>                                          gboolean file_must_exist);
>
>
>
>void gnome_file_entry_set_modal (GnomeFileEntry *fentry,
>                                         gboolean is_modal);
>
>
># 27 "gtkcauldron.c" 2
># 1 "../libgnomeui/gnome-dateedit.h" 1
>
>
>
>
># 1 "../libgnome/gnome-defs.h" 1
># 6 "../libgnomeui/gnome-dateedit.h" 2
>
>
>
>
>typedef enum {
>        GNOME_DATE_EDIT_SHOW_TIME = 1 << 0,
>        GNOME_DATE_EDIT_24_HR = 1 << 1,
>        GNOME_DATE_EDIT_WEEK_STARTS_ON_MONDAY = 1 << 2
>} GnomeDateEditFlags;
># 23 "../libgnomeui/gnome-dateedit.h"
>typedef struct {
>        GtkHBox hbox;
>
>        GtkWidget *date_entry;
>        GtkWidget *date_button;
>
>        GtkWidget *time_entry;
>        GtkWidget *time_popup;
>
>        GtkWidget *cal_label;
>        GtkWidget *cal_popup;
>        GtkWidget *calendar;
>
>        int lower_hour;
>        int upper_hour;
>
>        time_t initial_time;
>        int flags;
>} GnomeDateEdit;
>
>typedef struct {
>        GtkHBoxClass parent_class;
>        void (*date_changed) (GnomeDateEdit *gde);
>        void (*time_changed) (GnomeDateEdit *gde);
>} GnomeDateEditClass;
>
>guint gnome_date_edit_get_type (void);
>GtkWidget *gnome_date_edit_new (time_t the_time, int show_time, int use_24_format);
>GtkWidget *gnome_date_edit_new_flags (time_t the_time, GnomeDateEditFlags flags);
>
>void gnome_date_edit_set_time (GnomeDateEdit *gde, time_t the_time);
>void gnome_date_edit_set_popup_range (GnomeDateEdit *gde, int low_hour, int up_hour);
>time_t gnome_date_edit_get_date (GnomeDateEdit *gde);
>void gnome_date_edit_set_flags (GnomeDateEdit *gde, GnomeDateEditFlags flags);
>int gnome_date_edit_get_flags (GnomeDateEdit *gde);
>
>
>
># 28 "gtkcauldron.c" 2
># 1 "../libgnomeui/gnome-number-entry.h" 1
># 13 "../libgnomeui/gnome-number-entry.h"
># 1 "../libgnome/gnome-defs.h" 1
># 14 "../libgnomeui/gnome-number-entry.h" 2
>
>
>
>
># 27 "../libgnomeui/gnome-number-entry.h"
>typedef struct _GnomeNumberEntry GnomeNumberEntry;
>typedef struct _GnomeNumberEntryClass GnomeNumberEntryClass;
>
>struct _GnomeNumberEntry {
>        GtkHBox hbox;
>
>        gchar *calc_dialog_title;
>
>        GtkWidget *calc_dlg;
>
>        GtkWidget *gentry;
>};
>
>struct _GnomeNumberEntryClass {
>        GtkHBoxClass parent_class;
>};
>
>
>guint gnome_number_entry_get_type (void);
>GtkWidget *gnome_number_entry_new (const gchar *history_id,
>                                           const gchar *calc_dialog_title);
>
>GtkWidget *gnome_number_entry_gnome_entry (GnomeNumberEntry *nentry);
>GtkWidget *gnome_number_entry_gtk_entry (GnomeNumberEntry *nentry);
>void gnome_number_entry_set_title (GnomeNumberEntry *nentry,
>                                           const gchar *calc_dialog_title);
>
>gdouble gnome_number_entry_get_number (GnomeNumberEntry *nentry);
>
>
>
># 29 "gtkcauldron.c" 2
># 1 "../libgnomeui/gnome-stock.h" 1
># 24 "../libgnomeui/gnome-stock.h"
># 1 "../libgnome/gnome-defs.h" 1
># 25 "../libgnomeui/gnome-stock.h" 2
>
>
>
>
># 1 "../libgnomeui/gnome-pixmap.h" 1
>
>
>
>
>
>
># 1 "/usr/X11R6/include/gdk_imlib.h" 1
>
>
>
>
># 1 "/usr/X11R6/include/gdk_imlib_types.h" 1
>
>
>
>
>
>
>typedef struct _GdkImlibBorder GdkImlibBorder;
>typedef struct _GdkImlibColor GdkImlibColor;
>typedef struct _GdkImlibColorModifier GdkImlibColorModifier;
>typedef struct _GdkImlibImage GdkImlibImage;
>typedef struct _GdkImlibSaveInfo GdkImlibSaveInfo;
>typedef struct _GdkImlibInitParams GdkImlibInitParams;
>typedef struct _GdkImlibModifierMap GdkImlibModifierMap;
>
>struct _GdkImlibBorder
>  {
>    gint left, right;
>    gint top, bottom;
>  };
>
>struct _GdkImlibColor
>  {
>    gint r, g, b;
>    gint pixel;
>  };
>
>struct _GdkImlibColorModifier
>  {
>    gint gamma;
>    gint brightness;
>    gint contrast;
>  };
>
>struct _GdkImlibModifierMap
>  {
>    unsigned char rmap[256], gmap[256], bmap[256];
>  };
>
>struct _GdkImlibImage
>  {
>    gint rgb_width, rgb_height;
>    unsigned char *rgb_data;
>    unsigned char *alpha_data;
>    gchar *filename;
>
>    gint width, height;
>    GdkImlibColor shape_color;
>    GdkImlibBorder border;
>    GdkPixmap *pixmap;
>    GdkBitmap *shape_mask;
>    gchar cache;
>    GdkImlibColorModifier mod, rmod, gmod, bmod;
>    GdkImlibModifierMap *map;
>    int ref_count;
>    GHashTable *pixmaps;
>  };
>
>struct _GdkImlibSaveInfo
>  {
>    int quality;
>    int scaling;
>    int xjustification;
>    int yjustification;
>    int page_size;
>    char color;
>  };
>
>struct _GdkImlibInitParams
>  {
>    int flags;
>    int visualid;
>    char *palettefile;
>    char sharedmem;
>    char sharedpixmaps;
>    char paletteoverride;
>    char remap;
>    char fastrender;
>    char hiquality;
>    char dither;
>    int imagecachesize;
>    int pixmapcachesize;
>  };
># 6 "/usr/X11R6/include/gdk_imlib.h" 2
>
>
>
>
>
>
>  void gdk_imlib_init(void);
>  void gdk_imlib_init_params(GdkImlibInitParams * p);
>  gint gdk_imlib_get_render_type(void);
>  void gdk_imlib_set_render_type(gint rend_type);
>  gint gdk_imlib_load_colors(char *file);
>  GdkImlibImage *gdk_imlib_load_image(char *file);
>  GdkImlibImage *gdk_imlib_load_alpha (char *file);
>  gint gdk_imlib_best_color_match(gint * r, gint * g, gint * b);
>  void gdk_imlib_best_color_get(GdkColor * c);
>  gint gdk_imlib_render(GdkImlibImage * image, gint width, gint height);
>  GdkPixmap *gdk_imlib_copy_image(GdkImlibImage * image);
>  GdkBitmap *gdk_imlib_copy_mask(GdkImlibImage * image);
>  GdkPixmap *gdk_imlib_move_image(GdkImlibImage * image);
>  GdkBitmap *gdk_imlib_move_mask(GdkImlibImage * image);
>  void gdk_imlib_destroy_image(GdkImlibImage * image);
>  void gdk_imlib_kill_image(GdkImlibImage * image);
>  void gdk_imlib_free_colors(void);
>  void gdk_imlib_free_pixmap(GdkPixmap * pixmap);
>  void gdk_imlib_free_bitmap(GdkBitmap * bitmap);
>  void gdk_imlib_get_image_border(GdkImlibImage * image, GdkImlibBorder * border);
>  void gdk_imlib_set_image_border(GdkImlibImage * image, GdkImlibBorder * border);
>  void gdk_imlib_get_image_shape(GdkImlibImage * image, GdkImlibColor * color);
>  void gdk_imlib_set_image_shape(GdkImlibImage * image, GdkImlibColor * color);
>  gint gdk_imlib_save_image_to_eim(GdkImlibImage * image, char *file);
>  gint gdk_imlib_add_image_to_eim(GdkImlibImage * image, char *file);
>  gint gdk_imlib_save_image_to_ppm(GdkImlibImage * image, char *file);
>  gint gdk_imlib_load_file_to_pixmap(char *filename, GdkPixmap ** pmap, GdkBitmap ** mask);
>  void gdk_imlib_set_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_set_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_set_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_set_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_get_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_get_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_get_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_get_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod);
>  void gdk_imlib_set_image_red_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_set_image_green_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_set_image_blue_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_get_image_red_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_get_image_green_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_get_image_blue_curve(GdkImlibImage * im, unsigned char *mod);
>  void gdk_imlib_apply_modifiers_to_rgb(GdkImlibImage * im);
>  void gdk_imlib_changed_image(GdkImlibImage * im);
>  void gdk_imlib_apply_image(GdkImlibImage * im, GdkWindow * p);
>  void gdk_imlib_paste_image(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h);
>  void gdk_imlib_paste_image_border(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h);
>  void gdk_imlib_flip_image_horizontal(GdkImlibImage * im);
>  void gdk_imlib_flip_image_vertical(GdkImlibImage * im);
>  void gdk_imlib_rotate_image(GdkImlibImage * im, gint d);
>  GdkImlibImage *gdk_imlib_create_image_from_data(unsigned char *data, unsigned char *alpha, gint w, gint h);
>  GdkImlibImage *gdk_imlib_clone_image(GdkImlibImage * im);
>  GdkImlibImage *gdk_imlib_clone_scaled_image(GdkImlibImage * im, int w, int h);
>  gint gdk_imlib_get_fallback(void);
>  void gdk_imlib_set_fallback(gint fallback);
>  GdkVisual *gdk_imlib_get_visual(void);
>  GdkColormap *gdk_imlib_get_colormap(void);
>  gchar *gdk_imlib_get_sysconfig(void);
>  GdkImlibImage *gdk_imlib_create_image_from_xpm_data(char **data);
>  gint gdk_imlib_data_to_pixmap(char **data, GdkPixmap ** pmap, GdkBitmap ** mask);
>  void gdk_imlib_crop_image(GdkImlibImage * im, gint x, gint y, gint w, gint h);
>  gint gdk_imlib_save_image(GdkImlibImage * im, char *file, GdkImlibSaveInfo * info);
>  GdkImlibImage *gdk_imlib_crop_and_clone_image(GdkImlibImage * im, int x, int y, int w, int h);
>  GdkImlibImage *gdk_imlib_create_image_from_drawable(GdkWindow * gwin, GdkBitmap * gmask, int x, int y, int width, int height);
>  GdkImlibImage *gdk_imlib_inlined_png_to_image(unsigned char *data, int data_size);
>
>  void gdk_imlib_get_cache_info (int *cache_pixmaps, int *cache_images);
>  void gdk_imlib_set_cache_info (int cache_pixmaps, int cache_images);
># 8 "../libgnomeui/gnome-pixmap.h" 2
>
># 1 "../libgnome/gnome-defs.h" 1
># 10 "../libgnomeui/gnome-pixmap.h" 2
>
>
># 21 "../libgnomeui/gnome-pixmap.h"
>typedef struct _GnomePixmap GnomePixmap;
>typedef struct _GnomePixmapClass GnomePixmapClass;
>
>struct _GnomePixmap {
>        GtkWidget widget;
>
>        GdkPixmap *pixmap;
>        GdkBitmap *mask;
>};
>
>struct _GnomePixmapClass {
>        GtkWidgetClass parent_class;
>};
>
>
>guint gnome_pixmap_get_type (void);
>
>GtkWidget *gnome_pixmap_new_from_file (const char *filename);
>GtkWidget *gnome_pixmap_new_from_file_at_size (const char *filename, int width, int height);
>GtkWidget *gnome_pixmap_new_from_xpm_d (char **xpm_data);
>GtkWidget *gnome_pixmap_new_from_xpm_d_at_size (char **xpm_data, int width, int height);
>GtkWidget *gnome_pixmap_new_from_rgb_d (unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height);
>GtkWidget *gnome_pixmap_new_from_rgb_d_shaped (unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                GdkImlibColor *shape_color);
>GtkWidget * gnome_pixmap_new_from_rgb_d_shaped_at_size (unsigned char *data,
>                                                unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                int width, int height,
>                                                GdkImlibColor *shape_color);
>GtkWidget *gnome_pixmap_new_from_rgb_d_at_size (unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                int width, int height);
>GtkWidget *gnome_pixmap_new_from_gnome_pixmap (GnomePixmap *gpixmap);
>GtkWidget *gnome_pixmap_new_from_imlib (GdkImlibImage *im);
>GtkWidget *gnome_pixmap_new_from_imlib_at_size (GdkImlibImage *im,
>                                                int width, int height);
>
>void gnome_pixmap_load_file (GnomePixmap *gpixmap, const char *filename);
>void gnome_pixmap_load_file_at_size (GnomePixmap *gpixmap, const char *filename, int width, int height);
>void gnome_pixmap_load_xpm_d (GnomePixmap *gpixmap, char **xpm_data);
>void gnome_pixmap_load_xpm_d_at_size (GnomePixmap *gpixmap, char **xpm_data, int width, int height);
>void gnome_pixmap_load_rgb_d (GnomePixmap *gpixmap, unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height);
>void gnome_pixmap_load_rgb_d_shaped (GnomePixmap *gpixmap, unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                GdkImlibColor *shape_color);
>void gnome_pixmap_load_rgb_d_shaped_at_size (GnomePixmap *gpixmap,
>                                                unsigned char *data,
>                                                unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                int width, int height,
>                                                GdkImlibColor *shape_color);
>void gnome_pixmap_load_rgb_d_at_size (GnomePixmap *gpixmap, unsigned char *data, unsigned char *alpha,
>                                                int rgb_width, int rgb_height,
>                                                int width, int height);
>void gnome_pixmap_load_imlib (GnomePixmap *gpixmap,
>                                                GdkImlibImage *im);
>void gnome_pixmap_load_imlib_at_size (GnomePixmap *gpixmap,
>                                                GdkImlibImage *im,
>                                                int width, int height);
>
>
>
># 30 "../libgnomeui/gnome-stock.h" 2
># 89 "../libgnomeui/gnome-stock.h"
>
># 193 "../libgnomeui/gnome-stock.h"
>typedef struct _GnomeStockPixmapEntryAny GnomeStockPixmapEntryAny;
>typedef struct _GnomeStockPixmapEntryData GnomeStockPixmapEntryData;
>typedef struct _GnomeStockPixmapEntryFile GnomeStockPixmapEntryFile;
>typedef struct _GnomeStockPixmapEntryPath GnomeStockPixmapEntryPath;
>typedef struct _GnomeStockPixmapEntryWidget GnomeStockPixmapEntryWidget;
>typedef struct _GnomeStockPixmapEntryGPixmap GnomeStockPixmapEntryGPixmap;
>typedef union _GnomeStockPixmapEntry GnomeStockPixmapEntry;
>
>typedef enum {
>        GNOME_STOCK_PIXMAP_TYPE_NONE,
>        GNOME_STOCK_PIXMAP_TYPE_DATA,
>        GNOME_STOCK_PIXMAP_TYPE_FILE,
>        GNOME_STOCK_PIXMAP_TYPE_PATH,
>        GNOME_STOCK_PIXMAP_TYPE_WIDGET,
>        GNOME_STOCK_PIXMAP_TYPE_IMLIB,
>        GNOME_STOCK_PIXMAP_TYPE_IMLIB_SCALED,
>        GNOME_STOCK_PIXMAP_TYPE_GPIXMAP
>} GnomeStockPixmapType;
>
>
>
>struct _GnomeStockPixmapEntryData {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        gchar **xpm_data;
>};
>
>
>typedef struct _GnomeStockPixmapEntryImlib GnomeStockPixmapEntryImlib;
>struct _GnomeStockPixmapEntryImlib {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        const gchar *rgb_data;
>        GdkImlibColor shape;
>};
>
>
>typedef struct _GnomeStockPixmapEntryImlibScaled GnomeStockPixmapEntryImlibScaled;
>struct _GnomeStockPixmapEntryImlibScaled {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        const gchar *rgb_data;
>        GdkImlibColor shape;
>        int scaled_width, scaled_height;
>};
>
>
>
>struct _GnomeStockPixmapEntryFile {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        gchar *filename;
>};
>
>
>struct _GnomeStockPixmapEntryPath {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        gchar *pathname;
>};
>
>
>
>struct _GnomeStockPixmapEntryWidget {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        GtkWidget *widget;
>};
>
>
>struct _GnomeStockPixmapEntryGPixmap {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>        GnomePixmap *pixmap;
>};
>
>struct _GnomeStockPixmapEntryAny {
>        GnomeStockPixmapType type;
>        int width, height;
>        char *label;
>};
>
>union _GnomeStockPixmapEntry {
>        GnomeStockPixmapType type;
>        GnomeStockPixmapEntryAny any;
>        GnomeStockPixmapEntryData data;
>        GnomeStockPixmapEntryFile file;
>        GnomeStockPixmapEntryPath path;
>        GnomeStockPixmapEntryWidget widget;
>        GnomeStockPixmapEntryImlib imlib;
>        GnomeStockPixmapEntryImlibScaled imlib_s;
>        GnomeStockPixmapEntryGPixmap gpixmap;
>};
># 329 "../libgnomeui/gnome-stock.h"
>GtkWidget *gnome_stock_pixmap_widget_new(GtkWidget *window, const char *icon);
># 343 "../libgnomeui/gnome-stock.h"
>typedef struct _GnomeStock GnomeStock;
>typedef struct _GnomeStockClass GnomeStockClass;
>
>struct _GnomeStock {
>        GnomePixmap pixmap;
>        GnomePixmap *regular, *disabled, *focused;
>        GnomePixmap *current;
>        char *icon;
>        guint32 c_regular, c_disabled, c_focused;
>};
>
>struct _GnomeStockClass {
>        GnomePixmapClass pixmap_class;
>};
>
>guint gnome_stock_get_type(void);
>GtkWidget *gnome_stock_new(void);
>GtkWidget *gnome_stock_new_with_icon(const char *icon);
>gboolean gnome_stock_set_icon(GnomeStock *stock, const char *icon);
># 382 "../libgnomeui/gnome-stock.h"
>GtkWidget *gnome_stock_pixmap_widget (GtkWidget *window,
>                                                    const char *icon);
>
>
>
>
>GtkWidget *gnome_stock_pixmap_widget_at_size(GtkWidget *window,
>                                                         const char *icon,
>                                                         guint width,
>                                                         guint height);
>
>
>
>void gnome_stock_pixmap_widget_set_icon(GnomeStock *widget,
>                                        const char *icon);
>
>
>
>
>
>
>gint gnome_stock_pixmap_register (const char *icon,
>                                                    const char *subtype,
>                                                    GnomeStockPixmapEntry *entry);
>
>
>gint gnome_stock_pixmap_change (const char *icon,
>                                                    const char *subtype,
>                                                    GnomeStockPixmapEntry *entry);
>
>
>
>GnomeStockPixmapEntry *gnome_stock_pixmap_checkfor (const char *icon,
>                                                    const char *subtype);
># 424 "../libgnomeui/gnome-stock.h"
>GtkWidget *gnome_pixmap_button (GtkWidget *pixmap,
>                                                   const char *text);
>void gnome_button_can_default (GtkButton *button,
>                                                   gboolean can_default);
># 443 "../libgnomeui/gnome-stock.h"
>GtkWidget *gnome_stock_button (const char *type);
>
>
>
>
>
>GtkWidget *gnome_stock_or_ordinary_button (const char *type);
># 528 "../libgnomeui/gnome-stock.h"
>GtkWidget *gnome_stock_menu_item (const char *type,
>                                                    const char *text);
># 548 "../libgnomeui/gnome-stock.h"
>gboolean gnome_stock_menu_accel (const char *type,
>                                                    guchar *key,
>                                                    guint8 *mod);
>
>
>
>
>void gnome_stock_menu_accel_parse(const char *section);
>
>
>
>
>
>GtkWidget *gnome_stock_transparent_window (const char *icon, const char *subtype);
>
>
>
>
>void gnome_stock_pixmap_gdk (const char *icon,
>                             const char *subtype,
>                             GdkPixmap **pixmap,
>                             GdkPixmap **mask);
>
>
># 30 "gtkcauldron.c" 2
>
># 1 "/usr/X11R6/include/gtk12/gdk/gdkkeysyms.h" 1
># 32 "gtkcauldron.c" 2
>
># 1 "/usr/include/string.h" 1 3 4
># 48 "/usr/include/string.h" 3 4
># 1 "/usr/include/strings.h" 1 3 4
># 40 "/usr/include/strings.h" 3 4
>
>int bcmp(const void *, const void *, size_t);
>void bcopy(const void *, void *, size_t);
>void bzero(void *, size_t);
>int ffs(int);
>char *index(const char *, int);
>char *rindex(const char *, int);
>int strcasecmp(const char *, const char *);
>int strncasecmp(const char *, const char *, size_t);
>
># 49 "/usr/include/string.h" 2 3 4
># 60 "/usr/include/string.h" 3 4
>
>
>void *memccpy(void * , const void * , int, size_t);
>
>void *memchr(const void *, int, size_t);
>int memcmp(const void *, const void *, size_t);
>void *memcpy(void * , const void * , size_t);
>void *memmove(void *, const void *, size_t);
>void *memset(void *, int, size_t);
>
>char *stpcpy(char *, const char *);
>char *strcasestr(const char *, const char *);
>
>char *strcat(char * , const char * );
>char *strchr(const char *, int);
>int strcmp(const char *, const char *);
>int strcoll(const char *, const char *);
>char *strcpy(char * , const char * );
>size_t strcspn(const char *, const char *);
>
>char *strdup(const char *);
>
>char *strerror(int);
>
>int strerror_r(int, char *, size_t);
>
>
>size_t strlcat(char *, const char *, size_t);
>size_t strlcpy(char *, const char *, size_t);
>
>size_t strlen(const char *);
>
>void strmode(int, char *);
>
>char *strncat(char * , const char * , size_t);
>int strncmp(const char *, const char *, size_t);
>char *strncpy(char * , const char * , size_t);
>
>char *strnstr(const char *, const char *, size_t);
>
>char *strpbrk(const char *, const char *);
>char *strrchr(const char *, int);
>
>char *strsep(char **, const char *);
>char *strsignal(int);
>
>size_t strspn(const char *, const char *);
>char *strstr(const char *, const char *);
>char *strtok(char * , const char * );
>
>char *strtok_r(char *, const char *, char **);
>
>size_t strxfrm(char * , const char * , size_t);
>
>void swab(const void *, void *, size_t);
>
>
># 34 "gtkcauldron.c" 2
>
># 1 "/usr/include/stdlib.h" 1 3 4
># 45 "/usr/include/stdlib.h" 3 4
>typedef __rune_t rune_t;
># 57 "/usr/include/stdlib.h" 3 4
>typedef __wchar_t wchar_t;
>
>
>
>
>typedef struct {
>        int quot;
>        int rem;
>} div_t;
>
>typedef struct {
>        long quot;
>        long rem;
>} ldiv_t;
># 81 "/usr/include/stdlib.h" 3 4
>extern int __mb_cur_max;
>
>
>
>void abort(void) __attribute__((__noreturn__));
>int abs(int) __attribute__((__const__));
>int atexit(void (*)(void));
>double atof(const char *);
>int atoi(const char *);
>long atol(const char *);
>void *bsearch(const void *, const void *, size_t,
>            size_t, int (*)(const void *, const void *));
>void *calloc(size_t, size_t);
>div_t div(int, int) __attribute__((__const__));
>void exit(int) __attribute__((__noreturn__));
>void free(void *);
>char *getenv(const char *);
>long labs(long) __attribute__((__const__));
>ldiv_t ldiv(long, long) __attribute__((__const__));
>void *malloc(size_t);
>int mblen(const char *, size_t);
>size_t mbstowcs(wchar_t * , const char * , size_t);
>int mbtowc(wchar_t * , const char * , size_t);
>void qsort(void *, size_t, size_t,
>            int (*)(const void *, const void *));
>int rand(void);
>void *realloc(void *, size_t);
>void srand(unsigned);
>double strtod(const char * , char ** );
>float strtof(const char * , char ** );
>long strtol(const char * , char ** , int);
>long double
>         strtold(const char * , char ** );
>unsigned long
>         strtoul(const char * , char ** , int);
>int system(const char *);
>int wctomb(char *, wchar_t);
>size_t wcstombs(char * , const wchar_t * , size_t);
># 133 "/usr/include/stdlib.h" 3 4
>typedef struct {
>        long long quot;
>        long long rem;
>} lldiv_t;
>
>
>long long
>         atoll(const char *);
>
>long long
>         llabs(long long) __attribute__((__const__));
>
>lldiv_t lldiv(long long, long long) __attribute__((__const__));
>
>long long
>         strtoll(const char * , char ** , int);
>
>unsigned long long
>         strtoull(const char * , char ** , int);
>
>
>void _Exit(int) __attribute__((__noreturn__));
># 164 "/usr/include/stdlib.h" 3 4
>int rand_r(unsigned *);
>int setenv(const char *, const char *, int);
>void unsetenv(const char *);
># 178 "/usr/include/stdlib.h" 3 4
>double drand48(void);
>
>double erand48(unsigned short[3]);
>
>
>
>int getsubopt(char **, char *const *, char **);
>
>
>int grantpt(int);
>char *initstate(unsigned long , char *, long);
>long jrand48(unsigned short[3]);
>
>void lcong48(unsigned short[7]);
>long lrand48(void);
>
>int mkstemp(char *);
>
>
>
>char *mktemp(char *);
>
>
>long mrand48(void);
>long nrand48(unsigned short[3]);
>int posix_openpt(int);
>char *ptsname(int);
>int putenv(const char *);
>long random(void);
>char *realpath(const char *, char resolved_path[]);
>unsigned short
>        *seed48(unsigned short[3]);
>
>int setkey(const char *);
>
>
>char *setstate( char *);
>void srand48(long);
>void srandom(unsigned long);
>int unlockpt(int);
>
>
>
>extern const char *_malloc_options;
>extern void (*_malloc_message)(const char *, const char *, const char *,
>            const char *);
># 241 "/usr/include/stdlib.h" 3 4
>__uint32_t
>         arc4random(void);
>void arc4random_addrandom(unsigned char *dat, int datlen);
>void arc4random_stir(void);
>char *getbsize(int *, long *);
>
>char *cgetcap(char *, const char *, int);
>int cgetclose(void);
>int cgetent(char **, char **, const char *);
>int cgetfirst(char **, char **);
>int cgetmatch(const char *, const char *);
>int cgetnext(char **, char **);
>int cgetnum(char *, const char *, long *);
>int cgetset(const char *);
>int cgetstr(char *, const char *, char **);
>int cgetustr(char *, const char *, char **);
>
>int daemon(int, int);
>char *devname(int, int);
>char *devname_r(int, int, char *, int);
>int getloadavg(double [], int);
>const char *
>         getprogname(void);
>
>int heapsort(void *, size_t, size_t, int (*)(const void *, const void *));
>int mergesort(void *, size_t, size_t, int (*)(const void *, const void *));
>void qsort_r(void *, size_t, size_t, void *,
>            int (*)(void *, const void *, const void *));
>int radixsort(const unsigned char **, int, const unsigned char *,
>            unsigned);
>void *reallocf(void *, size_t);
>void setprogname(const char *);
>int sradixsort(const unsigned char **, int, const unsigned char *,
>            unsigned);
>void sranddev(void);
>void srandomdev(void);
>
>
>__int64_t
>         strtoq(const char *, char **, int);
>__uint64_t
>         strtouq(const char *, char **, int);
>
>
># 36 "gtkcauldron.c" 2
>
>
>gchar *GTK_CAULDRON_ENTER = "GTK_CAULDRON_ENTER";
>gchar *GTK_CAULDRON_ESCAPE = "GTK_CAULDRON_ESCAPE";
>
>static gchar *gtk_dialog_cauldron_error = 0;
>
>gchar *gtk_dialog_cauldron_get_error (void)
>{
>    return gtk_dialog_cauldron_error;
>}
>
>static void gtk_dialog_cauldron_set_error (gchar *s)
>{
>    gtk_dialog_cauldron_error = s;
>}
>
>enum {
>    VERTICAL_HOMOGENOUS = 1,
>    VERTICAL,
>    HORIZONTAL_HOMOGENOUS,
>    HORIZONTAL
>};
>
>
>
>struct cauldron_result {
>    void (*get_result) (GtkWidget *, void *);
>    GtkWidget *w;
>    void *result;
>    struct cauldron_result *next;
>    struct cauldron_result *prev;
>};
>
>
>struct cauldron_button {
>    gchar *label;
>    gchar **result;
>    struct cauldron_result *r;
>    GtkWidget *window;
>};
>
>
>static void gtk_cauldron_get_results (struct cauldron_result *r)
>{
>    if (!r)
>        return;
>    while (r->prev)
>        r = r->prev;
>    while (r) {
>        (*r->get_result) (r->w, r->result);
>        r = r->next;
>    }
>}
>
>
>static void gtk_cauldron_button_exit (GtkWidget * w, struct cauldron_button *b)
>{
>    if (b->r)
>        gtk_cauldron_get_results (b->r);
>    if (b->window) {
>        *(b->result) = b->label;
>        gtk_main_quit ();
>    }
>}
>
>
>static void get_entry_result (GtkWidget * w, void *x)
>{
>    gchar **result = (gchar **) x;
>    *result = g_strdup (gtk_entry_get_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_entry_get_type ())))))));
>}
>
>
>
>static void get_gnome_date_edit_result (GtkWidget * w, void *x)
>{
>    gdouble *result = (gdouble *) x;
>    *result = (gdouble) gnome_date_edit_get_date ((((GnomeDateEdit*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_date_edit_get_type ()))))));
>}
>
>
>static void get_gnome_entry_result (GtkWidget * w, void *x)
>{
>    gchar **result = (gchar **) x;
>    GnomeEntry *gentry;
>    GtkWidget *entry;
>    gentry = (((GnomeEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_entry_get_type ())))));
>    entry = gnome_entry_gtk_entry (gentry);
>    *result = g_strdup (gtk_entry_get_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ())))))));
>}
>
>
>static void get_gnome_file_entry_result (GtkWidget * w, void *x)
>{
>    gchar **result = (gchar **) x;
>    GnomeFileEntry *gentry;
>    GtkWidget *entry;
>    gentry = (((GnomeFileEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_file_entry_get_type ())))));
>    entry = gnome_file_entry_gtk_entry (gentry);
>    *result = g_strdup (gtk_entry_get_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ())))))));
>}
>
>
>static void get_gnome_number_entry_result (GtkWidget * w, void *x)
>{
>    gchar **result = (gchar **) x;
>    GnomeNumberEntry *gentry;
>    GtkWidget *entry;
>    gentry = (((GnomeNumberEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_number_entry_get_type ())))));
>    entry = gnome_number_entry_gtk_entry (gentry);
>    *result = g_strdup (gtk_entry_get_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ())))))));
>}
>
>
>
>
>static void get_text_result (GtkWidget * w, void *x)
>{
>    gchar **result = (gchar **) x;
>    gint i, l;
>    l = gtk_text_get_length ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))));
>    *result = malloc (l + 1);
>    for (i = 0; i < l; i++) {
>        (*result)[i] = ((((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->use_wchar) ? ((i) < ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->gap_position ? ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->text.wc[i] : ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->text.wc[(i)+((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->gap_size]) : ((i) < ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->gap_position ? ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->text.ch[i] : ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->text.ch[(i)+((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))))->gap_size]));
>    }
>    (*result)[l] = '\0';
>}
>
>
>static void get_check_result (GtkWidget * w, void *x)
>{
>    gint *result = (gint *) x;
>    *result = (((GtkToggleButton*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_toggle_button_get_type ())))))->active;
>}
>
>
>static void get_spin_result (GtkWidget * w, void *x)
>{
>    gdouble *result = (gdouble *) x;
>    *result = gtk_spin_button_get_value_as_float ((((GtkSpinButton*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_spin_button_get_type ()))))));
>}
>
>
>
>
>
>
>
>static gint find_breaker (gchar * p)
>{
>    int depth = 0;
>    gchar *q;
>    for (q = p; *q; q++) {
>        if (strchr ("<([{", *q)) {
>            depth++;
>            continue;
>        }
>        if (strchr (">)]}", *q)) {
>            depth--;
>            continue;
>        }
>        if (depth < 1)
>            return HORIZONTAL;
>        if (depth == 1) {
>            if (!strncmp (q, "||", 2))
>                return HORIZONTAL_HOMOGENOUS;
>            if (!strncmp (q, "//", 2))
>                return VERTICAL_HOMOGENOUS;
>            if (!strncmp (q, "|", 1))
>                return HORIZONTAL;
>            if (!strncmp (q, "/", 1))
>                return VERTICAL;
>        }
>    }
>    gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): bracketing error in format string");
>    return 0;
>}
>
>static gint space_after (gchar * p)
>{
>    int s = 0;
>    p++;
>    while ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z'))
>        p++;
>    while (*p == ' ') {
>        p++;
>        s++;
>    }
>    return s;
>}
>
>
>
>
>
>typedef struct _GtkCauldronStack {
>    gint widget_stack_pointer;
>    GtkWidget *widget_stack[256];
>} GtkCauldronStack;
>
>static int widget_stack_push (GtkCauldronStack * s, GtkWidget * x)
>{
>    if (s->widget_stack_pointer >= 250) {
>        gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): maximum number of widgets exceeded");
>        return 1;
>    }
>    s->widget_stack[s->widget_stack_pointer++] = x;
>    s->widget_stack[s->widget_stack_pointer] = 0;
>    return 0;
>}
>
>static GtkWidget *widget_stack_pop (GtkCauldronStack * s)
>{
>    if (s->widget_stack_pointer <= 0) {
>        gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): bracketing error in format string");
>        return 0;
>    }
>    return s->widget_stack[--(s->widget_stack_pointer)];
>}
>
>static GtkWidget *widget_stack_top (GtkCauldronStack * s)
>{
>    if (s->widget_stack_pointer <= 0) {
>        gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): bracketing error in format string");
>        return 0;
>    }
>    s->widget_stack[s->widget_stack_pointer] = 0;
>    return s->widget_stack[s->widget_stack_pointer - 1];
>}
>
>
>
>
>
>static int option_is_present (gchar * p, gchar c)
>{
>    int present = 0;
>    while (*p && strchr ("xfpsieocrdqjhvaugnt", *p)) {
>        if (*p == c)
>            present++;
>        p++;
>    }
>    return present;
>}
>
>static int gtk_cauldron_box_add (GtkWidget * b, GtkWidget * w, gchar ** p, gint pixels_per_space)
>{
>    gint expand = (0), fill = (0), padding = 0, shadow = -1;
>    if (option_is_present (1 + *p, 't'))
>        gtk_widget_set_sensitive (w, 0);
>    if (option_is_present (1 + *p, 'd')) {
>        gtk_container_add ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((b)), ((gtk_container_get_type ()))))), w);
>        while ((*p)[1] && strchr ("xfpsieocrdqjhvaugnt", (*p)[1]))
>            (*p)++;
>        return 0;
>    }
>    while ((*p)[1] && strchr ("xfpsieocrdqjhvaugnt", (*p)[1])) {
>        (*p)++;
>        switch (**p) {
>        case 'x':
>            expand = (!(0));
>            break;
>        case 'f':
>            fill = (!(0));
>            break;
>        case 'p':
>            padding += pixels_per_space;
>            break;
>        case 's':
>            (*p)++;
>            switch (**p) {
>            case 'i':
>                shadow = GTK_SHADOW_IN;
>                break;
>            case 'o':
>                shadow = GTK_SHADOW_OUT;
>                break;
>            case 'e':
>                (*p)++;
>                switch (**p) {
>                case 'i':
>                    shadow = GTK_SHADOW_ETCHED_IN;
>                    break;
>                case 'o':
>                    shadow = GTK_SHADOW_ETCHED_OUT;
>                    break;
>                }
>                break;
>            }
>            if ((( ((GtkTypeObject*) ((w))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass))->type, (((gtk_frame_get_type ())))) ) )) && shadow != -1) {
>                gtk_frame_set_shadow_type ((((GtkFrame*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_frame_get_type ()))))), shadow);
>            } else if ((( ((GtkTypeObject*) ((w))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass))->type, (((gtk_viewport_get_type ())))) ) )) && shadow != -1) {
>                gtk_viewport_set_shadow_type ((((GtkViewport*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_viewport_get_type ()))))), shadow);
>            } else {
>                gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): widget doesn't support setting of shadow type");
>                return 1;
>            }
>            break;
>        default:
>            break;
>        }
>    }
>    if ((( ((GtkTypeObject*) ((b))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((b)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((b)))->klass))->type, (((gtk_box_get_type ())))) ) ))) {
>
>        if ((( ((GtkTypeObject*) ((w))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass))->type, (((gtk_notebook_get_type ())))) ) )))
>            expand = fill = (!(0));
>        gtk_box_pack_start ((((GtkBox*) gtk_type_check_object_cast ((GtkTypeObject*) ((b)), ((gtk_box_get_type ()))))), w, expand, fill, padding);
>    } else if ((( ((GtkTypeObject*) ((b))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((b)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((b)))->klass))->type, (((gtk_container_get_type ())))) ) )))
>        gtk_container_add ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((b)), ((gtk_container_get_type ()))))), w);
>    return 0;
>}
>
>
>
>
>
>struct key_press_event_data {
>    gchar **result;
>    glong options;
>    struct cauldron_result **r;
>};
>
>
>
>static gint key_press_event (GtkWidget * window, GdkEventKey * event, struct key_press_event_data *d)
>{
>    if (!(d->options & (0x1L<<8))) {
>
>        if (event->keyval == 0xFF0D || event->keyval == 0xFF8D || event->keyval == 0xFE34 || event->keyval == 0xFD1E) {
>            *d->result = GTK_CAULDRON_ENTER;
>            gtk_cauldron_get_results (*d->r);
>            gtk_main_quit ();
>            return (!(0));
>        }
>    }
>    if (!(d->options & (0x1L<<7))) {
>        if (event->keyval == 0xFF1B) {
>            *d->result = GTK_CAULDRON_ESCAPE;
>            gtk_main_quit ();
>            return (!(0));
>        }
>    }
>    return (0);
>}
># 402 "gtkcauldron.c"
>static gchar *convert_label_with_ampersand (const gchar * label, gint * accelerator_key, gint * underbar_pos);
>
>static void user_callbacks (GtkWidget * w, gchar * p, GtkCauldronNextArgCallback next_arg, gpointer user_data, GtkAccelGroup * accel_table)
>{
>    int npresent, i;
>    npresent = option_is_present (p, 'a');
>    for (i = 0; i < npresent; i++) {
>        gchar *signal;
>        gint key, mods;
>        next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &signal);
>        next_arg (GTK_CAULDRON_TYPE_INT, user_data, &key);
>        next_arg (GTK_CAULDRON_TYPE_INT, user_data, &mods);
>        gtk_widget_add_accelerator (w, signal, accel_table, key, mods, GTK_ACCEL_VISIBLE);
>    }
>    npresent = option_is_present (p, 'u');
>    for (i = 0; i < npresent; i++) {
>        gchar *signal, *label;
>        gint mods;
>        gint underbar_pos = -1, accelerator_key = 0;
>        next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &signal);
>        next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>        next_arg (GTK_CAULDRON_TYPE_INT, user_data, &mods);
>        label = convert_label_with_ampersand (label, &accelerator_key, &underbar_pos);
>        gtk_widget_add_accelerator (w, signal, accel_table, accelerator_key, mods, GTK_ACCEL_VISIBLE);
>        g_free (label);
>    }
>    if (option_is_present (p, 'c')) {
>        GtkCauldronCustomCallback fud;
>        gpointer fud_user_data;
>        next_arg (GTK_CAULDRON_TYPE_CALLBACK, user_data, &fud);
>        next_arg (GTK_CAULDRON_TYPE_USERDATA_P, user_data, &fud_user_data);
>        (*fud) ((w), fud_user_data);
>    }
>}
>
>
>static gchar *convert_label_with_ampersand (const gchar * _label, gint * accelerator_key, gint * underbar_pos)
>{
>    gchar *p;
>    gchar *label = g_strdup (_label);
>    for (p = label;; p++) {
>        if (!*p)
>            break;
>        if (!p[1])
>            break;
>        if (*p == '&') {
>            memcpy (p, p + 1, strlen (p));
>            if (*p == '&')
>                continue;
>            *underbar_pos = (unsigned long) p - (unsigned long) label;
>            *accelerator_key = *p;
>            return label;
>        }
>    }
>    return label;
>}
>
>struct find_label_data {
>    gchar *label, *pattern;
>};
>
>
>
>static void find_label (GtkWidget * widget, gpointer data)
>{
>    struct find_label_data *d;
>    d = (struct find_label_data *) data;
>    if ((( ((GtkTypeObject*) ((widget))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass))->type, (((gtk_label_get_type ())))) ) ))) {
>        GtkLabel *label;
>        label = (((GtkLabel*) gtk_type_check_object_cast ((GtkTypeObject*) ((widget)), ((gtk_label_get_type ())))));
>        if (!strcmp (label->label, d->label))
>            if (strchr (d->pattern, '_'))
>                gtk_label_set_pattern (label, d->pattern);
>    } else if ((( ((GtkTypeObject*) ((widget))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass))->type, (((gtk_container_get_type ())))) ) ))) {
>        gtk_container_forall ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((widget)), ((gtk_container_get_type ()))))), find_label, data);
>    }
>}
>
>static void get_child_entry (GtkWidget * widget, gpointer data)
>{
>    GtkWidget **d = (GtkWidget **) data;
>    if ((( ((GtkTypeObject*) ((widget))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass))->type, (((gtk_entry_get_type ())))) ) ))) {
>        *d = widget;
>    } else if ((( ((GtkTypeObject*) ((widget))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((widget)))->klass))->type, (((gtk_container_get_type ())))) ) ))) {
>        gtk_container_forall ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((widget)), ((gtk_container_get_type ()))))), get_child_entry, data);
>    }
>}
>
>static gchar *create_label_pattern (gchar * label, gint underbar_pos)
>{
>    gchar *pattern;
>    pattern = g_strdup (label);
>    memset (pattern, ' ', strlen (label));
>    if (underbar_pos < strlen (pattern) && underbar_pos >= 0)
>        pattern[underbar_pos] = '_';
>    return pattern;
>}
>
>static void add_accelerator_with_underbar (GtkWidget * widget, GtkAccelGroup * accel_table, gint accelerator_key, gchar * label, gint underbar_pos)
>{
>    struct find_label_data d;
>    d.label = label;
>    d.pattern = create_label_pattern (label, underbar_pos);
>    find_label (widget, (void *) &d);
>    gtk_widget_add_accelerator (widget, "clicked",
>         accel_table, accelerator_key, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
>    g_free (d.pattern);
>}
>
>static GtkWidget *gtk_label_new_with_ampersand (const gchar * _label)
>{
>    GtkWidget *widget;
>    gchar *pattern;
>    gint accelerator_key = 0, underbar_pos = -1;
>    gchar *label = convert_label_with_ampersand (_label, &accelerator_key,
>                                                 &underbar_pos);
>    pattern = create_label_pattern (label, underbar_pos);
>    widget = gtk_label_new (label);
>    if (underbar_pos != -1)
>        gtk_label_set_pattern ((((GtkLabel*) gtk_type_check_object_cast ((GtkTypeObject*) ((widget)), ((gtk_label_get_type ()))))), pattern);
>    g_free (label);
>    return widget;
>}
># 561 "gtkcauldron.c"
>gchar *gtk_dialog_cauldron_parse (const gchar * title, glong options, const gchar * format,
>                 GtkCauldronNextArgCallback next_arg, gpointer user_data, GtkWidget *parent_)
>{
>    GtkWidget *parent = 0;
>    GtkWidget *w = 0, *top, *window, *f = 0;
>    GSList *radio_group = 0;
>    gchar *p, *return_result = 0, *fmt;
>    gint pixels_per_space = 3;
>    struct cauldron_button b[256];
>    gint ncauldron_button = 0;
>    gint how;
>    struct cauldron_result *r = 0;
>    struct key_press_event_data d;
>    GtkAccelGroup *accel_table;
>    GtkCauldronStack *stack;
>
>
>
>
>    GtkWidget *text_widget[64];
>    gint ntext_widget = 0;
>    gchar *text[64];
>
>
>    if (options & (0x1L<<10))
>        parent = parent_;
>
>    stack = malloc (sizeof (*stack));
>    memset (stack, 0, sizeof (*stack));
>
>    if (options & (0xFL<<(3)))
>        pixels_per_space = (options & (0xFL<<(3))) >> (3);
>
>
>    how = gnome_preferences_get_dialog_type ();
>
>
>
>    if (options & (0x1L<<0))
>        how = GTK_WINDOW_TOPLEVEL;
>    else if (options & (0x1L<<1))
>        how = GTK_WINDOW_DIALOG;
>    else if (options & (0x1L<<2))
>        how = GTK_WINDOW_POPUP;
>    window = gtk_window_new (how);
>
>    gtk_window_set_position ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), gnome_preferences_get_dialog_position ());
>
>
>
>    if (title)
>        gtk_window_set_title ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), title);
>    accel_table = gtk_accel_group_new ();
>    gtk_window_add_accel_group ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), accel_table);
>
>    d.result = &return_result;
>    d.options = options;
>    d.r = &r;
>
>    gtk_signal_connect (( ( (window) != ((void*) 0) && ( (((GtkObject*) (window))->klass) != ((void*) 0) && ((GtkFundamentalType) ((((GtkObjectClass*) (((GtkObject*) (window))->klass))->type) & 0xFF)) == GTK_TYPE_OBJECT ) ) ? (GtkObject*) (window) : (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (window), GTK_TYPE_OBJECT) ), "delete_event",
>                        ((GtkSignalFunc) gtk_main_quit),
>                        ((void*) 0));
>
>    gtk_signal_connect (( ( (window) != ((void*) 0) && ( (((GtkObject*) (window))->klass) != ((void*) 0) && ((GtkFundamentalType) ((((GtkObjectClass*) (((GtkObject*) (window))->klass))->type) & 0xFF)) == GTK_TYPE_OBJECT ) ) ? (GtkObject*) (window) : (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (window), GTK_TYPE_OBJECT) ), "key_press_event",
>                        (GtkSignalFunc) key_press_event, (gpointer) & d);
>
>    if (widget_stack_push (stack, window))
>        return ((gchar *) (-1));
>
>
>    p = fmt = malloc (strlen (format) + 8);
>    strcpy (fmt, "(");
>    strcat (fmt, (gchar *) format);
>    strcat (fmt, ")xf ");
>
>
>    for (; *p; p++) {
>        switch (*p) {
>            int c;
>        case '/':
>        case '|':
>        case ' ':
>            break;
>        case '{':
>            switch (find_breaker (p)) {
>            case VERTICAL:
>            case VERTICAL_HOMOGENOUS:
>                if (widget_stack_push (stack, gtk_vpaned_new ()))
>                    return ((gchar *) (-1));
>                break;
>            case HORIZONTAL:
>            case HORIZONTAL_HOMOGENOUS:
>                if (widget_stack_push (stack, gtk_hpaned_new ()))
>                    return ((gchar *) (-1));
>                break;
>            default:
>                return ((gchar *) (-1));
>            }
>            if (!(top = widget_stack_top (stack)))
>                return ((gchar *) (-1));
>            gtk_container_set_border_width ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((top)), ((gtk_container_get_type ()))))), pixels_per_space * space_after (p));
>            break;
>        case '(':
>            if (strchr ("% \t([{<>}])", p[1])) {
>                gchar *q;
>                gint s;
>                q = strchr (p, '%');
>                if (!q)
>                    q = "%S )";
>                s = space_after (q) * pixels_per_space;
>                switch (find_breaker (p)) {
>                case VERTICAL:
>                    if (widget_stack_push (stack, gtk_vbox_new ((0), s)))
>                        return ((gchar *) (-1));
>                    break;
>                case VERTICAL_HOMOGENOUS:
>                    if (widget_stack_push (stack, gtk_vbox_new ((!(0)), s)))
>                        return ((gchar *) (-1));
>                    break;
>                case HORIZONTAL:
>                    if (widget_stack_push (stack, gtk_hbox_new ((0), s)))
>                        return ((gchar *) (-1));
>                    break;
>                case HORIZONTAL_HOMOGENOUS:
>                    if (widget_stack_push (stack, gtk_hbox_new ((!(0)), s)))
>                        return ((gchar *) (-1));
>                    break;
>                default:
>                    return ((gchar *) (-1));
>                }
>            } else {
>
>                gchar *label;
>                label = g_strdup (p + 1);
>                p = strchr (p, ')');
>                if (!p) {
>                    gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): bracketing error in format string");
>                    return ((gchar *) (-1));
>                }
>                *(strchr (label, ')')) = '\0';
>                w = gtk_label_new_with_ampersand (label);
>                g_free (label);
>                user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                    return ((gchar *) (-1));
>                gtk_widget_show (w);
>                break;
>            }
>            if (!(top = widget_stack_top (stack)))
>                return ((gchar *) (-1));
>            gtk_container_set_border_width ((((GtkContainer*) gtk_type_check_object_cast ((GtkTypeObject*) ((top)), ((gtk_container_get_type ()))))), pixels_per_space * space_after (p));
>            break;
>        case '[':
>            if (widget_stack_push (stack, gtk_frame_new (((void*) 0))))
>                return ((gchar *) (-1));
>            break;
>        case '%':
>            switch (c = *(++p)) {
>            case '[':{
>                    char *label;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                    if (widget_stack_push (stack, gtk_frame_new (label)))
>                        return ((gchar *) (-1));
>                    break;
>                }
>            case 'L':{
>                    gchar *label;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                    w = gtk_label_new_with_ampersand (label);
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                    break;
>                }
>            case 'T':{
>                    gchar **result;
>                    GtkWidget *hscrollbar = 0, *vscrollbar = 0, *table = 0;
>                    int cols = 1, rows = 1;
>                    w = gtk_text_new (((void*) 0), ((void*) 0));
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P_P, user_data, &result);
>                    if (option_is_present (p + 1, 'e')) {
>                        if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_text_result); (r)->w = (w); (r)->result = (void *) (result);;
>                        gtk_text_set_editable ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))), (!(0)));
>                    } else {
>                        gtk_text_set_editable ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ()))))), (0));
>                    }
>                    if (option_is_present (p + 1, 'h')) {
>                        rows++;
>                        hscrollbar = gtk_hscrollbar_new ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ())))))->hadj);
>                    }
>                    if (option_is_present (p + 1, 'v')) {
>                        cols++;
>                        vscrollbar = gtk_vscrollbar_new ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_text_get_type ())))))->vadj);
>                    }
>                    if (hscrollbar || vscrollbar) {
>                        table = gtk_table_new (rows, cols, (0));
>                        if (rows >= 2)
>                            gtk_table_set_row_spacing ((((GtkTable*) gtk_type_check_object_cast ((GtkTypeObject*) ((table)), ((gtk_table_get_type ()))))), 0, 2);
>                        if (cols >= 2)
>                            gtk_table_set_col_spacing ((((GtkTable*) gtk_type_check_object_cast ((GtkTypeObject*) ((table)), ((gtk_table_get_type ()))))), 0, 2);
>                    }
>                    if (hscrollbar) {
>                        gtk_table_attach ((((GtkTable*) gtk_type_check_object_cast ((GtkTypeObject*) ((table)), ((gtk_table_get_type ()))))), hscrollbar, 0, 1, 1, 2,
>                                          GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
>                        gtk_widget_show (hscrollbar);
>                    }
>                    if (vscrollbar) {
>                        gtk_table_attach ((((GtkTable*) gtk_type_check_object_cast ((GtkTypeObject*) ((table)), ((gtk_table_get_type ()))))), vscrollbar, 1, 2, 0, 1,
>                                          GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
>                        gtk_widget_show (vscrollbar);
>                    }
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (table) {
>                        if (!(top = widget_stack_top (stack)))
>                            return ((gchar *) (-1));
>                        if (gtk_cauldron_box_add (top, table, &p, pixels_per_space))
>                            return ((gchar *) (-1));
>                        gtk_table_attach ((((GtkTable*) gtk_type_check_object_cast ((GtkTypeObject*) ((table)), ((gtk_table_get_type ()))))), w, 0, 1, 0, 1,
>                                      GTK_EXPAND | GTK_SHRINK | GTK_FILL,
>                               GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
>                        gtk_widget_show (table);
>                    } else {
>                        if (!(top = widget_stack_top (stack)))
>                            return ((gchar *) (-1));
>                        if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                            return ((gchar *) (-1));
>                    }
>                    gtk_widget_show (w);
>                    if (*result) {
>                        text_widget[ntext_widget] = w;
>                        text[ntext_widget] = *result;
>                        ntext_widget++;
>                        if (ntext_widget >= 64) {
>                            gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): maximum number of text widgets exceeded");
>                            return ((gchar *) (-1));
>                        }
>                    }
>                    break;
>                }
>
>            case 'D':{
>                gdouble *result;
>                gint flags;
>                next_arg (GTK_CAULDRON_TYPE_DOUBLE_P, user_data, &result);
>                next_arg (GTK_CAULDRON_TYPE_INT, user_data, &flags);
>                w = gnome_date_edit_new_flags ((time_t) *result, flags);
>                if (!result) {
>                    gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): date edit widget: place to store result = NULL");
>                    return ((gchar *) (-1));
>                }
>                if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_gnome_date_edit_result); (r)->w = (w); (r)->result = (void *) (result);;
>                if (option_is_present (p + 1, 'o')) {
>                    f = 0;
>                    get_child_entry (w, &f);
>                }
>                user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                    return ((gchar *) (-1));
>                gtk_widget_show (w);
>                break;
>            }
>
>            case 'F':
>            case 'N':
>            case 'E':
>            case 'P':{
>                    gchar **result, *history_id, *dialog_title;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P_P, user_data, &result);
>
>                    if (option_is_present (p + 1, 'g') && *p != 'P') {
>                        next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &history_id);
>                        switch (*p) {
>                        case 'F':
>                            next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &dialog_title);
>                            w = gnome_file_entry_new (history_id, dialog_title);
>                            if (*result) {
>                                GnomeFileEntry *gentry;
>                                GtkWidget *entry;
>                                gentry = (((GnomeFileEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_file_entry_get_type ())))));
>                                entry = gnome_file_entry_gtk_entry (gentry);
>                                gtk_entry_set_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ()))))), *result);
>                                if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_gnome_file_entry_result); (r)->w = (w); (r)->result = (void *) (result);;
>                            }
>                            break;
>                        case 'N':
>                            next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &dialog_title);
>                            w = gnome_number_entry_new (history_id, dialog_title);
>                            if (*result) {
>                                GnomeNumberEntry *gentry;
>                                GtkWidget *entry;
>                                gentry = (((GnomeNumberEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_number_entry_get_type ())))));
>                                entry = gnome_number_entry_gtk_entry (gentry);
>                                gtk_entry_set_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ()))))), *result);
>                                if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_gnome_number_entry_result); (r)->w = (w); (r)->result = (void *) (result);;
>                            }
>                            break;
>                        case 'E':
>                            w = gnome_entry_new (history_id);
>                            if (*result) {
>                                GnomeEntry *gentry;
>                                GtkWidget *entry;
>                                gentry = (((GnomeEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gnome_entry_get_type ())))));
>                                entry = gnome_entry_gtk_entry (gentry);
>                                gtk_entry_set_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((entry)), ((gtk_entry_get_type ()))))), *result);
>                                if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_gnome_entry_result); (r)->w = (w); (r)->result = (void *) (result);;
>                            }
>                            break;
>                        }
>                    } else {
>                        w = gtk_entry_new ();
>                        if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_entry_result); (r)->w = (w); (r)->result = (void *) (result);;
>                        if (c == 'P')
>                            gtk_entry_set_visibility ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_entry_get_type ()))))), (0));
>                        if (*result)
>                            gtk_entry_set_text ((((GtkEntry*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_entry_get_type ()))))), *result);
>                    }
># 894 "gtkcauldron.c"
>                    if (option_is_present (p + 1, 'o')) {
>                        f = 0;
>                        get_child_entry (w, &f);
>                    }
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                    break;
>                }
>            case 'B':{
>                    gchar *label;
>                    gint accelerator_key = 0, underbar_pos = -1;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                    b[ncauldron_button].label = label;
>                    b[ncauldron_button].result = &return_result;
>                    if (label) {
>                        label = convert_label_with_ampersand (label, &accelerator_key, &underbar_pos);
>
>                        if (option_is_present (p + 1, 'g'))
>                            w = gnome_stock_button (label);
>                        else
>
>                            w = gtk_button_new_with_label (label);
>                    } else
>                        w = gtk_button_new ();
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    if (accelerator_key)
>                        add_accelerator_with_underbar (w, accel_table, accelerator_key, label, underbar_pos);
>                    if (label)
>                        g_free (label);
>                    if (option_is_present (p + 1, 'r'))
>                        b[ncauldron_button].r = r;
>                    else
>                        b[ncauldron_button].r = 0;
>                    if (option_is_present (p + 1, 'q'))
>                        b[ncauldron_button].window = window;
>                    else
>                        b[ncauldron_button].window = 0;
>                    gtk_signal_connect (( ( (w) != ((void*) 0) && ( (((GtkObject*) (w))->klass) != ((void*) 0) && ((GtkFundamentalType) ((((GtkObjectClass*) (((GtkObject*) (w))->klass))->type) & 0xFF)) == GTK_TYPE_OBJECT ) ) ? (GtkObject*) (w) : (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (w), GTK_TYPE_OBJECT) ), "clicked",
>                              ((GtkSignalFunc) gtk_cauldron_button_exit),
>                                        (gpointer) & b[ncauldron_button]);
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                    ncauldron_button++;
>                    break;
>                }
>            case 'C':{
>                    gchar *label;
>                    gint accelerator_key = 0, underbar_pos = -1;
>                    int *result;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                    if (label) {
>                        label = convert_label_with_ampersand (label, &accelerator_key, &underbar_pos);
>                        w = gtk_check_button_new_with_label (label);
>                    } else
>                        w = gtk_check_button_new ();
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    if (accelerator_key)
>                        add_accelerator_with_underbar (w, accel_table, accelerator_key, label, underbar_pos);
>                    next_arg (GTK_CAULDRON_TYPE_INT_P, user_data, &result);
>                    (((GtkToggleButton*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_toggle_button_get_type ())))))->active = *result;
>                    if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_check_result); (r)->w = (w); (r)->result = (void *) (result);;
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                    if (label)
>                        g_free (label);
>                    break;
>                }
>            case 'S':
>                if (p[1] == 'B') {
>                    gint digits;
>                    gdouble climb_rate, *result;
>                    p++;
>                    next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &climb_rate);
>                    next_arg (GTK_CAULDRON_TYPE_INT, user_data, &digits);
>                    if (option_is_present (p + 1, 'j')) {
>                        gdouble lower_bound, upper_bound, step_increment,
>                         page_increment, page_size;
>                        GtkAdjustment *adj;
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE_P, user_data, &result);
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &lower_bound);
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &upper_bound);
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &step_increment);
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &page_increment);
>                        next_arg (GTK_CAULDRON_TYPE_DOUBLE, user_data, &page_size);
>                        adj = (GtkAdjustment *) gtk_adjustment_new (*result, lower_bound, upper_bound, step_increment, page_increment, page_size);
>
>                        w = gtk_spin_button_new (adj, climb_rate, digits);
>                        if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_spin_result); (r)->w = (w); (r)->result = (void *) (result);;
>                    } else {
>                        w = gtk_spin_button_new (0, climb_rate, digits);
>                    }
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                } else {
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if ((( ((GtkTypeObject*) ((top))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((top)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((top)))->klass))->type, (((gtk_hbox_get_type ())))) ) ))) {
>                        w = gtk_vseparator_new ();
>                    } else {
>                        w = gtk_hseparator_new ();
>                    }
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                }
>                break;
>            case 'R':{
>                    gchar *label;
>                    gint *result;
>                    gint accelerator_key = 0, underbar_pos = -1;
>                    next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                    if (label) {
>                        label = convert_label_with_ampersand (label, &accelerator_key, &underbar_pos);
>                        w = gtk_radio_button_new_with_label (radio_group, label);
>                    } else
>                        w = gtk_radio_button_new (radio_group);
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    if (accelerator_key)
>                        add_accelerator_with_underbar (w, accel_table, accelerator_key, label, underbar_pos);
>                    radio_group = gtk_radio_button_group ((((GtkRadioButton*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_radio_button_get_type ()))))));
>                    next_arg (GTK_CAULDRON_TYPE_INT_P, user_data, &result);
>                    gtk_toggle_button_set_active ((((GtkToggleButton*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_toggle_button_get_type ()))))), *result);
>                    if (r) { (r)->next = malloc (sizeof (*(r))); (r)->next->prev = (r); (r) = (r)->next; (r)->next = 0; } else { (r) = malloc (sizeof (*(r))); (r)->next = 0; (r)->prev = 0; } (r)->get_result = (get_check_result); (r)->w = (w); (r)->result = (void *) (result);;
>                    user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (w);
>                    if (label)
>                        g_free (label);
>                    break;
>                }
>            case 'X':{
>                    GtkCauldronCustomCallback func;
>                    gpointer data;
>                    next_arg (GTK_CAULDRON_TYPE_CALLBACK, user_data, &func);
>                    next_arg (GTK_CAULDRON_TYPE_USERDATA_P, user_data, &data);
>                    w = (*func) (window, data);
>                    if (option_is_present (p + 1, 'o'))
>                        f = w;
>                    if (w) {
>                        if (!(top = widget_stack_top (stack)))
>                            return ((gchar *) (-1));
>                        if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                            return ((gchar *) (-1));
>                        gtk_widget_show (w);
>                    } else {
>                        gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): user callback GtkCauldronCustomCallback returned null");
>                        return ((gchar *) (-1));
>                    }
>                    break;
>                }
>            }
>            break;
>        case '}':
>        case ')':
>        case ']':
>            radio_group = 0;
>            w = widget_stack_pop (stack);
>            if (!w)
>                return ((gchar *) (-1));
>            if ((( ((GtkTypeObject*) ((w))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((w)))->klass))->type, (((gtk_notebook_get_type ())))) ) ))) {
>                gtk_notebook_set_page ((((GtkNotebook*) gtk_type_check_object_cast ((GtkTypeObject*) ((w)), ((gtk_notebook_get_type ()))))), 0);
>                w = widget_stack_pop (stack);
>                if (!w)
>                    return ((gchar *) (-1));
>            }
>            if (option_is_present (p + 1, 'n')) {
>                gchar *label;
>
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                if (!(( ((GtkTypeObject*) ((top))) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) ((top)))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) ((top)))->klass))->type, (((gtk_notebook_get_type ())))) ) ))) {
>                    GtkWidget *notebook;
>                    notebook = gtk_notebook_new ();
>                    if (option_is_present (p + 1, 'v'))
>                        gtk_notebook_set_tab_pos ((((GtkNotebook*) gtk_type_check_object_cast ((GtkTypeObject*) ((notebook)), ((gtk_notebook_get_type ()))))), GTK_POS_LEFT);
>                    while (p[1] && strchr ("xfpsieocrdqjhvaugnt", p[1]))
>                        p++;
>                    if (!(top = widget_stack_top (stack)))
>                        return ((gchar *) (-1));
>                    if (gtk_cauldron_box_add (top, notebook, &p, pixels_per_space))
>                        return ((gchar *) (-1));
>                    gtk_widget_show (notebook);
>                    if (widget_stack_push (stack, notebook))
>                        return ((gchar *) (-1));
>                } else {
>                    while (p[1] && strchr ("xfpsieocrdqjhvaugnt", p[1]))
>                        p++;
>                }
>                next_arg (GTK_CAULDRON_TYPE_CHAR_P, user_data, &label);
>                user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                gtk_notebook_append_page ((((GtkNotebook*) gtk_type_check_object_cast ((GtkTypeObject*) ((top)), ((gtk_notebook_get_type ()))))), w, gtk_label_new_with_ampersand (label));
>            } else if (option_is_present (p + 1, 'v') || option_is_present (p + 1, 'h')) {
>                GtkWidget *scrolled_window;
>                scrolled_window = gtk_scrolled_window_new (((void*) 0), ((void*) 0));
>                gtk_scrolled_window_set_policy ((((GtkScrolledWindow*) gtk_type_check_object_cast ((GtkTypeObject*) ((scrolled_window)), ((gtk_scrolled_window_get_type ()))))),
>                                                option_is_present (p + 1, 'h') ? GTK_POLICY_ALWAYS : GTK_POLICY_AUTOMATIC,
>                                                option_is_present (p + 1, 'v') ? GTK_POLICY_ALWAYS : GTK_POLICY_AUTOMATIC);
>                gtk_scrolled_window_add_with_viewport ((((GtkScrolledWindow*) gtk_type_check_object_cast ((GtkTypeObject*) ((scrolled_window)), ((gtk_scrolled_window_get_type ()))))), w);
>                gtk_widget_show (scrolled_window);
>                user_callbacks (scrolled_window, p + 1, next_arg, user_data, accel_table);
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                if (gtk_cauldron_box_add (top, scrolled_window, &p, pixels_per_space))
>                    return ((gchar *) (-1));
>            } else {
>                user_callbacks (w, p + 1, next_arg, user_data, accel_table);
>                if (!(top = widget_stack_top (stack)))
>                    return ((gchar *) (-1));
>                if (gtk_cauldron_box_add (top, w, &p, pixels_per_space))
>                    return ((gchar *) (-1));
>            }
>            gtk_widget_show (w);
>            break;
>        default:{
>                gchar e[100] = "gtk_dialog_cauldron(): bad syntax in format string at: ";
>                gint l;
>                l = strlen (e);
>                strncpy (e + l, p, 30);
>                strcpy (e + l + 30, "...");
>                gtk_dialog_cauldron_set_error (e);
>                return ((gchar *) (-1));
>            }
>        }
>    }
>    if (stack->widget_stack_pointer != 1) {
>        gtk_dialog_cauldron_set_error ("gtk_dialog_cauldron(): bracketing error in format string");
>        return ((gchar *) (-1));
>    }
>    w = widget_stack_pop (stack);
>    if (!w)
>        return ((gchar *) (-1));
>    gtk_widget_show (w);
>
>    while (ntext_widget-- > 0) {
>        gtk_text_freeze ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((text_widget[ntext_widget])), ((gtk_text_get_type ()))))));
>        gtk_text_insert ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((text_widget[ntext_widget])), ((gtk_text_get_type ()))))), ((void*) 0), ((void*) 0), ((void*) 0), text[ntext_widget], -1);
>        gtk_text_thaw ((((GtkText*) gtk_type_check_object_cast ((GtkTypeObject*) ((text_widget[ntext_widget])), ((gtk_text_get_type ()))))));
>    }
>
>    if (options & (0x1L<<9))
>        gtk_grab_add (window);
>
>    if (f)
>        gtk_widget_grab_focus (f);
>    if (parent) {
>        if ((( ((GtkTypeObject*) (parent)) != ((void*) 0) && ( ((GtkTypeClass*) (((GtkTypeObject*) (parent))->klass)) != ((void*) 0) && gtk_type_is_a (((GtkTypeClass*) (((GtkTypeObject*) (parent))->klass))->type, (((gtk_window_get_type ())))) ) ))) {
>            if ((unsigned long) parent != (unsigned long) window) {
>                gtk_window_set_transient_for ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), (((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (parent), ((gtk_window_get_type ()))))));
>
>
>
>
>
>                if (gnome_preferences_get_dialog_centered ()) {
>                    gint x, y, w, h, window_x, window_y;
>                    if (((((( ( (parent) != ((void*) 0) && ( (((GtkObject*) (parent))->klass) != ((void*) 0) && ((GtkFundamentalType) ((((GtkObjectClass*) (((GtkObject*) (parent))->klass))->type) & 0xFF)) == GTK_TYPE_OBJECT ) ) ? (GtkObject*) (parent) : (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (parent), GTK_TYPE_OBJECT) )->flags)) & GTK_VISIBLE) != 0)) {
>                        gtk_window_set_position ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), GTK_WIN_POS_NONE);
>                        gdk_window_get_origin ((((GtkWidget*) gtk_type_check_object_cast ((GtkTypeObject*) ((parent)), ((gtk_widget_get_type ())))))->window, &x, &y);
>                        gdk_window_get_size ((((GtkWidget*) gtk_type_check_object_cast ((GtkTypeObject*) ((parent)), ((gtk_widget_get_type ())))))->window, &w, &h);
>                        window_x = x + w / 4;
>                        window_y = y + h / 4;
>                        gtk_widget_set_uposition ((((GtkWidget*) gtk_type_check_object_cast ((GtkTypeObject*) ((window)), ((gtk_widget_get_type ()))))), window_x, window_y);
>                    }
>                }
>
>            }
>        }
>    }
>    gtk_main ();
>    gtk_window_remove_accel_group ((((GtkWindow*) gtk_type_check_object_cast ((GtkTypeObject*) (window), ((gtk_window_get_type ()))))), accel_table);
>    gtk_object_destroy (( ( (window) != ((void*) 0) && ( (((GtkObject*) (window))->klass) != ((void*) 0) && ((GtkFundamentalType) ((((GtkObjectClass*) (((GtkObject*) (window))->klass))->type) & 0xFF)) == GTK_TYPE_OBJECT ) ) ? (GtkObject*) (window) : (GtkObject*) gtk_type_check_object_cast ((GtkTypeObject*) (window), GTK_TYPE_OBJECT) ));
>
>    if (r) {
>        while (r->prev)
>            r = r->prev;
>        while (r) {
>            struct cauldron_result *next;
>            next = r->next;
>            free (r);
>            r = next;
>        }
>    }
>    free (fmt);
>    free (stack);
>    return return_result;
>}
>
>static void next_arg (gint type, va_list * ap, void *result)
>{
>    switch (type) {
>    case GTK_CAULDRON_TYPE_CHAR_P:{
>            gchar **x = (gchar **) result;
>            *x = __builtin_va_arg((*ap), gchar *);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_CHAR_P_P:{
>            gchar ***x = (gchar ***) result;
>            *x = __builtin_va_arg((*ap), gchar **);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_INT:{
>            gint *x = (gint *) result;
>            *x = __builtin_va_arg((*ap), gint);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_INT_P:{
>            gint **x = (gint **) result;
>            *x = __builtin_va_arg((*ap), gint *);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_USERDATA_P:{
>            gpointer *x = (gpointer *) result;
>            *x = __builtin_va_arg((*ap), gpointer);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_DOUBLE:{
>            gdouble *x = (gdouble *) result;
>            *x = __builtin_va_arg((*ap), gdouble);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_DOUBLE_P:{
>            gdouble **x = (gdouble **) result;
>            *x = __builtin_va_arg((*ap), gdouble *);
>            break;
>        }
>    case GTK_CAULDRON_TYPE_CALLBACK:{
>            GtkCauldronNextArgCallback *x = (GtkCauldronNextArgCallback *) result;
>            *x = __builtin_va_arg((*ap), GtkCauldronNextArgCallback);
>            break;
>        }
>    }
>    return;
>}
># 1279 "gtkcauldron.c"
>gchar *gtk_dialog_cauldron (const gchar * title, glong options,...)
>{
>    gchar *r;
>    GtkWidget *parent = 0;
>    char *format;
>    va_list ap;
>    __builtin_stdarg_start((ap), (options));
>    if (options & (0x1L<<10))
>        parent = __builtin_va_arg((ap), GtkWidget *);
>    format = __builtin_va_arg((ap), char *);
>    r = gtk_dialog_cauldron_parse (title, options, format, (GtkCauldronNextArgCallback) next_arg, &ap, parent);
>    __builtin_va_end(ap);
>    if (r == ((gchar *) (-1)))
>        g_log ("GnomeUI", G_LOG_LEVEL_ERROR, gtk_dialog_cauldron_get_error ());
>    return r;
>}

Actions: View

Attachments on bug 11741: 4532 | 4533