// Written in the D programming language. /* * Full GTK, GDK, Pango, etc... bindings * * Tedious work done by John Demme (me@teqdruid.com) * h2d used as well. * * LGPL License from original header files probably applies. * */ module minwin.gtk; version(X86_64) version=CPU64BIT; else version(PPC64) version=CPU64BIT; // Included as part of MinWin since the LGPL says the use of header // files is unrestricted. The LGPL does not apply to any other part of // MinWin except for this file (and even there John isn't sure if it // applies since it is a port of header files). The original gtk.d is // available from www.dsource.org extern (C) { //alias int ptrdiff_t; //alias uint size_t; //alias int wchar_t; alias byte gint8; alias ubyte guint8; alias short gint16; alias ushort guint16; alias int gint32; alias uint guint32; alias long gint64; alias ulong guint64; version(CPU64BIT) { alias long gssize; alias ulong gsize; } else { alias int gssize; alias uint gsize; } alias _GStaticMutex GStaticMutex; alias void _GMutex; struct _GStaticMutex { _GMutex *runtime_mutex; union static_mutex_union { char pad[24]; double dummy_double; void *dummy_pointer; int dummy_long; } static_mutex_union static_mutex; } alias _GSystemThread GSystemThread; union _GSystemThread { char data[4]; double dummy_double; void *dummy_pointer; int dummy_long; } alias int GPid; alias char gchar; alias short gshort; version(CPU64BIT) alias long glong; else alias int glong; alias int gint; alias gint gboolean; alias ubyte guchar; alias ushort gushort; version(CPU64BIT) alias ulong gulong; else alias uint gulong; alias uint guint; alias float gfloat; alias double gdouble; alias void* gpointer; alias void *gconstpointer; alias gint (*GCompareFunc) (gpointer a, gpointer b); alias gint (*GCompareDataFunc) (gpointer a, gpointer b, gpointer user_data); alias gboolean (*GEqualFunc) (gpointer a, gpointer b); alias void (*GDestroyNotify) (gpointer data); alias void (*GFunc) (gpointer data, gpointer user_data); alias guint (*GHashFunc) (gpointer key); alias void (*GHFunc) (gpointer key, gpointer value, gpointer user_data); alias void (*GFreeFunc) (gpointer data); alias _GDoubleIEEE754 GDoubleIEEE754; alias _GFloatIEEE754 GFloatIEEE754; union _GFloatIEEE754 { gfloat v_float; struct mpn_struct { guint mantissa; guint biased_exponent; guint sign; } } union _GDoubleIEEE754 { gdouble v_double; struct mpn_struct { guint mantissa_low; guint mantissa_high; guint biased_exponent; guint sign; } } alias _GTimeVal GTimeVal; struct _GTimeVal { glong tv_sec; glong tv_usec; } alias _GArray GArray; alias _GByteArray GByteArray; alias _GPtrArray GPtrArray; struct _GArray { gchar *data; guint len; } struct _GByteArray { guint8 *data; guint len; } struct _GPtrArray { gpointer *pdata; guint len; } GArray* g_array_new (gboolean zero_terminated, gboolean clear_, guint element_size); GArray* g_array_sized_new (gboolean zero_terminated, gboolean clear_, guint element_size, guint reserved_size); gchar* g_array_free (GArray *array, gboolean free_segment); GArray* g_array_append_vals (GArray *array, gpointer data, guint len); GArray* g_array_prepend_vals (GArray *array, gpointer data, guint len); GArray* g_array_insert_vals (GArray *array, guint index_, gpointer 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_); GArray* g_array_remove_range (GArray *array, guint index_, guint length); void g_array_sort (GArray *array, GCompareFunc compare_func); void g_array_sort_with_data (GArray *array, GCompareDataFunc compare_func, gpointer user_data); GPtrArray* g_ptr_array_new (); GPtrArray* g_ptr_array_sized_new (guint reserved_size); gpointer* 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_remove_range (GPtrArray *array, guint index_, guint length); void g_ptr_array_add (GPtrArray *array, gpointer data); void g_ptr_array_sort (GPtrArray *array, GCompareFunc compare_func); void g_ptr_array_sort_with_data (GPtrArray *array, GCompareDataFunc compare_func, gpointer user_data); void g_ptr_array_foreach (GPtrArray *array, GFunc func, gpointer user_data); GByteArray* g_byte_array_new (); GByteArray* g_byte_array_sized_new (guint reserved_size); guint8* g_byte_array_free (GByteArray *array, gboolean free_segment); GByteArray* g_byte_array_append (GByteArray *array, guint8 *data, guint len); GByteArray* g_byte_array_prepend (GByteArray *array, 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_); GByteArray* g_byte_array_remove_range (GByteArray *array, guint index_, guint length); void g_byte_array_sort (GByteArray *array, GCompareFunc compare_func); void g_byte_array_sort_with_data (GByteArray *array, GCompareDataFunc compare_func, gpointer user_data); alias guint32 GQuark; GQuark g_quark_try_string ( gchar *string); GQuark g_quark_from_static_string ( gchar *string); GQuark g_quark_from_string ( gchar *string); gchar* g_quark_to_string (GQuark quark) ; alias _GError GError; struct _GError { GQuark domain; gint code; gchar *message; } GError* g_error_new (GQuark domain, gint code, gchar *format, ...) ; GError* g_error_new_literal (GQuark domain, gint code, gchar *message); void g_error_free (GError *error); GError* g_error_copy ( GError *error); gboolean g_error_matches ( GError *error, GQuark domain, gint code); void g_set_error (GError **err, GQuark domain, gint code, gchar *format, ...) ; void g_propagate_error (GError **dest, GError *src); void g_clear_error (GError **err); gint g_atomic_int_exchange_and_add (gint *atomic, gint val); void g_atomic_int_add (gint *atomic, gint val); gboolean g_atomic_int_compare_and_exchange (gint *atomic, gint oldval, gint newval); gboolean g_atomic_pointer_compare_and_exchange (gpointer *atomic, gpointer oldval, gpointer newval); GQuark g_thread_error_quark (); enum GThreadError { G_THREAD_ERROR_AGAIN }; alias gpointer (*GThreadFunc) (gpointer data); enum GThreadPriority { G_THREAD_PRIORITY_LOW, G_THREAD_PRIORITY_NORMAL, G_THREAD_PRIORITY_HIGH, G_THREAD_PRIORITY_URGENT }; alias _GThread GThread; struct _GThread { GThreadFunc func; gpointer data; gboolean joinable; GThreadPriority priority; } alias _GMutex GMutex; alias _GCond GCond; alias void _GCond; alias _GPrivate GPrivate; alias void _GPrivate; alias _GStaticPrivate GStaticPrivate; alias _GThreadFunctions GThreadFunctions; struct _GThreadFunctions { GMutex* (*mutex_new) (); void (*mutex_lock) (GMutex *mutex); gboolean (*mutex_trylock) (GMutex *mutex); void (*mutex_unlock) (GMutex *mutex); void (*mutex_free) (GMutex *mutex); GCond* (*cond_new) (); 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); gpointer (*private_get) (GPrivate *private_key); void (*private_set) (GPrivate *private_key, gpointer data); void (*thread_create) (GThreadFunc func, gpointer data, gulong stack_size, gboolean joinable, gboolean bound, GThreadPriority priority, gpointer thread, GError **error); void (*thread_yield) (); void (*thread_join) (gpointer thread); void (*thread_exit) (); void (*thread_set_priority)(gpointer thread, GThreadPriority priority); void (*thread_self) (gpointer thread); gboolean (*thread_equal) (gpointer thread1, gpointer thread2); } GThreadFunctions g_thread_functions_for_glib_use; gboolean g_thread_use_default_impl; gboolean g_threads_got_initialized; void g_thread_init (GThreadFunctions *vtable); void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable); GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex); GThread* g_thread_create_full (GThreadFunc func, gpointer data, gulong stack_size, gboolean joinable, gboolean bound, GThreadPriority priority, GError **error); GThread* g_thread_self (); void g_thread_exit (gpointer retval); gpointer g_thread_join (GThread *thread); void g_thread_set_priority (GThread *thread, GThreadPriority priority); void g_static_mutex_init (GStaticMutex *mutex); void g_static_mutex_free (GStaticMutex *mutex); struct _GStaticPrivate { guint index; } void g_static_private_init (GStaticPrivate *private_key); gpointer g_static_private_get (GStaticPrivate *private_key); void g_static_private_set (GStaticPrivate *private_key, gpointer data, GDestroyNotify notify); void g_static_private_free (GStaticPrivate *private_key); alias _GStaticRecMutex GStaticRecMutex; struct _GStaticRecMutex { GStaticMutex mutex; guint depth; GSystemThread owner; } void g_static_rec_mutex_init (GStaticRecMutex *mutex); void g_static_rec_mutex_lock (GStaticRecMutex *mutex); gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex); void g_static_rec_mutex_unlock (GStaticRecMutex *mutex); void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex, guint depth); guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex); void g_static_rec_mutex_free (GStaticRecMutex *mutex); alias _GStaticRWLock GStaticRWLock; struct _GStaticRWLock { GStaticMutex mutex; GCond *read_cond; GCond *write_cond; guint read_counter; gboolean have_writer; guint want_to_read; guint want_to_write; } void g_static_rw_lock_init (GStaticRWLock* lock); void g_static_rw_lock_reader_lock (GStaticRWLock* lock); gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock); void g_static_rw_lock_reader_unlock (GStaticRWLock* lock); void g_static_rw_lock_writer_lock (GStaticRWLock* lock); gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock); void g_static_rw_lock_writer_unlock (GStaticRWLock* lock); void g_static_rw_lock_free (GStaticRWLock* lock); enum GOnceStatus { G_ONCE_STATUS_NOTCALLED, G_ONCE_STATUS_PROGRESS, G_ONCE_STATUS_READY }; alias _GOnce GOnce; struct _GOnce { GOnceStatus status; gpointer retval; } gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg); void glib_dummy_decl (); alias _GAsyncQueue GAsyncQueue; alias void _GAsyncQueue; GAsyncQueue* g_async_queue_new (); void g_async_queue_lock (GAsyncQueue *queue); void g_async_queue_unlock (GAsyncQueue *queue); void g_async_queue_ref (GAsyncQueue *queue); void g_async_queue_unref (GAsyncQueue *queue); void g_async_queue_ref_unlocked (GAsyncQueue *queue); void g_async_queue_unref_and_unlock (GAsyncQueue *queue); void g_async_queue_push (GAsyncQueue *queue, gpointer data); void g_async_queue_push_unlocked (GAsyncQueue *queue, gpointer data); gpointer g_async_queue_pop (GAsyncQueue *queue); gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue); gpointer g_async_queue_try_pop (GAsyncQueue *queue); gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue); gpointer g_async_queue_timed_pop (GAsyncQueue *queue, GTimeVal *end_time); gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue, GTimeVal *end_time); gint g_async_queue_length (GAsyncQueue *queue); gint g_async_queue_length_unlocked (GAsyncQueue *queue); void g_on_error_query ( gchar *prg_name); void g_on_error_stack_trace ( gchar *prg_name); alias _GAllocator GAllocator; alias void _GAllocator; alias _GMemChunk GMemChunk; alias void _GMemChunk; alias _GMemVTable GMemVTable; gpointer g_malloc (gulong n_bytes); gpointer g_malloc0 (gulong n_bytes); gpointer g_realloc (gpointer mem, gulong n_bytes); void g_free (gpointer mem); gpointer g_try_malloc (gulong n_bytes); gpointer g_try_realloc (gpointer mem, gulong n_bytes); struct _GMemVTable { gpointer (*malloc) (gsize n_bytes); gpointer (*realloc) (gpointer mem, gsize n_bytes); void (*free) (gpointer mem); gpointer (*calloc) (gsize n_blocks, gsize n_block_bytes); gpointer (*try_malloc) (gsize n_bytes); gpointer (*try_realloc) (gpointer mem, gsize n_bytes); } void g_mem_set_vtable (GMemVTable *vtable); gboolean g_mem_is_system_malloc (); GMemVTable *glib_mem_profiler_table; void g_mem_profile (); 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 g_blow_chunks (); GAllocator* g_allocator_new ( gchar *name, guint n_preallocs); void g_allocator_free (GAllocator *allocator); alias _GList GList; struct _GList { gpointer data; GList *next; GList *prev; } void g_list_push_allocator (GAllocator *allocator); void g_list_pop_allocator (); GList* g_list_alloc (); 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_insert_before (GList *list, GList *sibling, gpointer data); GList* g_list_concat (GList *list1, GList *list2); GList* g_list_remove (GList *list, gpointer data); GList* g_list_remove_all (GList *list, gpointer data); GList* g_list_remove_link (GList *list, GList *llink); GList* g_list_delete_link (GList *list, GList *link_); GList* g_list_reverse (GList *list); GList* g_list_copy (GList *list); GList* g_list_nth (GList *list, guint n); GList* g_list_nth_prev (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); GList* g_list_sort_with_data (GList *list, GCompareDataFunc compare_func, gpointer user_data); gpointer g_list_nth_data (GList *list, guint n); alias _GCache GCache; alias void _GCache; alias gpointer (*GCacheNewFunc) (gpointer key); alias gpointer (*GCacheDupFunc) (gpointer value); alias void (*GCacheDestroyFunc) (gpointer value); 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, GEqualFunc key_equal_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); alias _GCompletion GCompletion; alias gchar* (*GCompletionFunc) (gpointer); alias gint (*GCompletionStrncmpFunc) (gchar *s1, gchar *s2, gsize n); struct _GCompletion { GList* items; GCompletionFunc func; gchar* prefix; GList* cache; GCompletionStrncmpFunc strncmp_func; } 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); GList* g_completion_complete_utf8 (GCompletion *cmp, gchar* prefix, gchar** new_prefix); void g_completion_set_compare (GCompletion *cmp, GCompletionStrncmpFunc strncmp_func); void g_completion_free (GCompletion* cmp); enum GConvertError { G_CONVERT_ERROR_NO_CONVERSION, G_CONVERT_ERROR_ILLEGAL_SEQUENCE, G_CONVERT_ERROR_FAILED, G_CONVERT_ERROR_PARTIAL_INPUT, G_CONVERT_ERROR_BAD_URI, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH }; GQuark g_convert_error_quark (); alias _GIConv *GIConv; alias void _GIConv; GIConv g_iconv_open ( gchar *to_codeset, gchar *from_codeset); size_t g_iconv (GIConv converter, gchar **inbuf, gsize *inbytes_left, gchar **outbuf, gsize *outbytes_left); gint g_iconv_close (GIConv converter); gchar* g_convert ( gchar *str, gssize len, gchar *to_codeset, gchar *from_codeset, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_convert_with_iconv ( gchar *str, gssize len, GIConv converter, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_convert_with_fallback ( gchar *str, gssize len, gchar *to_codeset, gchar *from_codeset, gchar *fallback, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_locale_to_utf8 ( gchar *opsysstring, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_locale_from_utf8 ( gchar *utf8string, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_filename_to_utf8 ( gchar *opsysstring, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error); gchar* g_filename_from_utf8 ( gchar *utf8string, gssize len, gsize *bytes_read, gsize *bytes_written, GError **error); gchar *g_filename_from_uri ( gchar *uri, gchar **hostname, GError **error); gchar *g_filename_to_uri ( gchar *filename, gchar *hostname, GError **error); alias _GData GData; alias void _GData; alias void (*GDataForeachFunc) (GQuark key_id, gpointer data, gpointer user_data); 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); gpointer g_datalist_id_remove_no_notify (GData **datalist, GQuark key_id); void g_datalist_foreach (GData **datalist, GDataForeachFunc func, gpointer user_data); void g_dataset_destroy (gpointer dataset_location); gpointer g_dataset_id_get_data (gpointer dataset_location, GQuark key_id); void g_dataset_id_set_data_full (gpointer dataset_location, GQuark key_id, gpointer data, GDestroyNotify destroy_func); gpointer g_dataset_id_remove_no_notify (gpointer dataset_location, GQuark key_id); void g_dataset_foreach (gpointer dataset_location, GDataForeachFunc func, gpointer user_data); alias gint32 GTime; alias guint16 GDateYear; alias guint8 GDateDay; alias _GDate GDate; enum GDateDMY { G_DATE_DAY = 0, G_DATE_MONTH = 1, G_DATE_YEAR = 2 }; enum GDateWeekday { 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 }; enum GDateMonth { 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 }; struct _GDate { guint julian_days; guint julian; guint dmy; guint day; guint month; guint year; } GDate* g_date_new (); 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_get_weekday ( GDate *date); GDateMonth g_date_get_month ( GDate *date); GDateYear g_date_get_year ( GDate *date); GDateDay g_date_get_day ( GDate *date); guint32 g_date_get_julian ( GDate *date); guint g_date_get_day_of_year ( GDate *date); guint g_date_get_monday_week_of_year ( GDate *date); guint g_date_get_sunday_week_of_year ( GDate *date); void g_date_clear (GDate *date, guint n_dates); void g_date_set_parse (GDate *date, 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_get_days_in_month (GDateMonth month, GDateYear year) ; guint8 g_date_get_monday_weeks_in_year (GDateYear year) ; guint8 g_date_get_sunday_weeks_in_year (GDateYear year) ; gint g_date_days_between ( GDate *date1, GDate *date2); gint g_date_compare ( GDate *lhs, GDate *rhs); void g_date_to_struct_tm ( GDate *date, void* tm); void g_date_clamp (GDate *date, GDate *min_date, GDate *max_date); void g_date_order (GDate *date1, GDate *date2); gsize g_date_strftime (gchar *s, gsize slen, gchar *format, GDate *date); alias _GDir GDir; alias void _GDir; GDir * g_dir_open ( gchar *path, guint flags, GError **error); gchar *g_dir_read_name (GDir *dir); void g_dir_rewind (GDir *dir); void g_dir_close (GDir *dir); enum GFileError { G_FILE_ERROR_EXIST, G_FILE_ERROR_ISDIR, G_FILE_ERROR_ACCES, G_FILE_ERROR_NAMETOOLONG, G_FILE_ERROR_NOENT, G_FILE_ERROR_NOTDIR, G_FILE_ERROR_NXIO, G_FILE_ERROR_NODEV, G_FILE_ERROR_ROFS, G_FILE_ERROR_TXTBSY, G_FILE_ERROR_FAULT, G_FILE_ERROR_LOOP, G_FILE_ERROR_NOSPC, G_FILE_ERROR_NOMEM, G_FILE_ERROR_MFILE, G_FILE_ERROR_NFILE, G_FILE_ERROR_BADF, G_FILE_ERROR_INVAL, G_FILE_ERROR_PIPE, G_FILE_ERROR_AGAIN, G_FILE_ERROR_INTR, G_FILE_ERROR_IO, G_FILE_ERROR_PERM, G_FILE_ERROR_FAILED }; enum GFileTest { G_FILE_TEST_IS_REGULAR = 1 << 0, G_FILE_TEST_IS_SYMLINK = 1 << 1, G_FILE_TEST_IS_DIR = 1 << 2, G_FILE_TEST_IS_EXECUTABLE = 1 << 3, G_FILE_TEST_EXISTS = 1 << 4 }; GQuark g_file_error_quark (); GFileError g_file_error_from_errno (gint err_no); gboolean g_file_test ( gchar *filename, GFileTest test); gboolean g_file_get_contents ( gchar *filename, gchar **contents, gsize *length, GError **error); gchar *g_file_read_link ( gchar *filename, GError **error); gint g_mkstemp (gchar *tmpl); gint g_file_open_tmp ( gchar *tmpl, gchar **name_used, GError **error); gchar *g_build_path ( gchar *separator, gchar *first_element, ...); gchar *g_build_filename ( gchar *first_element, ...); alias _GHashTable GHashTable; alias void _GHashTable; alias gboolean (*GHRFunc) (gpointer key, gpointer value, gpointer user_data); GHashTable* g_hash_table_new (GHashFunc hash_func, GEqualFunc key_equal_func); GHashTable* g_hash_table_new_full (GHashFunc hash_func, GEqualFunc key_equal_func, GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_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_replace (GHashTable *hash_table, gpointer key, gpointer value); gboolean g_hash_table_remove (GHashTable *hash_table, gpointer key); gboolean g_hash_table_steal (GHashTable *hash_table, gpointer key); gpointer g_hash_table_lookup (GHashTable *hash_table, gpointer key); gboolean g_hash_table_lookup_extended (GHashTable *hash_table, gpointer lookup_key, gpointer *orig_key, gpointer *value); void g_hash_table_foreach (GHashTable *hash_table, GHFunc func, gpointer user_data); gpointer g_hash_table_find (GHashTable *hash_table, GHRFunc predicate, gpointer user_data); guint g_hash_table_foreach_remove (GHashTable *hash_table, GHRFunc func, gpointer user_data); guint g_hash_table_foreach_steal (GHashTable *hash_table, GHRFunc func, gpointer user_data); guint g_hash_table_size (GHashTable *hash_table); gboolean g_str_equal (gpointer v, gpointer v2); guint g_str_hash (gpointer v); gboolean g_int_equal (gpointer v, gpointer v2); guint g_int_hash (gpointer v); guint g_direct_hash (gpointer v) ; gboolean g_direct_equal (gpointer v, gpointer v2) ; alias _GHook GHook; alias _GHookList GHookList; alias gint (*GHookCompareFunc) (GHook *new_hook, GHook *sibling); alias gboolean (*GHookFindFunc) (GHook *hook, gpointer data); alias void (*GHookMarshaller) (GHook *hook, gpointer marshal_data); alias gboolean (*GHookCheckMarshaller) (GHook *hook, gpointer marshal_data); alias void (*GHookFunc) (gpointer data); alias gboolean (*GHookCheckFunc) (gpointer data); alias void (*GHookFinalizeFunc) (GHookList *hook_list, GHook *hook); enum GHookFlagMask { G_HOOK_FLAG_ACTIVE = 1 << 0, G_HOOK_FLAG_IN_CALL = 1 << 1, G_HOOK_FLAG_MASK = 0x0f }; struct _GHookList { gulong seq_id; guint hook_size; guint is_setup; GHook *hooks; GMemChunk *hook_memchunk; GHookFinalizeFunc finalize_hook; gpointer dummy[2]; } struct _GHook { gpointer data; GHook *next; GHook *prev; guint ref_count; gulong hook_id; guint flags; gpointer func; GDestroyNotify destroy; } 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, gulong 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, gulong 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 marshal_data); void g_hook_list_marshal_check (GHookList *hook_list, gboolean may_recurse, GHookCheckMarshaller marshaller, gpointer marshal_data); alias _GSList GSList; struct _GSList { gpointer data; GSList *next; } void g_slist_push_allocator (GAllocator *allocator); void g_slist_pop_allocator (); GSList* g_slist_alloc (); 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_insert_before (GSList *slist, GSList *sibling, gpointer data); GSList* g_slist_concat (GSList *list1, GSList *list2); GSList* g_slist_remove (GSList *list, gpointer data); GSList* g_slist_remove_all (GSList *list, gpointer data); GSList* g_slist_remove_link (GSList *list, GSList *link_); GSList* g_slist_delete_link (GSList *list, GSList *link_); 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); GSList* g_slist_sort_with_data (GSList *list, GCompareDataFunc compare_func, gpointer user_data); gpointer g_slist_nth_data (GSList *list, guint n); alias _GMainContext GMainContext; alias void _GMainContext; alias _GMainLoop GMainLoop; alias void _GMainLoop; alias _GSource GSource; alias _GSourceCallbackFuncs GSourceCallbackFuncs; alias _GSourceFuncs GSourceFuncs; alias gboolean (*GSourceFunc) (gpointer data); alias void (*GChildWatchFunc) (GPid pid, gint status, gpointer data); struct _GSource { gpointer callback_data; GSourceCallbackFuncs *callback_funcs; GSourceFuncs *source_funcs; guint ref_count; GMainContext *context; gint priority; guint flags; guint source_id; GSList *poll_fds; GSource *prev; GSource *next; gpointer reserved1; gpointer reserved2; } struct _GSourceCallbackFuncs { void (*_ref) (gpointer cb_data); void (*unref) (gpointer cb_data); void (*get) (gpointer cb_data, GSource *source, GSourceFunc *func, gpointer *data); } alias void (*GSourceDummyMarshal) (); struct _GSourceFuncs { gboolean (*prepare) (GSource *source, gint *timeout_); gboolean (*check) (GSource *source); gboolean (*dispatch) (GSource *source, GSourceFunc callback, gpointer user_data); void (*finalize) (GSource *source); GSourceFunc closure_callback; GSourceDummyMarshal closure_marshal; } alias _GPollFD GPollFD; alias gint (*GPollFunc) (GPollFD *ufds, guint nfsd, gint timeout_); struct _GPollFD { gint fd; gushort events; gushort revents; } GMainContext *g_main_context_new (); void g_main_context_ref (GMainContext *context); void g_main_context_unref (GMainContext *context); GMainContext *g_main_context_default (); gboolean g_main_context_iteration (GMainContext *context, gboolean may_block); gboolean g_main_context_pending (GMainContext *context); GSource *g_main_context_find_source_by_id (GMainContext *context, guint source_id); GSource *g_main_context_find_source_by_user_data (GMainContext *context, gpointer user_data); GSource *g_main_context_find_source_by_funcs_user_data (GMainContext *context, GSourceFuncs *funcs, gpointer user_data); void g_main_context_wakeup (GMainContext *context); gboolean g_main_context_acquire (GMainContext *context); void g_main_context_release (GMainContext *context); gboolean g_main_context_wait (GMainContext *context, GCond *cond, GMutex *mutex); gboolean g_main_context_prepare (GMainContext *context, gint *priority); gint g_main_context_query (GMainContext *context, gint max_priority, gint *timeout_, GPollFD *fds, gint n_fds); gint g_main_context_check (GMainContext *context, gint max_priority, GPollFD *fds, gint n_fds); void g_main_context_dispatch (GMainContext *context); void g_main_context_set_poll_func (GMainContext *context, GPollFunc func); GPollFunc g_main_context_get_poll_func (GMainContext *context); void g_main_context_add_poll (GMainContext *context, GPollFD *fd, gint priority); void g_main_context_remove_poll (GMainContext *context, GPollFD *fd); int g_main_depth (); GMainLoop *g_main_loop_new (GMainContext *context, gboolean is_running); void g_main_loop_run (GMainLoop *loop); void g_main_loop_quit (GMainLoop *loop); GMainLoop *g_main_loop_ref (GMainLoop *loop); void g_main_loop_unref (GMainLoop *loop); gboolean g_main_loop_is_running (GMainLoop *loop); GMainContext *g_main_loop_get_context (GMainLoop *loop); GSource *g_source_new (GSourceFuncs *source_funcs); GSource *g_source_ref (GSource *source); void g_source_unref (GSource *source); guint g_source_attach (GSource *source, GMainContext *context); void g_source_destroy (GSource *source); void g_source_set_priority (GSource *source, gint priority); gint g_source_get_priority (GSource *source); void g_source_set_can_recurse (GSource *source, gboolean can_recurse); gboolean g_source_get_can_recurse (GSource *source); guint g_source_get_id (GSource *source); GMainContext *g_source_get_context (GSource *source); void g_source_set_callback (GSource *source, GSourceFunc func, gpointer data, GDestroyNotify notify); void g_source_set_callback_indirect (GSource *source, gpointer callback_data, GSourceCallbackFuncs *callback_funcs); void g_source_add_poll (GSource *source, GPollFD *fd); void g_source_remove_poll (GSource *source, GPollFD *fd); void g_source_get_current_time (GSource *source, GTimeVal *timeval); GSource *g_idle_source_new (); GSource *g_child_watch_source_new (GPid pid); GSource *g_timeout_source_new (guint interval); void g_get_current_time (GTimeVal *result); gboolean g_source_remove (guint tag); gboolean g_source_remove_by_user_data (gpointer user_data); gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs, gpointer user_data); 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_child_watch_add_full (gint priority, GPid pid, GChildWatchFunc Function, gpointer data, GDestroyNotify notify); guint g_child_watch_add (GPid pid, GChildWatchFunc Function, gpointer data); guint g_idle_add (GSourceFunc Function, gpointer data); guint g_idle_add_full (gint priority, GSourceFunc Function, gpointer data, GDestroyNotify notify); gboolean g_idle_remove_by_data (gpointer data); GSourceFuncs g_timeout_funcs; GSourceFuncs g_child_watch_funcs; GSourceFuncs g_idle_funcs; alias guint32 gunichar; alias guint16 gunichar2; enum GUnicodeType { G_UNICODE_CONTROL, G_UNICODE_FORMAT, G_UNICODE_UNASSIGNED, G_UNICODE_PRIVATE_USE, G_UNICODE_SURROGATE, G_UNICODE_LOWERCASE_LETTER, G_UNICODE_MODIFIER_LETTER, G_UNICODE_OTHER_LETTER, G_UNICODE_TITLECASE_LETTER, G_UNICODE_UPPERCASE_LETTER, G_UNICODE_COMBINING_MARK, G_UNICODE_ENCLOSING_MARK, G_UNICODE_NON_SPACING_MARK, G_UNICODE_DECIMAL_NUMBER, G_UNICODE_LETTER_NUMBER, G_UNICODE_OTHER_NUMBER, G_UNICODE_CONNECT_PUNCTUATION, G_UNICODE_DASH_PUNCTUATION, G_UNICODE_CLOSE_PUNCTUATION, G_UNICODE_FINAL_PUNCTUATION, G_UNICODE_INITIAL_PUNCTUATION, G_UNICODE_OTHER_PUNCTUATION, G_UNICODE_OPEN_PUNCTUATION, G_UNICODE_CURRENCY_SYMBOL, G_UNICODE_MODIFIER_SYMBOL, G_UNICODE_MATH_SYMBOL, G_UNICODE_OTHER_SYMBOL, G_UNICODE_LINE_SEPARATOR, G_UNICODE_PARAGRAPH_SEPARATOR, G_UNICODE_SPACE_SEPARATOR }; enum GUnicodeBreakType { G_UNICODE_BREAK_MANDATORY, G_UNICODE_BREAK_CARRIAGE_RETURN, G_UNICODE_BREAK_LINE_FEED, G_UNICODE_BREAK_COMBINING_MARK, G_UNICODE_BREAK_SURROGATE, G_UNICODE_BREAK_ZERO_WIDTH_SPACE, G_UNICODE_BREAK_INSEPARABLE, G_UNICODE_BREAK_NON_BREAKING_GLUE, G_UNICODE_BREAK_CONTINGENT, G_UNICODE_BREAK_SPACE, G_UNICODE_BREAK_AFTER, G_UNICODE_BREAK_BEFORE, G_UNICODE_BREAK_BEFORE_AND_AFTER, G_UNICODE_BREAK_HYPHEN, G_UNICODE_BREAK_NON_STARTER, G_UNICODE_BREAK_OPEN_PUNCTUATION, G_UNICODE_BREAK_CLOSE_PUNCTUATION, G_UNICODE_BREAK_QUOTATION, G_UNICODE_BREAK_EXCLAMATION, G_UNICODE_BREAK_IDEOGRAPHIC, G_UNICODE_BREAK_NUMERIC, G_UNICODE_BREAK_INFIX_SEPARATOR, G_UNICODE_BREAK_SYMBOL, G_UNICODE_BREAK_ALPHABETIC, G_UNICODE_BREAK_PREFIX, G_UNICODE_BREAK_POSTFIX, G_UNICODE_BREAK_COMPLEX_CONTEXT, G_UNICODE_BREAK_AMBIGUOUS, G_UNICODE_BREAK_UNKNOWN, G_UNICODE_BREAK_NEXT_LINE, G_UNICODE_BREAK_WORD_JOINER }; gboolean g_get_charset ( char **charset); gboolean g_unichar_isalnum (gunichar c) ; gboolean g_unichar_isalpha (gunichar c) ; gboolean g_unichar_iscntrl (gunichar c) ; gboolean g_unichar_isdigit (gunichar c) ; gboolean g_unichar_isgraph (gunichar c) ; gboolean g_unichar_islower (gunichar c) ; gboolean g_unichar_isprint (gunichar c) ; gboolean g_unichar_ispunct (gunichar c) ; gboolean g_unichar_isspace (gunichar c) ; gboolean g_unichar_isupper (gunichar c) ; gboolean g_unichar_isxdigit (gunichar c) ; gboolean g_unichar_istitle (gunichar c) ; gboolean g_unichar_isdefined (gunichar c) ; gboolean g_unichar_iswide (gunichar c) ; gunichar g_unichar_toupper (gunichar c) ; gunichar g_unichar_tolower (gunichar c) ; gunichar g_unichar_totitle (gunichar c) ; gint g_unichar_digit_value (gunichar c) ; gint g_unichar_xdigit_value (gunichar c) ; GUnicodeType g_unichar_type (gunichar c) ; GUnicodeBreakType g_unichar_break_type (gunichar c) ; void g_unicode_canonical_ordering (gunichar *string, gsize len); gunichar *g_unicode_canonical_decomposition (gunichar ch, gsize *result_len); gchar * g_utf8_skip; gunichar g_utf8_get_char ( gchar *p); gunichar g_utf8_get_char_validated ( gchar *p, gssize max_len); gchar* g_utf8_offset_to_pointer ( gchar *str, glong offset); glong g_utf8_pointer_to_offset ( gchar *str, gchar *pos); gchar* g_utf8_prev_char ( gchar *p); gchar* g_utf8_find_next_char ( gchar *p, gchar *end); gchar* g_utf8_find_prev_char ( gchar *str, gchar *p); glong g_utf8_strlen ( gchar *p, gssize max); gchar* g_utf8_strncpy (gchar *dest, gchar *src, gsize n); gchar* g_utf8_strchr ( gchar *p, gssize len, gunichar c); gchar* g_utf8_strrchr ( gchar *p, gssize len, gunichar c); gchar* g_utf8_strreverse ( gchar *str, gssize len); gunichar2 *g_utf8_to_utf16 ( gchar *str, glong len, glong *items_read, glong *items_written, GError **error); gunichar * g_utf8_to_ucs4 ( gchar *str, glong len, glong *items_read, glong *items_written, GError **error); gunichar * g_utf8_to_ucs4_fast ( gchar *str, glong len, glong *items_written); gunichar * g_utf16_to_ucs4 ( gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error); gchar* g_utf16_to_utf8 ( gunichar2 *str, glong len, glong *items_read, glong *items_written, GError **error); gunichar2 *g_ucs4_to_utf16 ( gunichar *str, glong len, glong *items_read, glong *items_written, GError **error); gchar* g_ucs4_to_utf8 ( gunichar *str, glong len, glong *items_read, glong *items_written, GError **error); gint g_unichar_to_utf8 (gunichar c, gchar *outbuf); gboolean g_utf8_validate ( gchar *str, gssize max_len, gchar **end); gboolean g_unichar_validate (gunichar ch); gchar *g_utf8_strup ( gchar *str, gssize len); gchar *g_utf8_strdown ( gchar *str, gssize len); gchar *g_utf8_casefold ( gchar *str, gssize len); enum GNormalizeMode { G_NORMALIZE_DEFAULT, G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT, G_NORMALIZE_DEFAULT_COMPOSE, G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE, G_NORMALIZE_ALL, G_NORMALIZE_NFKD = G_NORMALIZE_ALL, G_NORMALIZE_ALL_COMPOSE, G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE }; gchar *g_utf8_normalize ( gchar *str, gssize len, GNormalizeMode mode); gint g_utf8_collate ( gchar *str1, gchar *str2); gchar *g_utf8_collate_key ( gchar *str, gssize len); gboolean g_unichar_get_mirror_char (gunichar ch, gunichar *mirrored_ch); //alias __builtin_va_list __gnuc_va_list; alias void* va_list; gchar* g_get_user_name (); gchar* g_get_real_name (); gchar* g_get_home_dir (); gchar* g_get_tmp_dir (); gchar* g_get_prgname (); void g_set_prgname ( gchar *prgname); gchar* g_get_application_name (); void g_set_application_name ( gchar *application_name); alias _GDebugKey GDebugKey; struct _GDebugKey { gchar *key; guint value; } guint g_parse_debug_string ( gchar *string, GDebugKey *keys, guint nkeys); gint g_snprintf (gchar *string, gulong n, gchar *format, ...) ; gint g_vsnprintf (gchar *string, gulong n, gchar *format, va_list args); gboolean g_path_is_absolute ( gchar *file_name); gchar* g_path_skip_root ( gchar *file_name); gchar* g_basename ( gchar *file_name); gchar* g_get_current_dir (); gchar* g_path_get_basename ( gchar *file_name); gchar* g_path_get_dirname ( gchar *file_name); void g_nullify_pointer (gpointer *nullify_location); gchar* g_getenv ( gchar *variable); gboolean g_setenv ( gchar *variable, gchar *value, gboolean overwrite); void g_unsetenv ( gchar *variable); alias void (*GVoidFunc) (); void g_atexit (GVoidFunc func); gchar* g_find_program_in_path ( gchar *program); gint g_bit_nth_lsf (gulong mask, gint nth_bit); gint g_bit_nth_msf (gulong mask, gint nth_bit); guint g_bit_storage (gulong number); alias _GTrashStack GTrashStack; struct _GTrashStack { GTrashStack *next; } void g_trash_stack_push (GTrashStack **stack_p, gpointer data_p); gpointer g_trash_stack_pop (GTrashStack **stack_p); gpointer g_trash_stack_peek (GTrashStack **stack_p); guint g_trash_stack_height (GTrashStack **stack_p); guint glib_major_version; guint glib_minor_version; guint glib_micro_version; guint glib_interface_age; guint glib_binary_age; alias _GString GString; alias _GStringChunk GStringChunk; alias void _GStringChunk; struct _GString { gchar *str; gsize len; gsize allocated_len; } GStringChunk* g_string_chunk_new (gsize size); void g_string_chunk_free (GStringChunk *chunk); gchar* g_string_chunk_insert (GStringChunk *chunk, gchar *string); gchar* g_string_chunk_insert_len (GStringChunk *chunk, gchar *string, gssize len); gchar* g_string_chunk_insert_ (GStringChunk *chunk, gchar *string); GString* g_string_new ( gchar *init); GString* g_string_new_len ( gchar *init, gssize len); GString* g_string_sized_new (gsize dfl_size); gchar* g_string_free (GString *string, gboolean free_segment); gboolean g_string_equal ( GString *v, GString *v2); guint g_string_hash ( GString *str); GString* g_string_assign (GString *string, gchar *rval); GString* g_string_truncate (GString *string, gsize len); GString* g_string_set_size (GString *string, gsize len); GString* g_string_insert_len (GString *string, gssize pos, gchar *val, gssize len); GString* g_string_append (GString *string, gchar *val); GString* g_string_append_len (GString *string, gchar *val, gssize len); GString* g_string_append_c (GString *string, gchar c); GString* g_string_append_unichar (GString *string, gunichar wc); GString* g_string_prepend (GString *string, gchar *val); GString* g_string_prepend_c (GString *string, gchar c); GString* g_string_prepend_unichar (GString *string, gunichar wc); GString* g_string_prepend_len (GString *string, gchar *val, gssize len); GString* g_string_insert (GString *string, gssize pos, gchar *val); GString* g_string_insert_c (GString *string, gssize pos, gchar c); GString* g_string_insert_unichar (GString *string, gssize pos, gunichar wc); GString* g_string_erase (GString *string, gssize pos, gssize len); GString* g_string_ascii_down (GString *string); GString* g_string_ascii_up (GString *string); void g_string_printf (GString *string, gchar *format, ...) ; void g_string_append_printf (GString *string, gchar *format, ...) ; GString* g_string_down (GString *string); GString* g_string_up (GString *string); alias _GIOChannel GIOChannel; alias _GIOFuncs GIOFuncs; enum GIOError { G_IO_ERROR_NONE, G_IO_ERROR_AGAIN, G_IO_ERROR_INVAL, G_IO_ERROR_UNKNOWN }; enum GIOChannelError { G_IO_CHANNEL_ERROR_FBIG, G_IO_CHANNEL_ERROR_INVAL, G_IO_CHANNEL_ERROR_IO, G_IO_CHANNEL_ERROR_ISDIR, G_IO_CHANNEL_ERROR_NOSPC, G_IO_CHANNEL_ERROR_NXIO, G_IO_CHANNEL_ERROR_OVERFLOW, G_IO_CHANNEL_ERROR_PIPE, G_IO_CHANNEL_ERROR_FAILED }; enum GIOStatus { G_IO_STATUS_ERROR, G_IO_STATUS_NORMAL, G_IO_STATUS_EOF, G_IO_STATUS_AGAIN }; enum GSeekType { G_SEEK_CUR, G_SEEK_SET, G_SEEK_END }; enum GIOCondition { G_IO_IN =1, G_IO_OUT =4, G_IO_PRI =2, G_IO_ERR =8, G_IO_HUP =16, G_IO_NVAL =32 }; enum GIOFlags { G_IO_FLAG_APPEND = 1 << 0, G_IO_FLAG_NONBLOCK = 1 << 1, G_IO_FLAG_IS_READABLE = 1 << 2, G_IO_FLAG_IS_WRITEABLE = 1 << 3, G_IO_FLAG_IS_SEEKABLE = 1 << 4, G_IO_FLAG_MASK = (1 << 5) - 1, G_IO_FLAG_GET_MASK = G_IO_FLAG_MASK, G_IO_FLAG_SET_MASK = G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK }; struct _GIOChannel { guint ref_count; GIOFuncs *funcs; gchar *encoding; GIConv read_cd; GIConv write_cd; gchar *line_term; guint line_term_len; gsize buf_size; GString *read_buf; GString *encoded_read_buf; GString *write_buf; gchar partial_write_buf[6]; guint use_buffer; guint do_encode; guint close_on_unref; guint is_readable; guint is_writeable; guint is_seekable; gpointer reserved1; gpointer reserved2; } alias gboolean (*GIOFunc) (GIOChannel *source, GIOCondition condition, gpointer data); struct _GIOFuncs { GIOStatus (*io_read) (GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_read, GError **err); GIOStatus (*io_write) (GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_written, GError **err); GIOStatus (*io_seek) (GIOChannel *channel, gint64 offset, GSeekType type, GError **err); GIOStatus (*io_close) (GIOChannel *channel, GError **err); GSource* (*io_create_watch) (GIOChannel *channel, GIOCondition condition); void (*io_free) (GIOChannel *channel); GIOStatus (*io_set_flags) (GIOChannel *channel, GIOFlags flags, GError **err); GIOFlags (*io_get_flags) (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, gsize count, gsize *bytes_read); GIOError g_io_channel_write (GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_written); GIOError g_io_channel_seek (GIOChannel *channel, gint64 offset, GSeekType type); void g_io_channel_close (GIOChannel *channel); GIOStatus g_io_channel_shutdown (GIOChannel *channel, gboolean flush, GError **err); guint g_io_add_watch_full (GIOChannel *channel, gint priority, GIOCondition condition, GIOFunc func, gpointer user_data, GDestroyNotify notify); GSource * g_io_create_watch (GIOChannel *channel, GIOCondition condition); guint g_io_add_watch (GIOChannel *channel, GIOCondition condition, GIOFunc func, gpointer user_data); void g_io_channel_set_buffer_size (GIOChannel *channel, gsize size); gsize g_io_channel_get_buffer_size (GIOChannel *channel); GIOCondition g_io_channel_get_buffer_condition (GIOChannel *channel); GIOStatus g_io_channel_set_flags (GIOChannel *channel, GIOFlags flags, GError **error); GIOFlags g_io_channel_get_flags (GIOChannel *channel); void g_io_channel_set_line_term (GIOChannel *channel, gchar *line_term, gint length); gchar* g_io_channel_get_line_term (GIOChannel *channel, gint *length); void g_io_channel_set_buffered (GIOChannel *channel, gboolean buffered); gboolean g_io_channel_get_buffered (GIOChannel *channel); GIOStatus g_io_channel_set_encoding (GIOChannel *channel, gchar *encoding, GError **error); gchar* g_io_channel_get_encoding (GIOChannel *channel); void g_io_channel_set_close_on_unref (GIOChannel *channel, gboolean do_close); gboolean g_io_channel_get_close_on_unref (GIOChannel *channel); GIOStatus g_io_channel_flush (GIOChannel *channel, GError **error); GIOStatus g_io_channel_read_line (GIOChannel *channel, gchar **str_return, gsize *length, gsize *terminator_pos, GError **error); GIOStatus g_io_channel_read_line_string (GIOChannel *channel, GString *buffer, gsize *terminator_pos, GError **error); GIOStatus g_io_channel_read_to_end (GIOChannel *channel, gchar **str_return, gsize *length, GError **error); GIOStatus g_io_channel_read_chars (GIOChannel *channel, gchar *buf, gsize count, gsize *bytes_read, GError **error); GIOStatus g_io_channel_read_unichar (GIOChannel *channel, gunichar *thechar, GError **error); GIOStatus g_io_channel_write_chars (GIOChannel *channel, gchar *buf, gssize count, gsize *bytes_written, GError **error); GIOStatus g_io_channel_write_unichar (GIOChannel *channel, gunichar thechar, GError **error); GIOStatus g_io_channel_seek_position (GIOChannel *channel, gint64 offset, GSeekType type, GError **error); GIOChannel* g_io_channel_new_file ( gchar *filename, gchar *mode, GError **error); GQuark g_io_channel_error_quark (); GIOChannelError g_io_channel_error_from_errno (gint en); GIOChannel* g_io_channel_unix_new (int fd); gint g_io_channel_unix_get_fd (GIOChannel *channel); GSourceFuncs g_io_watch_funcs; enum GMarkupError { G_MARKUP_ERROR_BAD_UTF8, G_MARKUP_ERROR_EMPTY, G_MARKUP_ERROR_PARSE, G_MARKUP_ERROR_UNKNOWN_ELEMENT, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, G_MARKUP_ERROR_INVALID_CONTENT }; GQuark g_markup_error_quark (); enum GMarkupParseFlags { G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0 }; alias _GMarkupParseContext GMarkupParseContext; alias void _GMarkupParseContext; alias _GMarkupParser GMarkupParser; struct _GMarkupParser { void (*start_element) (GMarkupParseContext *context, gchar *element_name, gchar **attribute_names, gchar **attribute_values, gpointer user_data, GError **error); void (*end_element) (GMarkupParseContext *context, gchar *element_name, gpointer user_data, GError **error); void (*text) (GMarkupParseContext *context, gchar *text, gsize text_len, gpointer user_data, GError **error); void (*passthrough) (GMarkupParseContext *context, gchar *passthrough_text, gsize text_len, gpointer user_data, GError **error); void (*error) (GMarkupParseContext *context, GError *error, gpointer user_data); } GMarkupParseContext *g_markup_parse_context_new ( GMarkupParser *parser, GMarkupParseFlags flags, gpointer user_data, GDestroyNotify user_data_dnotify); void g_markup_parse_context_free (GMarkupParseContext *context); gboolean g_markup_parse_context_parse (GMarkupParseContext *context, gchar *text, gssize text_len, GError **error); gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context, GError **error); gchar *g_markup_parse_context_get_element (GMarkupParseContext *context); void g_markup_parse_context_get_position (GMarkupParseContext *context, gint *line_number, gint *char_number); gchar* g_markup_escape_text ( gchar *text, gssize length); gchar *g_markup_printf_escaped ( char *format, ...) ; gchar *g_markup_vprintf_escaped ( char *format, va_list args); gsize g_printf_string_upper_bound ( gchar* format, va_list args); enum GLogLevelFlags { 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) }; alias void (*GLogFunc) (gchar *log_domain, GLogLevelFlags log_level, gchar *message, gpointer user_data); guint g_log_set_handler ( gchar *log_domain, GLogLevelFlags log_levels, GLogFunc log_func, gpointer user_data); void g_log_remove_handler ( gchar *log_domain, guint handler_id); void g_log_default_handler ( gchar *log_domain, GLogLevelFlags log_level, gchar *message, gpointer unused_data); void g_log ( gchar *log_domain, GLogLevelFlags log_level, gchar *format, ...) ; void g_logv ( gchar *log_domain, GLogLevelFlags log_level, gchar *format, va_list args); GLogLevelFlags g_log_set_fatal_mask ( gchar *log_domain, GLogLevelFlags fatal_mask); GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask); void _g_log_fallback_handler ( gchar *log_domain, GLogLevelFlags log_level, gchar *message, gpointer unused_data); alias void (*GPrintFunc) (gchar *string); void g_print ( gchar *format, ...) ; GPrintFunc g_set_print_handler (GPrintFunc func); void g_printerr ( gchar *format, ...) ; GPrintFunc g_set_printerr_handler (GPrintFunc func); alias _GNode GNode; enum GTraverseFlags { 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 }; enum GTraverseType { G_IN_ORDER, G_PRE_ORDER, G_POST_ORDER, G_LEVEL_ORDER }; alias gboolean (*GNodeTraverseFunc) (GNode *node, gpointer data); alias void (*GNodeForeachFunc) (GNode *node, gpointer data); alias gpointer (*GCopyFunc) (gpointer src, gpointer data); struct _GNode { gpointer data; GNode *next; GNode *prev; GNode *parent; GNode *children; } void g_node_push_allocator (GAllocator *allocator); void g_node_pop_allocator (); GNode* g_node_new (gpointer data); void g_node_destroy (GNode *root); void g_node_unlink (GNode *node); GNode* g_node_copy_deep (GNode *node, GCopyFunc copy_func, gpointer data); GNode* g_node_copy (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_insert_after (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); 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); alias _GPatternSpec GPatternSpec; alias void _GPatternSpec; GPatternSpec* g_pattern_spec_new ( gchar *pattern); void g_pattern_spec_free (GPatternSpec *pspec); gboolean g_pattern_spec_equal (GPatternSpec *pspec1, GPatternSpec *pspec2); gboolean g_pattern_match (GPatternSpec *pspec, guint string_length, gchar *string, gchar *string_reversed); gboolean g_pattern_match_string (GPatternSpec *pspec, gchar *string); gboolean g_pattern_match_simple ( gchar *pattern, gchar *string); guint g_spaced_primes_closest (guint num) ; void g_qsort_with_data (gpointer pbase, gint total_elems, gsize size, GCompareDataFunc compare_func, gpointer user_data); alias _GQueue GQueue; struct _GQueue { GList *head; GList *tail; guint length; } GQueue* g_queue_new (); void g_queue_free (GQueue *queue); gboolean g_queue_is_empty (GQueue *queue); guint g_queue_get_length (GQueue *queue); void g_queue_reverse (GQueue *queue); GQueue * g_queue_copy (GQueue *queue); void g_queue_foreach (GQueue *queue, GFunc func, gpointer user_data); GList * g_queue_find (GQueue *queue, gpointer data); GList * g_queue_find_custom (GQueue *queue, gpointer data, GCompareFunc func); void g_queue_sort (GQueue *queue, GCompareDataFunc compare_func, gpointer user_data); void g_queue_push_head (GQueue *queue, gpointer data); void g_queue_push_tail (GQueue *queue, gpointer data); void g_queue_push_nth (GQueue *queue, gpointer data, gint n); gpointer g_queue_pop_head (GQueue *queue); gpointer g_queue_pop_tail (GQueue *queue); gpointer g_queue_pop_nth (GQueue *queue, guint n); gpointer g_queue_peek_head (GQueue *queue); gpointer g_queue_peek_tail (GQueue *queue); gpointer g_queue_peek_nth (GQueue *queue, guint n); gint g_queue_index (GQueue *queue, gpointer data); void g_queue_remove (GQueue *queue, gpointer data); void g_queue_remove_all (GQueue *queue, gpointer data); void g_queue_insert_before (GQueue *queue, GList *sibling, gpointer data); void g_queue_insert_after (GQueue *queue, GList *sibling, gpointer data); void g_queue_insert_sorted (GQueue *queue, gpointer data, GCompareDataFunc func, gpointer user_data); void g_queue_push_head_link (GQueue *queue, GList *link_); void g_queue_push_tail_link (GQueue *queue, GList *link_); void g_queue_push_nth_link (GQueue *queue, gint n, GList *link_); GList* g_queue_pop_head_link (GQueue *queue); GList* g_queue_pop_tail_link (GQueue *queue); GList* g_queue_pop_nth_link (GQueue *queue, guint n); GList* g_queue_peek_head_link (GQueue *queue); GList* g_queue_peek_tail_link (GQueue *queue); GList* g_queue_peek_nth_link (GQueue *queue, guint n); gint g_queue_link_index (GQueue *queue, GList *link_); void g_queue_unlink (GQueue *queue, GList *link_); void g_queue_delete_link (GQueue *queue, GList *link_); alias _GRand GRand; alias void _GRand; GRand* g_rand_new_with_seed (guint32 seed); GRand* g_rand_new_with_seed_array ( guint32 *seed, guint seed_length); GRand* g_rand_new (); void g_rand_free (GRand *rand_); GRand* g_rand_copy (GRand *rand_); void g_rand_set_seed (GRand *rand_, guint32 seed); void g_rand_set_seed_array (GRand *rand_, guint32 *seed, guint seed_length); guint32 g_rand_int (GRand *rand_); gint32 g_rand_int_range (GRand *rand_, gint32 begin, gint32 end); gdouble g_rand_double (GRand *rand_); gdouble g_rand_double_range (GRand *rand_, gdouble begin, gdouble end); void g_random_set_seed (guint32 seed); guint32 g_random_int (); gint32 g_random_int_range (gint32 begin, gint32 end); gdouble g_random_double (); gdouble g_random_double_range (gdouble begin, gdouble end); alias _GRelation GRelation; alias void _GRelation; alias _GTuples GTuples; struct _GTuples { guint len; } GRelation* g_relation_new (gint fields); void g_relation_destroy (GRelation *relation); void g_relation_index (GRelation *relation, gint field, GHashFunc hash_func, GEqualFunc key_equal_func); void g_relation_insert (GRelation *relation, ...); gint g_relation_delete (GRelation *relation, gpointer key, gint field); GTuples* g_relation_select (GRelation *relation, gpointer key, gint field); gint g_relation_count (GRelation *relation, gpointer 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); alias _GScanner GScanner; alias _GScannerConfig GScannerConfig; alias _GTokenValue GTokenValue; alias void (*GScannerMsgFunc) (GScanner *scanner, gchar *message, gboolean error); enum GErrorType { 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 }; enum GTokenType { 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 } union _GTokenValue { gpointer v_symbol; gchar *v_identifier; gulong v_binary; gulong v_octal; gulong v_int; guint64 v_int64; 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; guint skip_comment_multi; guint skip_comment_single; guint scan_comment_multi; guint scan_identifier; guint scan_identifier_1char; guint scan_identifier_NULL; guint scan_symbols; guint scan_binary; guint scan_octal; guint scan_float; guint scan_hex; guint scan_hex_dollar; guint scan_string_sq; guint scan_string_dq; guint numbers_2_int; guint int_2_float; guint identifier_2_string; guint char_2_token; guint symbol_2_token; guint scope_0_fallback; guint store_int64; guint padding_dummy; } struct _GScanner { gpointer user_data; guint max_parse_errors; guint parse_errors; gchar *input_name; GData *qdata; 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; gchar *text; 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, 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, gchar *symbol, gpointer value); void g_scanner_scope_remove_symbol (GScanner *scanner, guint scope_id, gchar *symbol); gpointer g_scanner_scope_lookup_symbol (GScanner *scanner, guint scope_id, 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, gchar *symbol); void g_scanner_unexp_token (GScanner *scanner, GTokenType expected_token, gchar *identifier_spec, gchar *symbol_spec, gchar *symbol_name, gchar *message, gint is_error); void g_scanner_error (GScanner *scanner, gchar *format, ...) ; void g_scanner_warn (GScanner *scanner, gchar *format, ...) ; enum GShellError { G_SHELL_ERROR_BAD_QUOTING, G_SHELL_ERROR_EMPTY_STRING, G_SHELL_ERROR_FAILED }; GQuark g_shell_error_quark (); gchar* g_shell_quote ( gchar *unquoted_string); gchar* g_shell_unquote ( gchar *quoted_string, GError **error); gboolean g_shell_parse_argv ( gchar *command_line, gint *argcp, gchar ***argvp, GError **error); enum GSpawnError { G_SPAWN_ERROR_FORK, G_SPAWN_ERROR_READ, G_SPAWN_ERROR_CHDIR, G_SPAWN_ERROR_ACCES, G_SPAWN_ERROR_PERM, G_SPAWN_ERROR_2BIG, G_SPAWN_ERROR_NOEXEC, G_SPAWN_ERROR_NAMETOOLONG, G_SPAWN_ERROR_NOENT, G_SPAWN_ERROR_NOMEM, G_SPAWN_ERROR_NOTDIR, G_SPAWN_ERROR_LOOP, G_SPAWN_ERROR_TXTBUSY, G_SPAWN_ERROR_IO, G_SPAWN_ERROR_NFILE, G_SPAWN_ERROR_MFILE, G_SPAWN_ERROR_INVAL, G_SPAWN_ERROR_ISDIR, G_SPAWN_ERROR_LIBBAD, G_SPAWN_ERROR_FAILED }; alias void (* GSpawnChildSetupFunc) (gpointer user_data); enum GSpawnFlags { G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0, G_SPAWN_DO_NOT_REAP_CHILD = 1 << 1, G_SPAWN_SEARCH_PATH = 1 << 2, G_SPAWN_STDOUT_TO_DEV_NULL = 1 << 3, G_SPAWN_STDERR_TO_DEV_NULL = 1 << 4, G_SPAWN_CHILD_INHERITS_STDIN = 1 << 5, G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6 }; GQuark g_spawn_error_quark (); gboolean g_spawn_async ( gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup, gpointer user_data, GPid *child_pid, GError **error); gboolean g_spawn_async_with_pipes ( gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup, gpointer user_data, GPid *child_pid, gint *standard_input, gint *standard_output, gint *standard_error, GError **error); gboolean g_spawn_sync ( gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup, gpointer user_data, gchar **standard_output, gchar **standard_error, gint *exit_status, GError **error); gboolean g_spawn_command_line_sync ( gchar *command_line, gchar **standard_output, gchar **standard_error, gint *exit_status, GError **error); gboolean g_spawn_command_line_async ( gchar *command_line, GError **error); void g_spawn_close_pid (GPid pid); enum GAsciiType { G_ASCII_ALNUM = 1 << 0, G_ASCII_ALPHA = 1 << 1, G_ASCII_CNTRL = 1 << 2, G_ASCII_DIGIT = 1 << 3, G_ASCII_GRAPH = 1 << 4, G_ASCII_LOWER = 1 << 5, G_ASCII_PRINT = 1 << 6, G_ASCII_PUNCT = 1 << 7, G_ASCII_SPACE = 1 << 8, G_ASCII_UPPER = 1 << 9, G_ASCII_XDIGIT = 1 << 10 }; guint16 * g_ascii_table; gchar g_ascii_tolower (gchar c) ; gchar g_ascii_toupper (gchar c) ; gint g_ascii_digit_value (gchar c) ; gint g_ascii_xdigit_value (gchar c) ; gchar* g_strdelimit (gchar *string, gchar *delimiters, gchar new_delimiter); gchar* g_strcanon (gchar *string, gchar *valid_chars, gchar substitutor); gchar* g_strerror (gint errnum) ; gchar* g_strsignal (gint signum) ; gchar* g_strreverse (gchar *string); gsize g_strlcpy (gchar *dest, gchar *src, gsize dest_size); gsize g_strlcat (gchar *dest, gchar *src, gsize dest_size); gchar * g_strstr_len ( gchar *haystack, gssize haystack_len, gchar *needle); gchar * g_strrstr ( gchar *haystack, gchar *needle); gchar * g_strrstr_len ( gchar *haystack, gssize haystack_len, gchar *needle); gboolean g_str_has_suffix ( gchar *str, gchar *suffix); gboolean g_str_has_prefix ( gchar *str, gchar *prefix); gdouble g_strtod ( gchar *nptr, gchar **endptr); gdouble g_ascii_strtod ( gchar *nptr, gchar **endptr); guint64 g_ascii_strtoull ( gchar *nptr, gchar **endptr, guint base); gchar * g_ascii_dtostr (gchar *buffer, gint buf_len, gdouble d); gchar * g_ascii_formatd (gchar *buffer, gint buf_len, gchar *format, gdouble d); gchar* g_strchug (gchar *string); gchar* g_strchomp (gchar *string); gint g_ascii_strcasecmp ( gchar *s1, gchar *s2); gint g_ascii_strncasecmp ( gchar *s1, gchar *s2, gsize n); gchar* g_ascii_strdown ( gchar *str, gssize len); gchar* g_ascii_strup ( gchar *str, gssize len); gint g_strcasecmp ( gchar *s1, gchar *s2); gint g_strncasecmp ( gchar *s1, gchar *s2, guint n); gchar* g_strdown (gchar *string); gchar* g_strup (gchar *string); gchar* g_strdup ( gchar *str); gchar* g_strdup_printf ( gchar *format, ...) ; gchar* g_strdup_vprintf ( gchar *format, va_list args); gchar* g_strndup ( gchar *str, gsize n); gchar* g_strnfill (gsize length, gchar fill_char); gchar* g_strconcat ( gchar *string1, ...); gchar* g_strjoin ( gchar *separator, ...); gchar* g_strcompress ( gchar *source); gchar* g_strescape ( gchar *source, gchar *exceptions); gpointer g_memdup (gpointer mem, guint byte_size); gchar** g_strsplit ( gchar *string, gchar *delimiter, gint max_tokens); gchar ** g_strsplit_set ( gchar *string, gchar *delimiters, gint max_tokens); gchar* g_strjoinv ( gchar *separator, gchar **str_array); void g_strfreev (gchar **str_array); gchar** g_strdupv (gchar **str_array); gchar* g_stpcpy (gchar *dest, char *src); gchar *g_strip_context ( gchar *msgid, gchar *msgval); alias _GThreadPool GThreadPool; struct _GThreadPool { GFunc func; gpointer user_data; gboolean exclusive; } GThreadPool* g_thread_pool_new (GFunc func, gpointer user_data, gint max_threads, gboolean exclusive, GError **error); void g_thread_pool_push (GThreadPool *pool, gpointer data, GError **error); void g_thread_pool_set_max_threads (GThreadPool *pool, gint max_threads, GError **error); gint g_thread_pool_get_max_threads (GThreadPool *pool); guint g_thread_pool_get_num_threads (GThreadPool *pool); guint g_thread_pool_unprocessed (GThreadPool *pool); void g_thread_pool_free (GThreadPool *pool, gboolean immediate, gboolean wait); void g_thread_pool_set_max_unused_threads (gint max_threads); gint g_thread_pool_get_max_unused_threads (); guint g_thread_pool_get_num_unused_threads (); void g_thread_pool_stop_unused_threads (); alias _GTimer GTimer; alias void _GTimer; GTimer* g_timer_new (); void g_timer_destroy (GTimer *timer); void g_timer_start (GTimer *timer); void g_timer_stop (GTimer *timer); void g_timer_reset (GTimer *timer); void g_timer_continue (GTimer *timer); gdouble g_timer_elapsed (GTimer *timer, gulong *microseconds); void g_usleep (gulong microseconds); void g_time_val_add (GTimeVal *time_, glong microseconds); alias _GTree GTree; alias void _GTree; alias gboolean (*GTraverseFunc) (gpointer key, gpointer value, gpointer data); GTree* g_tree_new (GCompareFunc key_compare_func); GTree* g_tree_new_with_data (GCompareDataFunc key_compare_func, gpointer key_compare_data); GTree* g_tree_new_full (GCompareDataFunc key_compare_func, gpointer key_compare_data, GDestroyNotify key_destroy_func, GDestroyNotify value_destroy_func); void g_tree_destroy (GTree *tree); void g_tree_insert (GTree *tree, gpointer key, gpointer value); void g_tree_replace (GTree *tree, gpointer key, gpointer value); void g_tree_remove (GTree *tree, gpointer key); void g_tree_steal (GTree *tree, gpointer key); gpointer g_tree_lookup (GTree *tree, gpointer key); gboolean g_tree_lookup_extended (GTree *tree, gpointer lookup_key, gpointer *orig_key, gpointer *value); void g_tree_foreach (GTree *tree, GTraverseFunc func, gpointer user_data); void g_tree_traverse (GTree *tree, GTraverseFunc traverse_func, GTraverseType traverse_type, gpointer user_data); gpointer g_tree_search (GTree *tree, GCompareFunc search_func, gpointer user_data); gint g_tree_height (GTree *tree); gint g_tree_nnodes (GTree *tree); alias _PangoCoverage PangoCoverage; alias void _PangoCoverage; enum PangoCoverageLevel { PANGO_COVERAGE_NONE, PANGO_COVERAGE_FALLBACK, PANGO_COVERAGE_APPROXIMATE, PANGO_COVERAGE_EXACT }; PangoCoverage * pango_coverage_new (); PangoCoverage * pango_coverage_ref (PangoCoverage *coverage); void pango_coverage_unref (PangoCoverage *coverage); PangoCoverage * pango_coverage_copy (PangoCoverage *coverage); PangoCoverageLevel pango_coverage_get (PangoCoverage *coverage, int index_); void pango_coverage_set (PangoCoverage *coverage, int index_, PangoCoverageLevel level); void pango_coverage_max (PangoCoverage *coverage, PangoCoverage *other); void pango_coverage_to_bytes (PangoCoverage *coverage, guchar **bytes, int *n_bytes); PangoCoverage *pango_coverage_from_bytes (guchar *bytes, int n_bytes); alias gulong GType; alias _GValue GValue; union _GTypeCValue ; alias _GTypeCValue GTypeCValue; alias _GTypePlugin GTypePlugin; alias void _GTypePlugin; alias _GTypeClass GTypeClass; alias _GTypeInterface GTypeInterface; alias _GTypeInstance GTypeInstance; alias _GTypeInfo GTypeInfo; alias _GTypeFundamentalInfo GTypeFundamentalInfo; alias _GInterfaceInfo GInterfaceInfo; alias _GTypeValueTable GTypeValueTable; alias _GTypeQuery GTypeQuery; struct _GTypeClass { GType g_type; } struct _GTypeInstance { GTypeClass *g_class; } struct _GTypeInterface { GType g_type; GType g_instance_type; } struct _GTypeQuery { GType type; gchar *type_name; guint class_size; guint instance_size; } enum GTypeDebugFlags { G_TYPE_DEBUG_NONE = 0, G_TYPE_DEBUG_OBJECTS = 1 << 0, G_TYPE_DEBUG_SIGNALS = 1 << 1, G_TYPE_DEBUG_MASK = 0x03 }; void g_type_init (); void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags); gchar* g_type_name (GType type); GQuark g_type_qname (GType type); GType g_type_from_name ( gchar *name); GType g_type_parent (GType type); guint g_type_depth (GType type); GType g_type_next_base (GType leaf_type, GType root_type); gboolean g_type_is_a (GType type, GType is_a_type); gpointer g_type_class_ref (GType type); gpointer g_type_class_peek (GType type); gpointer g_type_class_peek_static (GType type); void g_type_class_unref (gpointer g_class); gpointer g_type_class_peek_parent (gpointer g_class); gpointer g_type_interface_peek (gpointer instanc_class, GType iface_type); gpointer g_type_interface_peek_parent (gpointer g_iface); gpointer g_type_default_interface_ref (GType g_type); gpointer g_type_default_interface_peek (GType g_type); void g_type_default_interface_unref (gpointer g_iface); GType* g_type_children (GType type, guint *n_children); GType* g_type_interfaces (GType type, guint *n_interfaces); void g_type_set_qdata (GType type, GQuark quark, gpointer data); gpointer g_type_get_qdata (GType type, GQuark quark); void g_type_query (GType type, GTypeQuery *query); alias void (*GBaseInitFunc) (gpointer g_class); alias void (*GBaseFinalizeFunc) (gpointer g_class); alias void (*GClassInitFunc) (gpointer g_class, gpointer class_data); alias void (*GClassFinalizeFunc) (gpointer g_class, gpointer class_data); alias void (*GInstanceInitFunc) (GTypeInstance *instanc, gpointer g_class); alias void (*GInterfaceInitFunc) (gpointer g_iface, gpointer iface_data); alias void (*GInterfaceFinalizeFunc) (gpointer g_iface, gpointer iface_data); alias gboolean (*GTypeClassCacheFunc) (gpointer cache_data, GTypeClass *g_class); alias void (*GTypeInterfaceCheckFunc) (gpointer func_data, gpointer g_iface); enum GTypeFundamentalFlags { G_TYPE_FLAG_CLASSED = (1 << 0), G_TYPE_FLAG_INSTANTIATABLE = (1 << 1), G_TYPE_FLAG_DERIVABLE = (1 << 2), G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3) }; enum GTypeFlags { G_TYPE_FLAG_ABSTRACT = (1 << 4), G_TYPE_FLAG_VALUE_ABSTRACT = (1 << 5) }; struct _GTypeInfo { guint16 class_size; GBaseInitFunc base_init; GBaseFinalizeFunc base_finalize; GClassInitFunc class_init; GClassFinalizeFunc class_finalize; gpointer class_data; guint16 instance_size; guint16 n_preallocs; GInstanceInitFunc instance_init; GTypeValueTable *value_table; } struct _GTypeFundamentalInfo { GTypeFundamentalFlags type_flags; } struct _GInterfaceInfo { GInterfaceInitFunc interface_init; GInterfaceFinalizeFunc interface_finalize; gpointer interface_data; } struct _GTypeValueTable { void (*value_init) (GValue *value); void (*value_free) (GValue *value); void (*value_copy) (GValue *src_value, GValue *dest_value); gpointer (*value_peek_pointer) (GValue *value); gchar *collect_format; gchar* (*collect_value) (GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags); gchar *lcopy_format; gchar* (*lcopy_value) (GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags); } GType g_type_register_static (GType parent_type, gchar *type_name, GTypeInfo *info, GTypeFlags flags); GType g_type_register_dynamic (GType parent_type, gchar *type_name, GTypePlugin *plugin, GTypeFlags flags); GType g_type_register_fundamental (GType type_id, gchar *type_name, GTypeInfo *info, GTypeFundamentalInfo *finfo, GTypeFlags flags); void g_type_add_interface_static (GType instance_type, GType interface_type, GInterfaceInfo *info); void g_type_add_interface_dynamic (GType instance_type, GType interface_type, GTypePlugin *plugin); void g_type_interface_add_prerequisite (GType interface_type, GType prerequisite_type); GType*g_type_interface_prerequisites (GType interface_type, guint *n_prerequisites); void g_type_class_add_private (gpointer g_class, gsize private_size); gpointer g_type_instance_get_private (GTypeInstance *insance, GType private_type); GTypePlugin* g_type_get_plugin (GType type); GTypePlugin* g_type_interface_get_plugin (GType instance_type, GType interface_type); GType g_type_fundamental_next (); GType g_type_fundamental (GType type_id); GTypeInstance* g_type_create_instance (GType type); void g_type_free_instance (GTypeInstance *insance); void g_type_add_class_cache_func (gpointer cache_data, GTypeClassCacheFunc cache_func); void g_type_remove_class_cache_func (gpointer cache_data, GTypeClassCacheFunc cache_func); void g_type_class_unref_uncached (gpointer g_class); void g_type_add_interface_check (gpointer check_data, GTypeInterfaceCheckFunc check_func); void g_type_remove_interface_check (gpointer check_data, GTypeInterfaceCheckFunc chec_func); GTypeValueTable* g_type_value_table_peek (GType type); gboolean g_type_check_instance (GTypeInstance *instanc); GTypeInstance* g_type_check_instance_cast (GTypeInstance *instanc, GType iface_type); gboolean g_type_check_instance_is_a (GTypeInstance *instanc, GType iface_type); GTypeClass* g_type_check_class_cast (GTypeClass *g_class, GType is_a_type); gboolean g_type_check_class_is_a (GTypeClass *g_class, GType is_a_type); gboolean g_type_check_is_value_type (GType type); gboolean g_type_check_value (GValue *value); gboolean g_type_check_value_holds (GValue *value, GType type); gboolean g_type_test_flags (GType type, guint flags); gchar* g_type_name_from_instance (GTypeInstance *instanc); gchar* g_type_name_from_class (GTypeClass *g_class); GTypeDebugFlags _g_type_debug_flags; alias gpointer (*GBoxedCopyFunc) (gpointer boxed); alias void (*GBoxedFreeFunc) (gpointer boxed); gpointer g_boxed_copy (GType boxed_type, gpointer src_boxed); void g_boxed_free (GType boxed_type, gpointer boxed); void g_value_set_boxed (GValue *value, gpointer v_boxed); void g_value_set_static_boxed (GValue *value, gpointer v_boxed); gpointer g_value_get_boxed ( GValue *value); gpointer g_value_dup_boxed ( GValue *value); GType g_boxed_type_register_static ( gchar *name, GBoxedCopyFunc boxed_copy, GBoxedFreeFunc boxed_free); void g_value_take_boxed (GValue *value, gpointer v_boxed); void g_value_set_boxed_take_ownership (GValue *value, gpointer v_boxed); GType g_closure_get_type () ; GType g_value_get_type () ; GType g_value_array_get_type () ; GType g_strv_get_type () ; GType g_gstring_get_type () ; alias gchar** GStrv; alias _GEnumClass GEnumClass; alias _GFlagsClass GFlagsClass; alias _GEnumValue GEnumValue; alias _GFlagsValue GFlagsValue; struct _GEnumClass { GTypeClass g_type_class; gint minimum; gint maximum; guint n_values; GEnumValue *values; } struct _GFlagsClass { GTypeClass g_type_class; guint mask; guint n_values; GFlagsValue *values; } struct _GEnumValue { gint value; gchar *value_name; gchar *value_nick; } struct _GFlagsValue { guint value; gchar *value_name; gchar *value_nick; } GEnumValue* g_enum_get_value (GEnumClass *enum_class, gint value); GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class, gchar *name); GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class, gchar *nick); GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class, guint value); GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class, gchar *name); GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class, gchar *nick); void g_value_set_enum (GValue *value, gint v_enum); gint g_value_get_enum ( GValue *value); void g_value_set_flags (GValue *value, guint v_flags); guint g_value_get_flags ( GValue *value); GType g_enum_register_static ( gchar *name, GEnumValue *_static_values); GType g_flags_register_static ( gchar *name, GFlagsValue *_static_values); void g_enum_complete_type_info (GType g_enum_type, GTypeInfo *info, GEnumValue *_values); void g_flags_complete_type_info (GType g_flags_type, GTypeInfo *info, GFlagsValue *_values); alias void (*GValueTransform) ( GValue *src_value, GValue *dest_value); struct _GValue { GType g_type; union data_union { gint v_int; guint v_uint; glong v_long; gulong v_ulong; gint64 v_int64; guint64 v_uint64; gfloat v_float; gdouble v_double; gpointer v_pointer; } data_union data[2]; } GValue* g_value_init (GValue *value, GType g_type); void g_value_copy ( GValue *src_value, GValue *dest_value); GValue* g_value_reset (GValue *value); void g_value_unset (GValue *value); void g_value_set_instance (GValue *value, gpointer instanc); gboolean g_value_fits_pointer ( GValue *value); gpointer g_value_peek_pointer ( GValue *value); gboolean g_value_type_compatible (GType src_type, GType dest_type); gboolean g_value_type_transformable (GType src_type, GType dest_type); gboolean g_value_transform ( GValue *src_value, GValue *dest_value); void g_value_register_transform_func (GType src_type, GType dest_type, GValueTransform transform_func); enum GParamFlags { G_PARAM_READABLE = 1 << 0, G_PARAM_WRITABLE = 1 << 1, G_PARAM_CONSTRUCT = 1 << 2, G_PARAM_CONSTRUCT_ONLY = 1 << 3, G_PARAM_LAX_VALIDATION = 1 << 4, G_PARAM_PRIVATE = 1 << 5 }; alias _GParamSpec GParamSpec; alias _GParamSpecClass GParamSpecClass; alias _GParameter GParameter; alias _GParamSpecPool GParamSpecPool; alias void _GParamSpecPool; struct _GParamSpec { GTypeInstance g_type_instance; gchar *name; GParamFlags flags; GType value_type; GType owner_type; gchar *_nick; gchar *_blurb; GData *qdata; guint ref_count; guint param_id; } struct _GParamSpecClass { GTypeClass g_type_class; GType value_type; void (*finalize) (GParamSpec *pspec); void (*value_set_default) (GParamSpec *pspec, GValue *value); gboolean (*value_validate) (GParamSpec *pspec, GValue *value); gint (*values_cmp) (GParamSpec *pspec, GValue *value1, GValue *value2); gpointer dummy[4]; } struct _GParameter { gchar *name; GValue value; } GParamSpec* g_param_spec_ref (GParamSpec *pspec); void g_param_spec_unref (GParamSpec *pspec); void g_param_spec_sink (GParamSpec *pspec); gpointer g_param_spec_get_qdata (GParamSpec *pspec, GQuark quark); void g_param_spec_set_qdata (GParamSpec *pspec, GQuark quark, gpointer data); void g_param_spec_set_qdata_full (GParamSpec *pspec, GQuark quark, gpointer data, GDestroyNotify destroy); gpointer g_param_spec_steal_qdata (GParamSpec *pspec, GQuark quark); GParamSpec* g_param_spec_get_redirect_target (GParamSpec *pspec); void g_param_value_set_default (GParamSpec *pspec, GValue *value); gboolean g_param_value_defaults (GParamSpec *pspec, GValue *value); gboolean g_param_value_validate (GParamSpec *pspec, GValue *value); gboolean g_param_value_convert (GParamSpec *pspec, GValue *src_value, GValue *dest_value, gboolean strict_validation); gint g_param_values_cmp (GParamSpec *pspec, GValue *value1, GValue *value2); gchar* g_param_spec_get_name (GParamSpec *pspec); gchar* g_param_spec_get_nick (GParamSpec *pspec); gchar* g_param_spec_get_blurb (GParamSpec *pspec); void g_value_set_param (GValue *value, GParamSpec *param); GParamSpec* g_value_get_param ( GValue *value); GParamSpec* g_value_dup_param ( GValue *value); void g_value_take_param (GValue *value, GParamSpec *param); void g_value_set_param_take_ownership (GValue *value, GParamSpec *param); alias _GParamSpecTypeInfo GParamSpecTypeInfo; struct _GParamSpecTypeInfo { guint16 instance_size; guint16 n_preallocs; void (*instanc_init) (GParamSpec *pspec); GType value_type; void (*finalize) (GParamSpec *pspec); void (*value_set_default) (GParamSpec *pspec, GValue *value); gboolean (*value_validate) (GParamSpec *pspec, GValue *value); gint (*values_cmp) (GParamSpec *pspec, GValue *value1, GValue *value2); } GType g_param_type_register_static ( gchar *name, GParamSpecTypeInfo *pspec_info); GType _g_param_type_register_static_ant ( gchar *name, GParamSpecTypeInfo *pspec_info, GType opt_type); gpointer g_param_spec_internal (GType param_type, gchar *name, gchar *nick, gchar *blurb, GParamFlags flags); GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing); void g_param_spec_pool_insert (GParamSpecPool *pool, GParamSpec *pspec, GType owner_type); void g_param_spec_pool_remove (GParamSpecPool *pool, GParamSpec *pspec); GParamSpec* g_param_spec_pool_lookup (GParamSpecPool *pool, gchar *param_name, GType owner_type, gboolean walk_ancestors); GList* g_param_spec_pool_list_owned (GParamSpecPool *pool, GType owner_type); GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool, GType owner_type, guint *n_pspecs_p); alias _GClosure GClosure; alias _GClosureNotifyData GClosureNotifyData; alias void (*GCallback) (); alias void (*GClosureNotify) (gpointer data, GClosure *closure); alias void (*GClosureMarshal) (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); alias _GCClosure GCClosure; struct _GClosureNotifyData { gpointer data; GClosureNotify notify; } struct _GClosure { guint ref_count; guint meta_marshal; guint n_guards; guint n_fnotifiers; guint n_inotifiers; guint in_inotify; guint floating; guint derivative_flag; guint in_marshal; guint is_invalid; void (*marshal) (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); gpointer data; GClosureNotifyData *notifiers; } struct _GCClosure { GClosure closure; gpointer callback; } GClosure* g_cclosure_new (GCallback callback_func, gpointer user_data, GClosureNotify destroy_data); GClosure* g_cclosure_new_swap (GCallback callback_func, gpointer user_data, GClosureNotify destroy_data); GClosure* g_signal_type_cclosure_new (GType itype); GClosure* g_closure_ref (GClosure *closure); void g_closure_sink (GClosure *closure); void g_closure_unref (GClosure *closure); GClosure* g_closure_new_simple (guint sizeof_closure, gpointer data); void g_closure_add_finalize_notifier (GClosure *closure, gpointer notify_data, GClosureNotify notify_func); void g_closure_remove_finalize_notifier (GClosure *closure, gpointer notify_data, GClosureNotify notify_func); void g_closure_add_invalidate_notifier (GClosure *closure, gpointer notify_data, GClosureNotify notify_func); void g_closure_remove_invalidate_notifier (GClosure *closure, gpointer notify_data, GClosureNotify notify_func); void g_closure_add_marshal_guards (GClosure *closure, gpointer pre_marshal_data, GClosureNotify pre_marshal_notify, gpointer post_marshal_data, GClosureNotify post_marshal_notify); void g_closure_set_marshal (GClosure *closure, GClosureMarshal marshal); void g_closure_set_meta_marshal (GClosure *closure, gpointer marshal_data, GClosureMarshal meta_marshal); void g_closure_invalidate (GClosure *closure); void g_closure_invoke (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint); void g_cclosure_marshal_VOID__VOID (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__CHAR (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__UCHAR (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__INT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__LONG (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__ULONG (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__ENUM (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__FLAGS (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__FLOAT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__DOUBLE (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__STRING (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__PARAM (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__BOXED (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__OBJECT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); alias _GSignalQuery GSignalQuery; alias _GSignalInvocationHint GSignalInvocationHint; alias GClosureMarshal GSignalCMarshaller; alias gboolean (*GSignalEmissionHook) (GSignalInvocationHint *ihint, guint n_param_values, GValue *param_values, gpointer data); alias gboolean (*GSignalAccumulator) (GSignalInvocationHint *ihint, GValue *return_accu, GValue *handler_return, gpointer data); enum GSignalFlags { G_SIGNAL_RUN_FIRST = 1 << 0, G_SIGNAL_RUN_LAST = 1 << 1, G_SIGNAL_RUN_CLEANUP = 1 << 2, G_SIGNAL_NO_RECURSE = 1 << 3, G_SIGNAL_DETAILED = 1 << 4, G_SIGNAL_ACTION = 1 << 5, G_SIGNAL_NO_HOOKS = 1 << 6 }; enum GConnectFlags { G_CONNECT_AFTER = 1 << 0, G_CONNECT_SWAPPED = 1 << 1 }; enum GSignalMatchType { G_SIGNAL_MATCH_ID = 1 << 0, G_SIGNAL_MATCH_DETAIL = 1 << 1, G_SIGNAL_MATCH_CLOSURE = 1 << 2, G_SIGNAL_MATCH_FUNC = 1 << 3, G_SIGNAL_MATCH_DATA = 1 << 4, G_SIGNAL_MATCH_UNBLOCKED = 1 << 5 }; struct _GSignalInvocationHint { guint signal_id; GQuark detail; GSignalFlags run_type; } struct _GSignalQuery { guint signal_id; gchar *signal_name; GType itype; GSignalFlags signal_flags; GType return_type; guint n_params; GType *param_types; } guint g_signal_newv ( gchar *signal_name, GType itype, GSignalFlags signal_flags, GClosure *class_closure, GSignalAccumulator accumulator, gpointer accu_data, GSignalCMarshaller c_marshaller, GType return_type, guint n_params, GType *param_types); guint g_signal_new_valist ( gchar *signal_name, GType itype, GSignalFlags signal_flags, GClosure *class_closure, GSignalAccumulator accumulator, gpointer accu_data, GSignalCMarshaller c_marshaller, GType return_type, guint n_params, va_list args); guint g_signal_new ( gchar *signal_name, GType itype, GSignalFlags signal_flags, guint class_offset, GSignalAccumulator accumulator, gpointer accu_data, GSignalCMarshaller c_marshaller, GType return_type, guint n_params, ...); void g_signal_emitv ( GValue *instanc_and_params, guint signal_id, GQuark detail, GValue *return_value); void g_signal_emit_valist (gpointer instanc, guint signal_id, GQuark detail, va_list var_args); void g_signal_emit (gpointer instanc, guint signal_id, GQuark detail, ...); void g_signal_emit_by_name (gpointer instanc, gchar *detailed_signal, ...); guint g_signal_lookup ( gchar *name, GType itype); gchar* g_signal_name (guint signal_id); void g_signal_query (guint signal_id, GSignalQuery *query); guint* g_signal_list_ids (GType itype, guint *n_ids); gboolean g_signal_parse_name ( gchar *detailed_signal, GType itype, guint *signal_id_p, GQuark *detail_p, gboolean force_detail_quark); GSignalInvocationHint* g_signal_get_invocation_hint (gpointer instanc); void g_signal_stop_emission (gpointer instanc, guint signal_id, GQuark detail); void g_signal_stop_emission_by_name (gpointer instanc, gchar *detailed_signal); gulong g_signal_add_emission_hook (guint signal_id, GQuark detail, GSignalEmissionHook hook_func, gpointer hook_data, GDestroyNotify data_destroy); void g_signal_remove_emission_hook (guint signal_id, gulong hook_id); gboolean g_signal_has_handler_pending (gpointer instanc, guint signal_id, GQuark detail, gboolean may_be_blocked); gulong g_signal_connect_closure_by_id (gpointer instanc, guint signal_id, GQuark detail, GClosure *closure, gboolean after); gulong g_signal_connect_closure (gpointer instanc, gchar *detailed_signal, GClosure *closure, gboolean after); gulong g_signal_connect_data (gpointer instanc, gchar *detailed_signal, GCallback c_handler, gpointer data, GClosureNotify destroy_data, GConnectFlags connect_flags); void g_signal_handler_block (gpointer instanc, gulong handler_id); void g_signal_handler_unblock (gpointer instanc, gulong handler_id); void g_signal_handler_disconnect (gpointer instanc, gulong handler_id); gboolean g_signal_handler_is_connected (gpointer instanc, gulong handler_id); gulong g_signal_handler_find (gpointer instanc, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data); guint g_signal_handlers_block_matched (gpointer instanc, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data); guint g_signal_handlers_unblock_matched (gpointer instanc, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data); guint g_signal_handlers_disconnect_matched (gpointer instanc, GSignalMatchType mask, guint signal_id, GQuark detail, GClosure *closure, gpointer func, gpointer data); void g_signal_override_class_closure (guint signal_id, GType instance_type, GClosure *class_closure); void g_signal_chain_from_overridden ( GValue *instanc_and_params, GValue *return_value); gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint, GValue *return_accu, GValue *handler_return, gpointer dummy); void g_signal_handlers_destroy (gpointer instanc); void _g_signals_destroy (GType itype); alias _GObject GObject; alias _GObjectClass GObjectClass; alias void (*GObjectGetPropertyFunc) (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); alias void (*GObjectSetPropertyFunc) (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); alias void (*GObjectFinalizeFunc) (GObject *object); alias void (*GWeakNotify) (gpointer data, GObject *where_the_object_was); struct _GObject { GTypeInstance g_type_instance; guint ref_count; GData *qdata; } struct _GObjectClass { GTypeClass g_type_class; GSList *construct_properties; // BVH GObject* (*constructor) (GType type, guint n_ruct_properties); void (*set_property) (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); void (*get_property) (GObject *object, guint property_id, GValue *value, GParamSpec *pspec); void (*dispose) (GObject *object); void (*finalize) (GObject *object); void (*dispatch_properties_changed) (GObject *object, guint n_pspecs, GParamSpec **pspecs); void (*notify) (GObject *object, GParamSpec *pspec); gpointer pdummy[8]; } struct _GObjectConstructParam { GParamSpec *pspec; GValue *value; } void g_object_class_install_property (GObjectClass *oclass, guint property_id, GParamSpec *pspec); GParamSpec* g_object_class_find_property (GObjectClass *oclass, gchar *property_name); GParamSpec**g_object_class_list_properties (GObjectClass *oclass, guint *n_properties); void g_object_class_override_property (GObjectClass *oclass, guint property_id, gchar *name); void g_object_interface_install_property (gpointer g_iface, GParamSpec *pspec); GParamSpec* g_object_interface_find_property (gpointer g_iface, gchar *property_name); GParamSpec**g_object_interface_list_properties (gpointer g_iface, guint *n_properties_p); gpointer g_object_new (GType object_type, gchar *first_property_name, ...); gpointer g_object_newv (GType object_type, guint n_parameters, GParameter *parameters); GObject* g_object_new_valist (GType object_type, gchar *first_property_name, va_list var_args); void g_object_set (gpointer object, gchar *first_property_name, ...); void g_object_get (gpointer object, gchar *first_property_name, ...); gpointer g_object_connect (gpointer object, gchar *signal_spec, ...); void g_object_disconnect (gpointer object, gchar *signal_spec, ...); void g_object_set_valist (GObject *object, gchar *first_property_name, va_list var_args); void g_object_get_valist (GObject *object, gchar *first_property_name, va_list var_args); void g_object_set_property (GObject *object, gchar *property_name, GValue *value); void g_object_get_property (GObject *object, gchar *property_name, GValue *value); void g_object_freeze_notify (GObject *object); void g_object_notify (GObject *object, gchar *property_name); void g_object_thaw_notify (GObject *object); gpointer g_object_ref (gpointer object); void g_object_unref (gpointer object); void g_object_weak_ref (GObject *object, GWeakNotify notify, gpointer data); void g_object_weak_unref (GObject *object, GWeakNotify notify, gpointer data); void g_object_add_weak_pointer (GObject *object, gpointer *weak_pointer_location); void g_object_remove_weak_pointer (GObject *object, gpointer *weak_pointer_location); gpointer g_object_get_qdata (GObject *object, GQuark quark); void g_object_set_qdata (GObject *object, GQuark quark, gpointer data); void g_object_set_qdata_full (GObject *object, GQuark quark, gpointer data, GDestroyNotify destroy); gpointer g_object_steal_qdata (GObject *object, GQuark quark); gpointer g_object_get_data (GObject *object, gchar *key); void g_object_set_data (GObject *object, gchar *key, gpointer data); void g_object_set_data_full (GObject *object, gchar *key, gpointer data, GDestroyNotify destroy); gpointer g_object_steal_data (GObject *object, gchar *key); void g_object_watch_closure (GObject *object, GClosure *closure); GClosure* g_cclosure_new_object (GCallback callback_func, GObject *object); GClosure* g_cclosure_new_object_swap (GCallback callback_func, GObject *object); GClosure* g_closure_new_object (guint sizeof_closure, GObject *object); void g_value_set_object (GValue *value, gpointer v_object); gpointer g_value_get_object ( GValue *value); GObject* g_value_dup_object ( GValue *value); gulong g_signal_connect_object (gpointer instanc, gchar *detailed_signal, GCallback c_handler, gpointer gobject, GConnectFlags connect_flags); void g_object_run_dispose (GObject *object); void g_value_take_object (GValue *value, gpointer v_object); void g_value_set_object_take_ownership (GValue *value, gpointer v_object); alias _GParamSpecChar GParamSpecChar; alias _GParamSpecUChar GParamSpecUChar; alias _GParamSpecBoolean GParamSpecBoolean; alias _GParamSpecInt GParamSpecInt; alias _GParamSpecUInt GParamSpecUInt; alias _GParamSpecLong GParamSpecLong; alias _GParamSpecULong GParamSpecULong; alias _GParamSpecInt64 GParamSpecInt64; alias _GParamSpecUInt64 GParamSpecUInt64; alias _GParamSpecUnichar GParamSpecUnichar; alias _GParamSpecEnum GParamSpecEnum; alias _GParamSpecFlags GParamSpecFlags; alias _GParamSpecFloat GParamSpecFloat; alias _GParamSpecDouble GParamSpecDouble; alias _GParamSpecString GParamSpecString; alias _GParamSpecParam GParamSpecParam; alias _GParamSpecBoxed GParamSpecBoxed; alias _GParamSpecPointer GParamSpecPointer; alias _GParamSpecValueArray GParamSpecValueArray; alias _GParamSpecObject GParamSpecObject; alias _GParamSpecOverride GParamSpecOverride; struct _GParamSpecChar { GParamSpec parent_instance; gint8 minimum; gint8 maximum; gint8 default_value; } struct _GParamSpecUChar { GParamSpec parent_instance; guint8 minimum; guint8 maximum; guint8 default_value; } struct _GParamSpecBoolean { GParamSpec parent_instance; gboolean default_value; } struct _GParamSpecInt { GParamSpec parent_instance; gint minimum; gint maximum; gint default_value; } struct _GParamSpecUInt { GParamSpec parent_instance; guint minimum; guint maximum; guint default_value; } struct _GParamSpecLong { GParamSpec parent_instance; glong minimum; glong maximum; glong default_value; } struct _GParamSpecULong { GParamSpec parent_instance; gulong minimum; gulong maximum; gulong default_value; } struct _GParamSpecInt64 { GParamSpec parent_instance; gint64 minimum; gint64 maximum; gint64 default_value; } struct _GParamSpecUInt64 { GParamSpec parent_instance; guint64 minimum; guint64 maximum; guint64 default_value; } struct _GParamSpecUnichar { GParamSpec parent_instance; gunichar default_value; } struct _GParamSpecEnum { GParamSpec parent_instance; GEnumClass *enum_class; gint default_value; } struct _GParamSpecFlags { GParamSpec parent_instance; GFlagsClass *flags_class; guint default_value; } struct _GParamSpecFloat { GParamSpec parent_instance; gfloat minimum; gfloat maximum; gfloat default_value; gfloat epsilon; } struct _GParamSpecDouble { GParamSpec parent_instance; gdouble minimum; gdouble maximum; gdouble default_value; gdouble epsilon; } struct _GParamSpecString { GParamSpec parent_instance; gchar *default_value; gchar *cset_first; gchar *cset_nth; gchar substitutor; guint null_fold_if_empty; guint ensure_non_null; } struct _GParamSpecParam { GParamSpec parent_instance; } struct _GParamSpecBoxed { GParamSpec parent_instance; } struct _GParamSpecPointer { GParamSpec parent_instance; } struct _GParamSpecValueArray { GParamSpec parent_instance; GParamSpec *element_spec; guint fixed_n_elements; } struct _GParamSpecObject { GParamSpec parent_instance; } struct _GParamSpecOverride { GParamSpec parent_instance; GParamSpec *overridden; } GParamSpec* g_param_spec_char ( gchar *name, gchar *nick, gchar *blurb, gint8 minimum, gint8 maximum, gint8 default_value, GParamFlags flags); GParamSpec* g_param_spec_uchar ( gchar *name, gchar *nick, gchar *blurb, guint8 minimum, guint8 maximum, guint8 default_value, GParamFlags flags); GParamSpec* g_param_spec_boolean ( gchar *name, gchar *nick, gchar *blurb, gboolean default_value, GParamFlags flags); GParamSpec* g_param_spec_int ( gchar *name, gchar *nick, gchar *blurb, gint minimum, gint maximum, gint default_value, GParamFlags flags); GParamSpec* g_param_spec_uint ( gchar *name, gchar *nick, gchar *blurb, guint minimum, guint maximum, guint default_value, GParamFlags flags); GParamSpec* g_param_spec_long ( gchar *name, gchar *nick, gchar *blurb, glong minimum, glong maximum, glong default_value, GParamFlags flags); GParamSpec* g_param_spec_ulong ( gchar *name, gchar *nick, gchar *blurb, gulong minimum, gulong maximum, gulong default_value, GParamFlags flags); GParamSpec* g_param_spec_int64 ( gchar *name, gchar *nick, gchar *blurb, gint64 minimum, gint64 maximum, gint64 default_value, GParamFlags flags); GParamSpec* g_param_spec_uint64 ( gchar *name, gchar *nick, gchar *blurb, guint64 minimum, guint64 maximum, guint64 default_value, GParamFlags flags); GParamSpec* g_param_spec_unichar ( gchar *name, gchar *nick, gchar *blurb, gunichar default_value, GParamFlags flags); GParamSpec* g_param_spec_enum ( gchar *name, gchar *nick, gchar *blurb, GType enum_type, gint default_value, GParamFlags flags); GParamSpec* g_param_spec_flags ( gchar *name, gchar *nick, gchar *blurb, GType flags_type, guint default_value, GParamFlags flags); GParamSpec* g_param_spec_float ( gchar *name, gchar *nick, gchar *blurb, gfloat minimum, gfloat maximum, gfloat default_value, GParamFlags flags); GParamSpec* g_param_spec_double ( gchar *name, gchar *nick, gchar *blurb, gdouble minimum, gdouble maximum, gdouble default_value, GParamFlags flags); GParamSpec* g_param_spec_string ( gchar *name, gchar *nick, gchar *blurb, gchar *default_value, GParamFlags flags); GParamSpec* g_param_spec_param ( gchar *name, gchar *nick, gchar *blurb, GType param_type, GParamFlags flags); GParamSpec* g_param_spec_boxed ( gchar *name, gchar *nick, gchar *blurb, GType boxed_type, GParamFlags flags); GParamSpec* g_param_spec_pointer ( gchar *name, gchar *nick, gchar *blurb, GParamFlags flags); GParamSpec* g_param_spec_value_array ( gchar *name, gchar *nick, gchar *blurb, GParamSpec *element_spec, GParamFlags flags); GParamSpec* g_param_spec_object ( gchar *name, gchar *nick, gchar *blurb, GType object_type, GParamFlags flags); GParamSpec* g_param_spec_override ( gchar *name, GParamSpec *overridden); GType *g_param_spec_types; void g_source_set_closure (GSource *source, GClosure *closure); GType g_io_channel_get_type (); GType g_io_condition_get_type (); alias _GTypeModule GTypeModule; alias _GTypeModuleClass GTypeModuleClass; struct _GTypeModule { GObject parent_instance; guint use_count; GSList *type_infos; GSList *interface_infos; gchar *name; } struct _GTypeModuleClass { GObjectClass parent_class; gboolean (* load) (GTypeModule *modle); void (* unload) (GTypeModule *modle); void (*reserved1) (); void (*reserved2) (); void (*reserved3) (); void (*reserved4) (); } GType g_type_module_get_type (); gboolean g_type_module_use (GTypeModule *modle); void g_type_module_unuse (GTypeModule *modle); void g_type_module_set_name (GTypeModule *modle, gchar *name); GType g_type_module_register_type (GTypeModule *modle, GType parent_type, gchar *type_name, GTypeInfo *type_info, GTypeFlags flags); void g_type_module_add_interface (GTypeModule *modle, GType instance_type, GType interface_type, GInterfaceInfo *interface_info); alias _GTypePluginClass GTypePluginClass; alias void (*GTypePluginUse) (GTypePlugin *plugin); alias void (*GTypePluginUnuse) (GTypePlugin *plugin); alias void (*GTypePluginCompleteTypeInfo) (GTypePlugin *plugin, GType g_type, GTypeInfo *info, GTypeValueTable *value_table); alias void (*GTypePluginCompleteInterfaceInfo) (GTypePlugin *plugin, GType instance_type, GType interface_type, GInterfaceInfo *info); struct _GTypePluginClass { GTypeInterface base_iface; GTypePluginUse use_plugin; GTypePluginUnuse unuse_plugin; GTypePluginCompleteTypeInfo complete_type_info; GTypePluginCompleteInterfaceInfo complete_interface_info; } GType g_type_plugin_get_type () ; void g_type_plugin_use (GTypePlugin *plugin); void g_type_plugin_unuse (GTypePlugin *plugin); void g_type_plugin_complete_type_info (GTypePlugin *plugin, GType g_type, GTypeInfo *info, GTypeValueTable *value_table); void g_type_plugin_complete_interface_info (GTypePlugin *plugin, GType instance_type, GType interface_type, GInterfaceInfo *info); alias _GValueArray GValueArray; struct _GValueArray { guint n_values; GValue *values; guint n_prealloced; } GValue* g_value_array_get_nth (GValueArray *value_array, guint index_); GValueArray* g_value_array_new (guint n_prealloced); void g_value_array_free (GValueArray *value_array); GValueArray* g_value_array_copy ( GValueArray *value_array); GValueArray* g_value_array_prepend (GValueArray *value_array, GValue *value); GValueArray* g_value_array_append (GValueArray *value_array, GValue *value); GValueArray* g_value_array_insert (GValueArray *value_array, guint index_, GValue *value); GValueArray* g_value_array_remove (GValueArray *value_array, guint index_); GValueArray* g_value_array_sort (GValueArray *value_array, GCompareFunc compare_func); GValueArray* g_value_array_sort_with_data (GValueArray *value_array, GCompareDataFunc compare_func, gpointer user_data); void g_value_set_char (GValue *value, gchar v_char); gchar g_value_get_char ( GValue *value); void g_value_set_uchar (GValue *value, guchar v_uchar); guchar g_value_get_uchar ( GValue *value); void g_value_set_boolean (GValue *value, gboolean v_boolean); gboolean g_value_get_boolean ( GValue *value); void g_value_set_int (GValue *value, gint v_int); gint g_value_get_int ( GValue *value); void g_value_set_uint (GValue *value, guint v_uint); guint g_value_get_uint ( GValue *value); void g_value_set_long (GValue *value, glong v_long); glong g_value_get_long ( GValue *value); void g_value_set_ulong (GValue *value, gulong v_ulong); gulong g_value_get_ulong ( GValue *value); void g_value_set_int64 (GValue *value, gint64 v_int64); gint64 g_value_get_int64 ( GValue *value); void g_value_set_uint64 (GValue *value, guint64 v_uint64); guint64 g_value_get_uint64 ( GValue *value); void g_value_set_float (GValue *value, gfloat v_float); gfloat g_value_get_float ( GValue *value); void g_value_set_double (GValue *value, gdouble v_double); gdouble g_value_get_double ( GValue *value); void g_value_set_string (GValue *value, gchar *v_string); void g_value_set_static_string (GValue *value, gchar *v_string); gchar* g_value_get_string ( GValue *value); gchar* g_value_dup_string ( GValue *value); void g_value_set_pointer (GValue *value, gpointer v_pointer); gpointer g_value_get_pointer ( GValue *value); GType g_pointer_type_register_static ( gchar *name); gchar* g_strdup_value_contents ( GValue *value); void g_value_take_string (GValue *value, gchar *v_string); void g_value_set_string_take_ownership (GValue *value, gchar *v_string); alias gchar* gchararray; alias _PangoLogAttr PangoLogAttr; alias _PangoEngineLang PangoEngineLang; alias void _PangoEngineLang; alias _PangoEngineShape PangoEngineShape; alias void _PangoEngineShape; alias _PangoFont PangoFont; alias void _PangoFont; alias _PangoMatrix PangoMatrix; alias _PangoRectangle PangoRectangle; alias _PangoLanguage PangoLanguage; alias void _PangoLanguage; alias guint32 PangoGlyph; struct _PangoRectangle { int x; int y; int width; int height; } struct _PangoMatrix { double xx; double xy; double yx; double yy; double x0; double y0; } GType pango_matrix_get_type (); PangoMatrix *pango_matrix_copy ( PangoMatrix *matrix); void pango_matrix_free (PangoMatrix *matrix); void pango_matrix_translate (PangoMatrix *matrix, double tx, double ty); void pango_matrix_scale (PangoMatrix *matrix, double scale_x, double scale_y); void pango_matrix_rotate (PangoMatrix *matrix, double degrees); void pango_matrix_concat (PangoMatrix *matrix, PangoMatrix *new_matrix); enum PangoDirection { PANGO_DIRECTION_LTR, PANGO_DIRECTION_RTL, PANGO_DIRECTION_TTB_LTR, PANGO_DIRECTION_TTB_RTL, PANGO_DIRECTION_WEAK_LTR, PANGO_DIRECTION_WEAK_RTL, PANGO_DIRECTION_NEUTRAL }; GType pango_language_get_type (); PangoLanguage *pango_language_from_string ( char *language); gboolean pango_language_matches (PangoLanguage *language, char *range_list); gboolean pango_get_mirror_char (gunichar ch, gunichar *mirrored_ch); PangoDirection pango_unichar_direction (gunichar ch); PangoDirection pango_find_base_dir ( gchar *text, gint length); alias _PangoFontDescription PangoFontDescription; alias void _PangoFontDescription; alias _PangoFontMetrics PangoFontMetrics; alias void _PangoFontMetrics; enum PangoStyle { PANGO_STYLE_NORMAL, PANGO_STYLE_OBLIQUE, PANGO_STYLE_ITALIC }; enum PangoVariant { PANGO_VARIANT_NORMAL, PANGO_VARIANT_SMALL_CAPS }; enum PangoWeight { PANGO_WEIGHT_ULTRALIGHT = 200, PANGO_WEIGHT_LIGHT = 300, PANGO_WEIGHT_NORMAL = 400, PANGO_WEIGHT_BOLD = 700, PANGO_WEIGHT_ULTRABOLD = 800, PANGO_WEIGHT_HEAVY = 900 }; enum PangoStretch { PANGO_STRETCH_ULTRA_CONDENSED, PANGO_STRETCH_EXTRA_CONDENSED, PANGO_STRETCH_CONDENSED, PANGO_STRETCH_SEMI_CONDENSED, PANGO_STRETCH_NORMAL, PANGO_STRETCH_SEMI_EXPANDED, PANGO_STRETCH_EXPANDED, PANGO_STRETCH_EXTRA_EXPANDED, PANGO_STRETCH_ULTRA_EXPANDED }; enum PangoFontMask { PANGO_FONT_MASK_FAMILY = 1 << 0, PANGO_FONT_MASK_STYLE = 1 << 1, PANGO_FONT_MASK_VARIANT = 1 << 2, PANGO_FONT_MASK_WEIGHT = 1 << 3, PANGO_FONT_MASK_STRETCH = 1 << 4, PANGO_FONT_MASK_SIZE = 1 << 5 }; GType pango_font_description_get_type (); PangoFontDescription *pango_font_description_new (); PangoFontDescription *pango_font_description_copy ( PangoFontDescription *desc); PangoFontDescription *pango_font_description_copy_static ( PangoFontDescription *desc); guint pango_font_description_hash ( PangoFontDescription *desc); gboolean pango_font_description_equal ( PangoFontDescription *desc1, PangoFontDescription *desc2); void pango_font_description_free (PangoFontDescription *desc); void pango_font_descriptions_free (PangoFontDescription **descs, int n_descs); void pango_font_description_set_family (PangoFontDescription *desc, char *family); void pango_font_description_set_family_static (PangoFontDescription *desc, char *family); char *pango_font_description_get_family ( PangoFontDescription *desc); void pango_font_description_set_style (PangoFontDescription *desc, PangoStyle style); PangoStyle pango_font_description_get_style ( PangoFontDescription *desc); void pango_font_description_set_variant (PangoFontDescription *desc, PangoVariant variant); PangoVariant pango_font_description_get_variant ( PangoFontDescription *desc); void pango_font_description_set_weight (PangoFontDescription *desc, PangoWeight weight); PangoWeight pango_font_description_get_weight ( PangoFontDescription *desc); void pango_font_description_set_stretch (PangoFontDescription *desc, PangoStretch stretch); PangoStretch pango_font_description_get_stretch ( PangoFontDescription *desc); void pango_font_description_set_size (PangoFontDescription *desc, gint size); gint pango_font_description_get_size ( PangoFontDescription *desc); PangoFontMask pango_font_description_get_set_fields ( PangoFontDescription *desc); void pango_font_description_unset_fields (PangoFontDescription *desc, PangoFontMask to_unset); void pango_font_description_merge (PangoFontDescription *desc, PangoFontDescription *desc_to_merge, gboolean replace_existing); void pango_font_description_merge_static (PangoFontDescription *desc, PangoFontDescription *desc_to_merge, gboolean replace_existing); gboolean pango_font_description_better_match ( PangoFontDescription *desc, PangoFontDescription *old_match, PangoFontDescription *new_match); PangoFontDescription *pango_font_description_from_string ( char *str); char * pango_font_description_to_string ( PangoFontDescription *desc); char * pango_font_description_to_filename ( PangoFontDescription *desc); GType pango_font_metrics_get_type (); PangoFontMetrics *pango_font_metrics_ref (PangoFontMetrics *metrics); void pango_font_metrics_unref (PangoFontMetrics *metrics); int pango_font_metrics_get_ascent (PangoFontMetrics *metrics); int pango_font_metrics_get_descent (PangoFontMetrics *metrics); int pango_font_metrics_get_approximate_char_width (PangoFontMetrics *metrics); int pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics); int pango_font_metrics_get_underline_position (PangoFontMetrics *metrics); int pango_font_metrics_get_underline_thickness (PangoFontMetrics *metrics); int pango_font_metrics_get_strikethrough_position (PangoFontMetrics *metrics); int pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics); alias _PangoFontFamily PangoFontFamily; alias void _PangoFontFamily; alias _PangoFontFace PangoFontFace; alias void _PangoFontFace; GType pango_font_family_get_type () ; void pango_font_family_list_faces (PangoFontFamily *family, PangoFontFace ***faces, int *n_faces); char *pango_font_family_get_name (PangoFontFamily *family); gboolean pango_font_family_is_monospace (PangoFontFamily *family); GType pango_font_face_get_type () ; PangoFontDescription *pango_font_face_describe (PangoFontFace *face); char *pango_font_face_get_face_name (PangoFontFace *face); void pango_font_face_list_sizes (PangoFontFace *face, int **sizes, int *n_sizes); GType pango_font_get_type () ; PangoFontDescription *pango_font_describe (PangoFont *font); PangoCoverage * pango_font_get_coverage (PangoFont *font, PangoLanguage *language); PangoEngineShape * pango_font_find_shaper (PangoFont *font, PangoLanguage *language, guint32 ch); PangoFontMetrics * pango_font_get_metrics (PangoFont *font, PangoLanguage *language); void pango_font_get_glyph_extents (PangoFont *font, PangoGlyph glyph, PangoRectangle *ink_rect, PangoRectangle *logical_rect); alias _PangoColor PangoColor; struct _PangoColor { guint16 red; guint16 green; guint16 blue; } GType pango_color_get_type () ; PangoColor *pango_color_copy ( PangoColor *src); void pango_color_free (PangoColor *color); gboolean pango_color_parse (PangoColor *color, char *spec); alias _PangoAttribute PangoAttribute; alias _PangoAttrClass PangoAttrClass; alias _PangoAttrString PangoAttrString; alias _PangoAttrLanguage PangoAttrLanguage; alias _PangoAttrInt PangoAttrInt; alias _PangoAttrFloat PangoAttrFloat; alias _PangoAttrColor PangoAttrColor; alias _PangoAttrFontDesc PangoAttrFontDesc; alias _PangoAttrShape PangoAttrShape; alias _PangoAttrList PangoAttrList; alias void _PangoAttrList; alias _PangoAttrIterator PangoAttrIterator; alias void _PangoAttrIterator; enum PangoAttrType { PANGO_ATTR_INVALID, PANGO_ATTR_LANGUAGE, PANGO_ATTR_FAMILY, PANGO_ATTR_STYLE, PANGO_ATTR_WEIGHT, PANGO_ATTR_VARIANT, PANGO_ATTR_STRETCH, PANGO_ATTR_SIZE, PANGO_ATTR_FONT_DESC, PANGO_ATTR_FOREGROUND, PANGO_ATTR_BACKGROUND, PANGO_ATTR_UNDERLINE, PANGO_ATTR_STRIKETHROUGH, PANGO_ATTR_RISE, PANGO_ATTR_SHAPE, PANGO_ATTR_SCALE, PANGO_ATTR_FALLBACK, PANGO_ATTR_LETTER_SPACING }; enum PangoUnderline { PANGO_UNDERLINE_NONE, PANGO_UNDERLINE_SINGLE, PANGO_UNDERLINE_DOUBLE, PANGO_UNDERLINE_LOW, PANGO_UNDERLINE_ERROR }; struct _PangoAttribute { PangoAttrClass *klass; guint start_index; guint end_index; } alias gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute, gpointer data); struct _PangoAttrClass { PangoAttrType type; PangoAttribute * (*copy) ( PangoAttribute *attr); void (*destroy) (PangoAttribute *attr); gboolean (*equal) ( PangoAttribute *attr1, PangoAttribute *attr2); } struct _PangoAttrString { PangoAttribute attr; char *value; } struct _PangoAttrLanguage { PangoAttribute attr; PangoLanguage *value; } struct _PangoAttrInt { PangoAttribute attr; int value; } struct _PangoAttrFloat { PangoAttribute attr; double value; } struct _PangoAttrColor { PangoAttribute attr; PangoColor color; } struct _PangoAttrShape { PangoAttribute attr; PangoRectangle ink_rect; PangoRectangle logical_rect; } struct _PangoAttrFontDesc { PangoAttribute attr; PangoFontDescription *desc; } PangoAttrType pango_attr_type_register ( gchar *name); PangoAttribute * pango_attribute_copy ( PangoAttribute *attr); void pango_attribute_destroy (PangoAttribute *attr); gboolean pango_attribute_equal ( PangoAttribute *attr1, PangoAttribute *attr2); PangoAttribute *pango_attr_language_new (PangoLanguage *language); PangoAttribute *pango_attr_family_new ( char *family); PangoAttribute *pango_attr_foreground_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_background_new (guint16 red, guint16 green, guint16 blue); PangoAttribute *pango_attr_size_new (int size); PangoAttribute *pango_attr_style_new (PangoStyle style); PangoAttribute *pango_attr_weight_new (PangoWeight weight); PangoAttribute *pango_attr_variant_new (PangoVariant variant); PangoAttribute *pango_attr_stretch_new (PangoStretch stretch); PangoAttribute *pango_attr_font_desc_new ( PangoFontDescription *desc); PangoAttribute *pango_attr_underline_new (PangoUnderline underline); PangoAttribute *pango_attr_strikethrough_new (gboolean strikethrough); PangoAttribute *pango_attr_rise_new (int rise); PangoAttribute *pango_attr_shape_new ( PangoRectangle *ink_rect, PangoRectangle *logical_rect); PangoAttribute *pango_attr_scale_new (double scale_factor); PangoAttribute *pango_attr_fallback_new (gboolean enable_fallback); PangoAttribute *pango_attr_letter_spacing_new (int letter_spacing); GType pango_attr_list_get_type () ; PangoAttrList * pango_attr_list_new (); void pango_attr_list_ref (PangoAttrList *list); void pango_attr_list_unref (PangoAttrList *list); PangoAttrList * pango_attr_list_copy (PangoAttrList *list); void pango_attr_list_insert (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_insert_before (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_change (PangoAttrList *list, PangoAttribute *attr); void pango_attr_list_splice (PangoAttrList *list, PangoAttrList *other, gint pos, gint len); PangoAttrList *pango_attr_list_filter (PangoAttrList *list, PangoAttrFilterFunc func, gpointer data); PangoAttrIterator *pango_attr_list_get_iterator (PangoAttrList *list); void pango_attr_iterator_range (PangoAttrIterator *iterator, gint *start, gint *end); gboolean pango_attr_iterator_next (PangoAttrIterator *iterator); PangoAttrIterator *pango_attr_iterator_copy (PangoAttrIterator *iterator); void pango_attr_iterator_destroy (PangoAttrIterator *iterator); PangoAttribute * pango_attr_iterator_get (PangoAttrIterator *iterator, PangoAttrType type); void pango_attr_iterator_get_font (PangoAttrIterator *iterator, PangoFontDescription *desc, PangoLanguage **language, GSList **extra_attrs); GSList * pango_attr_iterator_get_attrs (PangoAttrIterator *iterator); gboolean pango_parse_markup ( char *markup_text, int length, gunichar accel_marker, PangoAttrList **attr_list, char **text, gunichar *accel_char, GError **error); alias _PangoAnalysis PangoAnalysis; alias _PangoItem PangoItem; struct _PangoAnalysis { PangoEngineShape *shape_engine; PangoEngineLang *lang_engine; PangoFont *font; guint8 level; PangoLanguage *language; GSList *extra_attrs; } struct _PangoItem { gint offset; gint length; gint num_chars; PangoAnalysis analysis; } PangoItem *pango_item_new (); PangoItem *pango_item_copy (PangoItem *item); void pango_item_free (PangoItem *item); PangoItem *pango_item_split (PangoItem *orig, int split_index, int split_offset); struct _PangoLogAttr { guint is_line_break; guint is_mandatory_break; guint is_char_break; guint is_white; guint is_cursor_position; guint is_word_start; guint is_word_end; guint is_sentence_boundary; guint is_sentence_start; guint is_sentence_end; guint backspace_deletes_character; } void pango_break ( gchar *text, int length, PangoAnalysis *analysis, PangoLogAttr *attrs, int attrs_len); void pango_find_paragraph_boundary ( gchar *text, gint length, gint *paragraph_delimiter_index, gint *next_paragraph_start); void pango_get_log_attrs ( char *text, int length, int level, PangoLanguage *language, PangoLogAttr *log_attrs, int attrs_len); GType pango_fontset_get_type () ; alias _PangoFontset PangoFontset; alias void _PangoFontset; alias gboolean (*PangoFontsetForeachFunc) (PangoFontset *fontset, PangoFont *font, gpointer data); PangoFont * pango_fontset_get_font (PangoFontset *fontset, guint wc); PangoFontMetrics *pango_fontset_get_metrics (PangoFontset *fontset); void pango_fontset_foreach (PangoFontset *fontset, PangoFontsetForeachFunc func, gpointer data); alias _PangoContext PangoContext; alias void _PangoContext; alias _PangoFontMap PangoFontMap; alias void _PangoFontMap; GType pango_font_map_get_type () ; PangoFont * pango_font_map_load_font (PangoFontMap *fontmap, PangoContext *context, PangoFontDescription *desc); PangoFontset *pango_font_map_load_fontset (PangoFontMap *fontmap, PangoContext *context, PangoFontDescription *desc, PangoLanguage *language); void pango_font_map_list_families (PangoFontMap *fontmap, PangoFontFamily ***families, int *n_families); alias _PangoContextClass PangoContextClass; alias void _PangoContextClass; GType pango_context_get_type () ; PangoFontMap *pango_context_get_font_map (PangoContext *context); void pango_context_list_families (PangoContext *context, PangoFontFamily ***families, int *n_families); PangoFont * pango_context_load_font (PangoContext *context, PangoFontDescription *desc); PangoFontset *pango_context_load_fontset (PangoContext *context, PangoFontDescription *desc, PangoLanguage *language); PangoFontMetrics *pango_context_get_metrics (PangoContext *context, PangoFontDescription *desc, PangoLanguage *language); void pango_context_set_font_description (PangoContext *context, PangoFontDescription *desc); PangoFontDescription * pango_context_get_font_description (PangoContext *context); PangoLanguage *pango_context_get_language (PangoContext *context); void pango_context_set_language (PangoContext *context, PangoLanguage *language); void pango_context_set_base_dir (PangoContext *context, PangoDirection direction); PangoDirection pango_context_get_base_dir (PangoContext *context); void pango_context_set_matrix (PangoContext *context, PangoMatrix *matrix); PangoMatrix *pango_context_get_matrix (PangoContext *context); GList *pango_itemize (PangoContext *context, char *text, int start_index, int length, PangoAttrList *attrs, PangoAttrIterator *cached_iter); GList *pango_itemize_with_base_dir (PangoContext *context, PangoDirection base_dir, char *text, int start_index, int length, PangoAttrList *attrs, PangoAttrIterator *cached_iter); alias _PangoGlyphGeometry PangoGlyphGeometry; alias _PangoGlyphVisAttr PangoGlyphVisAttr; alias _PangoGlyphInfo PangoGlyphInfo; alias _PangoGlyphString PangoGlyphString; alias gint32 PangoGlyphUnit; struct _PangoGlyphGeometry { PangoGlyphUnit width; PangoGlyphUnit x_offset; PangoGlyphUnit y_offset; } struct _PangoGlyphVisAttr { guint is_cluster_start; } struct _PangoGlyphInfo { PangoGlyph glyph; PangoGlyphGeometry geometry; PangoGlyphVisAttr attr; } struct _PangoGlyphString { gint num_glyphs; PangoGlyphInfo *glyphs; gint *log_clusters; gint space; } PangoGlyphString *pango_glyph_string_new (); void pango_glyph_string_set_size (PangoGlyphString *string, gint new_len); GType pango_glyph_string_get_type (); PangoGlyphString *pango_glyph_string_copy (PangoGlyphString *string); void pango_glyph_string_free (PangoGlyphString *string); void pango_glyph_string_extents (PangoGlyphString *glyphs, PangoFont *font, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_glyph_string_extents_range (PangoGlyphString *glyphs, int start, int end, PangoFont *font, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_glyph_string_get_logical_widths (PangoGlyphString *glyphs, char *text, int length, int embedding_level, int *logical_widths); void pango_glyph_string_index_to_x (PangoGlyphString *glyphs, char *text, int length, PangoAnalysis *analysis, int index_, gboolean trailing, int *x_pos); void pango_glyph_string_x_to_index (PangoGlyphString *glyphs, char *text, int length, PangoAnalysis *analysis, int x_pos, int *index_, int *trailing); void pango_shape ( gchar *text, gint length, PangoAnalysis *analysis, PangoGlyphString *glyphs); GList *pango_reorder_items (GList *logical_items); alias _PangoScriptIter PangoScriptIter; alias void _PangoScriptIter; const int PANGO_SCALE = 1024; enum PangoScript { PANGO_SCRIPT_INVALID_CODE = -1, PANGO_SCRIPT_COMMON = 0, PANGO_SCRIPT_INHERITED, PANGO_SCRIPT_ARABIC, PANGO_SCRIPT_ARMENIAN, PANGO_SCRIPT_BENGALI, PANGO_SCRIPT_BOPOMOFO, PANGO_SCRIPT_CHEROKEE, PANGO_SCRIPT_COPTIC, PANGO_SCRIPT_CYRILLIC, PANGO_SCRIPT_DESERET, PANGO_SCRIPT_DEVANAGARI, PANGO_SCRIPT_ETHIOPIC, PANGO_SCRIPT_GEORGIAN, PANGO_SCRIPT_GOTHIC, PANGO_SCRIPT_GREEK, PANGO_SCRIPT_GUJARATI, PANGO_SCRIPT_GURMUKHI, PANGO_SCRIPT_HAN, PANGO_SCRIPT_HANGUL, PANGO_SCRIPT_HEBREW, PANGO_SCRIPT_HIRAGANA, PANGO_SCRIPT_KANNADA, PANGO_SCRIPT_KATAKANA, PANGO_SCRIPT_KHMER, PANGO_SCRIPT_LAO, PANGO_SCRIPT_LATIN, PANGO_SCRIPT_MALAYALAM, PANGO_SCRIPT_MONGOLIAN, PANGO_SCRIPT_MYANMAR, PANGO_SCRIPT_OGHAM, PANGO_SCRIPT_OLD_ITALIC, PANGO_SCRIPT_ORIYA, PANGO_SCRIPT_RUNIC, PANGO_SCRIPT_SINHALA, PANGO_SCRIPT_SYRIAC, PANGO_SCRIPT_TAMIL, PANGO_SCRIPT_TELUGU, PANGO_SCRIPT_THAANA, PANGO_SCRIPT_THAI, PANGO_SCRIPT_TIBETAN, PANGO_SCRIPT_CANADIAN_ABORIGINAL, PANGO_SCRIPT_YI, PANGO_SCRIPT_TAGALOG, PANGO_SCRIPT_HANUNOO, PANGO_SCRIPT_BUHID, PANGO_SCRIPT_TAGBANWA, PANGO_SCRIPT_BRAILLE, PANGO_SCRIPT_CYPRIOT, PANGO_SCRIPT_LIMBU, PANGO_SCRIPT_OSMANYA, PANGO_SCRIPT_SHAVIAN, PANGO_SCRIPT_LINEAR_B, PANGO_SCRIPT_TAI_LE, PANGO_SCRIPT_UGARITIC }; PangoScript pango_script_for_unichar (gunichar ch); PangoScriptIter *pango_script_iter_new ( char *text, int length); void pango_script_iter_get_range (PangoScriptIter *iter, char **start, char **end, PangoScript *script); gboolean pango_script_iter_next (PangoScriptIter *iter); void pango_script_iter_free (PangoScriptIter *iter); PangoLanguage *pango_script_get_sample_language (PangoScript script); gboolean pango_language_includes_script (PangoLanguage *language, PangoScript script); GType pango_attr_type_get_type (); GType pango_underline_get_type (); GType pango_coverage_level_get_type (); GType pango_style_get_type (); GType pango_variant_get_type (); GType pango_weight_get_type (); GType pango_stretch_get_type (); GType pango_font_mask_get_type (); GType pango_alignment_get_type (); GType pango_wrap_mode_get_type (); GType pango_ellipsize_mode_get_type (); GType pango_script_get_type (); GType pango_tab_align_get_type (); GType pango_direction_get_type (); alias _PangoGlyphItem PangoGlyphItem; struct _PangoGlyphItem { PangoItem *item; PangoGlyphString *glyphs; } PangoGlyphItem *pango_glyph_item_split (PangoGlyphItem *orig, char *text, int split_index); void pango_glyph_item_free (PangoGlyphItem *glyph_item); GSList * pango_glyph_item_apply_attrs (PangoGlyphItem *glyph_item, char *text, PangoAttrList *list); void pango_glyph_item_letter_space (PangoGlyphItem *glyph_item, char *text, PangoLogAttr *log_attrs, int letter_spacing); alias _PangoTabArray PangoTabArray; alias void _PangoTabArray; enum PangoTabAlign { PANGO_TAB_LEFT }; PangoTabArray *pango_tab_array_new (gint initial_size, gboolean positions_in_pixels); PangoTabArray *pango_tab_array_new_with_positions (gint size, gboolean positions_in_pixels, PangoTabAlign first_alignment, gint first_position, ...); GType pango_tab_array_get_type (); PangoTabArray *pango_tab_array_copy (PangoTabArray *src); void pango_tab_array_free (PangoTabArray *tab_array); gint pango_tab_array_get_size (PangoTabArray *tab_array); void pango_tab_array_resize (PangoTabArray *tab_array, gint new_size); void pango_tab_array_set_tab (PangoTabArray *tab_array, gint tab_index, PangoTabAlign alignment, gint location); void pango_tab_array_get_tab (PangoTabArray *tab_array, gint tab_index, PangoTabAlign *alignment, gint *location); void pango_tab_array_get_tabs (PangoTabArray *tab_array, PangoTabAlign **alignments, gint **locations); gboolean pango_tab_array_get_positions_in_pixels (PangoTabArray *tab_array); alias _PangoLayout PangoLayout; alias void _PangoLayout; alias _PangoLayoutClass PangoLayoutClass; alias void _PangoLayoutClass; alias _PangoLayoutLine PangoLayoutLine; alias PangoGlyphItem PangoLayoutRun; enum PangoAlignment { PANGO_ALIGN_LEFT, PANGO_ALIGN_CENTER, PANGO_ALIGN_RIGHT }; enum PangoWrapMode { PANGO_WRAP_WORD, PANGO_WRAP_CHAR, PANGO_WRAP_WORD_CHAR }; enum PangoEllipsizeMode { PANGO_ELLIPSIZE_NONE, PANGO_ELLIPSIZE_START, PANGO_ELLIPSIZE_MIDDLE, PANGO_ELLIPSIZE_END }; struct _PangoLayoutLine { PangoLayout *layout; gint start_index; gint length; GSList *runs; guint is_paragraph_start; guint resolved_dir; } GType pango_layout_get_type () ; PangoLayout *pango_layout_new (PangoContext *context); PangoLayout *pango_layout_copy (PangoLayout *src); PangoContext *pango_layout_get_context (PangoLayout *layout); void pango_layout_set_attributes (PangoLayout *layout, PangoAttrList *attrs); PangoAttrList *pango_layout_get_attributes (PangoLayout *layout); void pango_layout_set_text (PangoLayout *layout, char *text, int length); char *pango_layout_get_text (PangoLayout *layout); void pango_layout_set_markup (PangoLayout *layout, char *markup, int length); void pango_layout_set_markup_with_accel (PangoLayout *layout, char *markup, int length, gunichar accel_marker, gunichar *accel_char); void pango_layout_set_font_description (PangoLayout *layout, PangoFontDescription *desc); void pango_layout_set_width (PangoLayout *layout, int width); int pango_layout_get_width (PangoLayout *layout); void pango_layout_set_wrap (PangoLayout *layout, PangoWrapMode wrap); PangoWrapMode pango_layout_get_wrap (PangoLayout *layout); void pango_layout_set_indent (PangoLayout *layout, int indent); int pango_layout_get_indent (PangoLayout *layout); void pango_layout_set_spacing (PangoLayout *layout, int spacing); int pango_layout_get_spacing (PangoLayout *layout); void pango_layout_set_justify (PangoLayout *layout, gboolean justify); gboolean pango_layout_get_justify (PangoLayout *layout); void pango_layout_set_auto_dir (PangoLayout *layout, gboolean auto_dir); gboolean pango_layout_get_auto_dir (PangoLayout *layout); void pango_layout_set_alignment (PangoLayout *layout, PangoAlignment alignment); PangoAlignment pango_layout_get_alignment (PangoLayout *layout); void pango_layout_set_tabs (PangoLayout *layout, PangoTabArray *tabs); PangoTabArray* pango_layout_get_tabs (PangoLayout *layout); void pango_layout_set_single_paragraph_mode (PangoLayout *layout, gboolean setting); gboolean pango_layout_get_single_paragraph_mode (PangoLayout *layout); void pango_layout_set_ellipsize (PangoLayout *layout, PangoEllipsizeMode ellipsize); PangoEllipsizeMode pango_layout_get_ellipsize (PangoLayout *layout); void pango_layout_context_changed (PangoLayout *layout); void pango_layout_get_log_attrs (PangoLayout *layout, PangoLogAttr **attrs, gint *n_attrs); void pango_layout_index_to_pos (PangoLayout *layout, int index_, PangoRectangle *pos); void pango_layout_get_cursor_pos (PangoLayout *layout, int index_, PangoRectangle *strong_pos, PangoRectangle *weak_pos); void pango_layout_move_cursor_visually (PangoLayout *layout, gboolean strong, int old_index, int old_trailing, int direction, int *new_index, int *new_trailing); gboolean pango_layout_xy_to_index (PangoLayout *layout, int x, int y, int *index_, int *trailing); void pango_layout_get_extents (PangoLayout *layout, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_get_pixel_extents (PangoLayout *layout, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_get_size (PangoLayout *layout, int *width, int *height); void pango_layout_get_pixel_size (PangoLayout *layout, int *width, int *height); int pango_layout_get_line_count (PangoLayout *layout); PangoLayoutLine *pango_layout_get_line (PangoLayout *layout, int line); GSList * pango_layout_get_lines (PangoLayout *layout); void pango_layout_line_ref (PangoLayoutLine *line); void pango_layout_line_unref (PangoLayoutLine *line); gboolean pango_layout_line_x_to_index (PangoLayoutLine *line, int x_pos, int *index_, int *trailing); void pango_layout_line_index_to_x (PangoLayoutLine *line, int index_, gboolean trailing, int *x_pos); void pango_layout_line_get_x_ranges (PangoLayoutLine *line, int start_index, int end_index, int **ranges, int *n_ranges); void pango_layout_line_get_extents (PangoLayoutLine *line, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_line_get_pixel_extents (PangoLayoutLine *layout_line, PangoRectangle *ink_rect, PangoRectangle *logical_rect); alias _PangoLayoutIter PangoLayoutIter; alias void _PangoLayoutIter; GType pango_layout_iter_get_type (); PangoLayoutIter *pango_layout_get_iter (PangoLayout *layout); void pango_layout_iter_free (PangoLayoutIter *iter); int pango_layout_iter_get_index (PangoLayoutIter *iter); PangoLayoutRun *pango_layout_iter_get_run (PangoLayoutIter *iter); PangoLayoutLine *pango_layout_iter_get_line (PangoLayoutIter *iter); gboolean pango_layout_iter_at_last_line (PangoLayoutIter *iter); gboolean pango_layout_iter_next_char (PangoLayoutIter *iter); gboolean pango_layout_iter_next_cluster (PangoLayoutIter *iter); gboolean pango_layout_iter_next_run (PangoLayoutIter *iter); gboolean pango_layout_iter_next_line (PangoLayoutIter *iter); void pango_layout_iter_get_char_extents (PangoLayoutIter *iter, PangoRectangle *logical_rect); void pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_iter_get_run_extents (PangoLayoutIter *iter, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_iter_get_line_extents (PangoLayoutIter *iter, PangoRectangle *ink_rect, PangoRectangle *logical_rect); void pango_layout_iter_get_line_yrange (PangoLayoutIter *iter, int *y0_, int *y1_); void pango_layout_iter_get_layout_extents (PangoLayoutIter *iter, PangoRectangle *ink_rect, PangoRectangle *logical_rect); int pango_layout_iter_get_baseline (PangoLayoutIter *iter); alias _GdkPoint GdkPoint; alias _GdkRectangle GdkRectangle; alias _GdkSegment GdkSegment; alias _GdkSpan GdkSpan; alias guint32 GdkWChar; alias _GdkAtom *GdkAtom; alias void _GdkAtom; alias guint32 GdkNativeWindow; alias _GdkColor GdkColor; alias _GdkColormap GdkColormap; alias _GdkCursor GdkCursor; alias _GdkFont GdkFont; alias _GdkGC GdkGC; alias _GdkImage GdkImage; alias _GdkRegion GdkRegion; alias void _GdkRegion; alias _GdkVisual GdkVisual; alias _GdkDrawable GdkDrawable; alias _GdkDrawable GdkBitmap; alias _GdkDrawable GdkPixmap; alias _GdkDrawable GdkWindow; alias _GdkDisplay GdkDisplay; alias _GdkScreen GdkScreen; enum GdkByteOrder { GDK_LSB_FIRST, GDK_MSB_FIRST }; enum GdkModifierType { 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 << 30, GDK_MODIFIER_MASK = GDK_RELEASE_MASK | 0x1fff }; enum GdkInputCondition { GDK_INPUT_READ = 1 << 0, GDK_INPUT_WRITE = 1 << 1, GDK_INPUT_EXCEPTION = 1 << 2 }; enum GdkStatus { GDK_OK = 0, GDK_ERROR = -1, GDK_ERROR_PARAM = -2, GDK_ERROR_FILE = -3, GDK_ERROR_MEM = -4 }; enum GdkGrabStatus { GDK_GRAB_SUCCESS = 0, GDK_GRAB_ALREADY_GRABBED = 1, GDK_GRAB_INVALID_TIME = 2, GDK_GRAB_NOT_VIEWABLE = 3, GDK_GRAB_FROZEN = 4 }; alias void (*GdkInputFunction) (gpointer data, gint source, GdkInputCondition condition); alias void (*GdkDestroyNotify) (gpointer data); struct _GdkPoint { gint x; gint y; } struct _GdkRectangle { gint x; gint y; gint width; gint height; } struct _GdkSegment { gint x1; gint y1; gint x2; gint y2; } struct _GdkSpan { gint x; gint y; gint width; } struct _GdkColor { guint32 pixel; guint16 red; guint16 green; guint16 blue; } alias _GdkColormapClass GdkColormapClass; struct _GdkColormap { GObject parent_instance; gint size; GdkColor *colors; GdkVisual *visual; gpointer windowing_data; } struct _GdkColormapClass { GObjectClass parent_class; } GType gdk_colormap_get_type () ; 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 (); GdkScreen *gdk_colormap_get_screen (GdkColormap *cmap); gint gdk_colormap_get_system_size (); void gdk_colormap_change (GdkColormap *colormap, gint ncolors); 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); void gdk_colormap_query_color (GdkColormap *colormap, gulong pixel, GdkColor *result); GdkVisual *gdk_colormap_get_visual (GdkColormap *colormap); GdkColor *gdk_color_copy ( GdkColor *color); void gdk_color_free (GdkColor *color); gint gdk_color_parse ( gchar *spec, GdkColor *color); guint gdk_color_hash ( GdkColor *colora); gboolean gdk_color_equal ( GdkColor *colora, GdkColor *colorb); GType gdk_color_get_type (); void gdk_colors_store (GdkColormap *colormap, GdkColor *colors, gint ncolors); gint gdk_color_white (GdkColormap *colormap, GdkColor *color); gint gdk_color_black (GdkColormap *colormap, GdkColor *color); gint gdk_color_alloc (GdkColormap *colormap, GdkColor *color); gint gdk_color_change (GdkColormap *colormap, GdkColor *color); gint 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); guint gdk_pixbuf_major_version, gdk_pixbuf_minor_version, gdk_pixbuf_micro_version; char *gdk_pixbuf_version; enum GdkPixbufAlphaMode { GDK_PIXBUF_ALPHA_BILEVEL, GDK_PIXBUF_ALPHA_FULL }; enum GdkColorspace { GDK_COLORSPACE_RGB }; alias _GdkPixbuf GdkPixbuf; alias void _GdkPixbuf; alias _GdkPixbufAnimation GdkPixbufAnimation; alias void _GdkPixbufAnimation; alias _GdkPixbufAnimationIter GdkPixbufAnimationIter; alias void _GdkPixbufAnimationIter; alias void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data); enum GdkPixbufError { GDK_PIXBUF_ERROR_CORRUPT_IMAGE, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, GDK_PIXBUF_ERROR_BAD_OPTION, GDK_PIXBUF_ERROR_UNKNOWN_TYPE, GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION, GDK_PIXBUF_ERROR_FAILED }; GQuark gdk_pixbuf_error_quark () ; GType gdk_pixbuf_get_type () ; GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf); void gdk_pixbuf_unref (GdkPixbuf *pixbuf); GdkColorspace gdk_pixbuf_get_colorspace ( GdkPixbuf *pixbuf); int gdk_pixbuf_get_n_channels ( GdkPixbuf *pixbuf); gboolean gdk_pixbuf_get_has_alpha ( GdkPixbuf *pixbuf); int gdk_pixbuf_get_bits_per_sample ( GdkPixbuf *pixbuf); guchar *gdk_pixbuf_get_pixels ( GdkPixbuf *pixbuf); int gdk_pixbuf_get_width ( GdkPixbuf *pixbuf); int gdk_pixbuf_get_height ( GdkPixbuf *pixbuf); int gdk_pixbuf_get_rowstride ( GdkPixbuf *pixbuf); GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height); GdkPixbuf *gdk_pixbuf_copy ( GdkPixbuf *pixbuf); GdkPixbuf *gdk_pixbuf_new_subpixbuf (GdkPixbuf *src_pixbuf, int src_x, int src_y, int width, int height); GdkPixbuf *gdk_pixbuf_new_from_file ( char *filename, GError **error); GdkPixbuf *gdk_pixbuf_new_from_file_at_size ( char *filename, int width, int height, GError **error); GdkPixbuf *gdk_pixbuf_new_from_data ( guchar *data, GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height, int rowstride, GdkPixbufDestroyNotify destroy_fn, gpointer destroy_fn_data); GdkPixbuf *gdk_pixbuf_new_from_xpm_data ( char **data); GdkPixbuf* gdk_pixbuf_new_from_inline (gint data_length, guint8 *data, gboolean copy_pixels, GError **error); void gdk_pixbuf_fill (GdkPixbuf *pixbuf, guint32 pixel); gboolean gdk_pixbuf_save (GdkPixbuf *pixbuf, char *filename, char *type, GError **error, ...); gboolean gdk_pixbuf_savev (GdkPixbuf *pixbuf, char *filename, char *type, char **option_keys, char **option_values, GError **error); alias gboolean (*GdkPixbufSaveFunc) ( gchar *buf, gsize count, GError **error, gpointer data); gboolean gdk_pixbuf_save_to_callback (GdkPixbuf *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, char *type, GError **error, ...); gboolean gdk_pixbuf_save_to_callbackv (GdkPixbuf *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, char *type, char **option_keys, char **option_values, GError **error); gboolean gdk_pixbuf_save_to_buffer (GdkPixbuf *pixbuf, gchar **buffer, gsize *buffer_size, char *type, GError **error, ...); gboolean gdk_pixbuf_save_to_bufferv (GdkPixbuf *pixbuf, gchar **buffer, gsize *buffer_size, char *type, char **option_keys, char **option_values, GError **error); GdkPixbuf *gdk_pixbuf_add_alpha ( GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b); void gdk_pixbuf_copy_area ( GdkPixbuf *src_pixbuf, int src_x, int src_y, int width, int height, GdkPixbuf *dest_pixbuf, int dest_x, int dest_y); void gdk_pixbuf_saturate_and_pixelate ( GdkPixbuf *src, GdkPixbuf *dest, gfloat saturation, gboolean pixelate); enum GdkInterpType { GDK_INTERP_NEAREST, GDK_INTERP_TILES, GDK_INTERP_BILINEAR, GDK_INTERP_HYPER }; void gdk_pixbuf_scale ( GdkPixbuf *src, GdkPixbuf *dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, GdkInterpType interp_type); void gdk_pixbuf_composite ( GdkPixbuf *src, GdkPixbuf *dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, GdkInterpType interp_type, int overall_alpha); void gdk_pixbuf_composite_color ( GdkPixbuf *src, GdkPixbuf *dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, GdkInterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, guint32 color1, guint32 color2); GdkPixbuf *gdk_pixbuf_scale_simple ( GdkPixbuf *src, int dest_width, int dest_height, GdkInterpType interp_type); GdkPixbuf *gdk_pixbuf_composite_color_simple ( GdkPixbuf *src, int dest_width, int dest_height, GdkInterpType interp_type, int overall_alpha, int check_size, guint32 color1, guint32 color2); GType gdk_pixbuf_animation_get_type () ; GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file ( char *filename, GError **error); GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation); void gdk_pixbuf_animation_unref (GdkPixbufAnimation *animation); int gdk_pixbuf_animation_get_width (GdkPixbufAnimation *animation); int gdk_pixbuf_animation_get_height (GdkPixbufAnimation *animation); gboolean gdk_pixbuf_animation_is_static_image (GdkPixbufAnimation *animation); GdkPixbuf *gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation); GdkPixbufAnimationIter *gdk_pixbuf_animation_get_iter (GdkPixbufAnimation *animation, GTimeVal *start_time); GType gdk_pixbuf_animation_iter_get_type () ; int gdk_pixbuf_animation_iter_get_delay_time (GdkPixbufAnimationIter *iter); GdkPixbuf *gdk_pixbuf_animation_iter_get_pixbuf (GdkPixbufAnimationIter *iter); gboolean gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter); gboolean gdk_pixbuf_animation_iter_advance (GdkPixbufAnimationIter *iter, GTimeVal *current_time); gchar * gdk_pixbuf_get_option (GdkPixbuf *pixbuf, gchar *key); alias _GdkPixbufFormat GdkPixbufFormat; alias void _GdkPixbufFormat; GSList *gdk_pixbuf_get_formats (); gchar *gdk_pixbuf_format_get_name (GdkPixbufFormat *format); gchar *gdk_pixbuf_format_get_description (GdkPixbufFormat *format); gchar **gdk_pixbuf_format_get_mime_types (GdkPixbufFormat *format); gchar **gdk_pixbuf_format_get_extensions (GdkPixbufFormat *format); gboolean gdk_pixbuf_format_is_writable (GdkPixbufFormat *format); GdkPixbufFormat *gdk_pixbuf_get_file_info ( gchar *filename, gint *width, gint *height); alias _GdkPixbufLoader GdkPixbufLoader; struct _GdkPixbufLoader { GObject parent_instance; gpointer priv; } alias _GdkPixbufLoaderClass GdkPixbufLoaderClass; struct _GdkPixbufLoaderClass { GObjectClass parent_class; void (*size_prepared) (GdkPixbufLoader *loader, int width, int height); void (*area_prepared) (GdkPixbufLoader *loader); void (*area_updated) (GdkPixbufLoader *loader, int x, int y, int width, int height); void (*closed) (GdkPixbufLoader *loader); } GType gdk_pixbuf_loader_get_type () ; GdkPixbufLoader * gdk_pixbuf_loader_new (); GdkPixbufLoader * gdk_pixbuf_loader_new_with_type ( char *image_type, GError **error); GdkPixbufLoader * gdk_pixbuf_loader_new_with_mime_type ( char *mime_type, GError **error); void gdk_pixbuf_loader_set_size (GdkPixbufLoader *loader, int width, int height); gboolean gdk_pixbuf_loader_write (GdkPixbufLoader *loader, guchar *buf, gsize count, GError **error); GdkPixbuf * gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader); GdkPixbufAnimation * gdk_pixbuf_loader_get_animation (GdkPixbufLoader *loader); gboolean gdk_pixbuf_loader_close (GdkPixbufLoader *loader, GError **error); GdkPixbufFormat *gdk_pixbuf_loader_get_format (GdkPixbufLoader *loader); GType gdk_pixbuf_alpha_mode_get_type (); GType gdk_colorspace_get_type (); GType gdk_pixbuf_error_get_type (); GType gdk_interp_type_get_type (); enum GdkCursorType { 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, GDK_LAST_CURSOR, GDK_CURSOR_IS_PIXMAP = -1 }; struct _GdkCursor { GdkCursorType type; guint ref_count; } GType gdk_cursor_get_type (); GdkCursor* gdk_cursor_new_for_display (GdkDisplay *display, GdkCursorType cursor_type); 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); GdkCursor* gdk_cursor_new_from_pixbuf (GdkDisplay *display, GdkPixbuf *pixbuf, gint x, gint y); GdkDisplay* gdk_cursor_get_display (GdkCursor *cursor); GdkCursor* gdk_cursor_ref (GdkCursor *cursor); void gdk_cursor_unref (GdkCursor *cursor); alias _GdkDragContext GdkDragContext; enum GdkDragAction { 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 }; enum GdkDragProtocol { GDK_DRAG_PROTO_MOTIF, GDK_DRAG_PROTO_XDND, GDK_DRAG_PROTO_ROOTWIN, GDK_DRAG_PROTO_NONE, GDK_DRAG_PROTO_WIN32_DROPFILES, GDK_DRAG_PROTO_OLE2, GDK_DRAG_PROTO_LOCAL }; alias _GdkDragContextClass GdkDragContextClass; struct _GdkDragContext { GObject parent_instance; GdkDragProtocol protocol; gboolean is_source; GdkWindow *source_window; GdkWindow *dest_window; GList *targets; GdkDragAction actions; GdkDragAction suggested_action; GdkDragAction action; guint32 start_time; gpointer windowing_data; } struct _GdkDragContextClass { GObjectClass parent_class; } GType gdk_drag_context_get_type () ; GdkDragContext * gdk_drag_context_new (); 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_for_display (GdkDisplay *display, guint32 xid, GdkDragProtocol *protocol); void gdk_drag_find_window_for_screen (GdkDragContext *context, GdkWindow *drag_window, GdkScreen *screen, gint x_root, gint y_root, GdkWindow **dest_window, GdkDragProtocol *protocol); 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_); alias _GdkDeviceKey GdkDeviceKey; alias _GdkDeviceAxis GdkDeviceAxis; alias _GdkDevice GdkDevice; alias _GdkDeviceClass GdkDeviceClass; alias void _GdkDeviceClass; alias _GdkTimeCoord GdkTimeCoord; enum GdkExtensionMode { GDK_EXTENSION_EVENTS_NONE, GDK_EXTENSION_EVENTS_ALL, GDK_EXTENSION_EVENTS_CURSOR }; enum GdkInputSource { GDK_SOURCE_MOUSE, GDK_SOURCE_PEN, GDK_SOURCE_ERASER, GDK_SOURCE_CURSOR }; enum GdkInputMode { GDK_MODE_DISABLED, GDK_MODE_SCREEN, GDK_MODE_WINDOW }; enum GdkAxisUse { GDK_AXIS_IGNORE, GDK_AXIS_X, GDK_AXIS_Y, GDK_AXIS_PRESSURE, GDK_AXIS_XTILT, GDK_AXIS_YTILT, GDK_AXIS_WHEEL, GDK_AXIS_LAST }; struct _GdkDeviceKey { guint keyval; GdkModifierType modifiers; } struct _GdkDeviceAxis { GdkAxisUse use; gdouble min; gdouble max; } struct _GdkDevice { GObject parent_instance; gchar *name; GdkInputSource source; GdkInputMode mode; gboolean has_cursor; gint num_axes; GdkDeviceAxis *axes; gint num_keys; GdkDeviceKey *keys; } struct _GdkTimeCoord { guint32 time; gdouble axes[128]; } GType gdk_device_get_type (); GList * gdk_devices_list (); void gdk_device_set_source (GdkDevice *device, GdkInputSource source); gboolean gdk_device_set_mode (GdkDevice *device, GdkInputMode mode); void gdk_device_set_key (GdkDevice *device, guint index_, guint keyval, GdkModifierType modifiers); void gdk_device_set_axis_use (GdkDevice *device, guint index_, GdkAxisUse use); void gdk_device_get_state (GdkDevice *device, GdkWindow *window, gdouble *axes, GdkModifierType *mask); gboolean gdk_device_get_history (GdkDevice *device, GdkWindow *window, guint32 start, guint32 stop, GdkTimeCoord ***events, gint *n_events); void gdk_device_free_history (GdkTimeCoord **events, gint n_events); gboolean gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value); void gdk_input_set_extension_events (GdkWindow *window, gint mask, GdkExtensionMode mode); GdkDevice *gdk_device_get_core_pointer (); alias _GdkEventAny GdkEventAny; alias _GdkEventExpose GdkEventExpose; alias _GdkEventNoExpose GdkEventNoExpose; alias _GdkEventVisibility GdkEventVisibility; alias _GdkEventMotion GdkEventMotion; alias _GdkEventButton GdkEventButton; alias _GdkEventScroll GdkEventScroll; alias _GdkEventKey GdkEventKey; alias _GdkEventFocus GdkEventFocus; alias _GdkEventCrossing GdkEventCrossing; alias _GdkEventConfigure GdkEventConfigure; alias _GdkEventProperty GdkEventProperty; alias _GdkEventSelection GdkEventSelection; alias _GdkEventProximity GdkEventProximity; alias _GdkEventClient GdkEventClient; alias _GdkEventDND GdkEventDND; alias _GdkEventWindowState GdkEventWindowState; alias _GdkEventSetting GdkEventSetting; alias _GdkEvent GdkEvent; alias void (*GdkEventFunc) (GdkEvent *event, gpointer data); alias void GdkXEvent; enum GdkFilterReturn { GDK_FILTER_CONTINUE, GDK_FILTER_TRANSLATE, GDK_FILTER_REMOVE }; alias GdkFilterReturn (*GdkFilterFunc) (GdkXEvent *xevent, GdkEvent *event, gpointer data); enum GdkEventType { 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, GDK_SCROLL = 31, GDK_WINDOW_STATE = 32, GDK_SETTING = 33 }; enum GdkEventMask { 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_SCROLL_MASK = 1 << 21, GDK_ALL_EVENTS_MASK = 0x3FFFFE }; enum GdkVisibilityState { GDK_VISIBILITY_UNOBSCURED, GDK_VISIBILITY_PARTIAL, GDK_VISIBILITY_FULLY_OBSCURED }; enum GdkScrollDirection { GDK_SCROLL_UP, GDK_SCROLL_DOWN, GDK_SCROLL_LEFT, GDK_SCROLL_RIGHT }; enum GdkNotifyType { 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 }; enum GdkCrossingMode { GDK_CROSSING_NORMAL, GDK_CROSSING_GRAB, GDK_CROSSING_UNGRAB }; enum GdkPropertyState { GDK_PROPERTY_NEW_VALUE, GDK_PROPERTY_DELETE }; enum GdkWindowState { GDK_WINDOW_STATE_WITHDRAWN = 1 << 0, GDK_WINDOW_STATE_ICONIFIED = 1 << 1, GDK_WINDOW_STATE_MAXIMIZED = 1 << 2, GDK_WINDOW_STATE_STICKY = 1 << 3, GDK_WINDOW_STATE_FULLSCREEN = 1 << 4, GDK_WINDOW_STATE_ABOVE = 1 << 5, GDK_WINDOW_STATE_BELOW = 1 << 6 }; enum GdkSettingAction { GDK_SETTING_ACTION_NEW, GDK_SETTING_ACTION_CHANGED, GDK_SETTING_ACTION_DELETED }; struct _GdkEventAny { GdkEventType type; GdkWindow *window; gint8 send_event; } struct _GdkEventExpose { GdkEventType type; GdkWindow *window; gint8 send_event; GdkRectangle area; GdkRegion *region; 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 *axes; guint state; gint16 is_hint; GdkDevice *device; gdouble x_root, y_root; } struct _GdkEventButton { GdkEventType type; GdkWindow *window; gint8 send_event; guint32 time; gdouble x; gdouble y; gdouble *axes; guint state; guint button; GdkDevice *device; gdouble x_root, y_root; } struct _GdkEventScroll { GdkEventType type; GdkWindow *window; gint8 send_event; guint32 time; gdouble x; gdouble y; guint state; GdkScrollDirection direction; GdkDevice *device; gdouble x_root, y_root; } struct _GdkEventKey { GdkEventType type; GdkWindow *window; gint8 send_event; guint32 time; guint state; guint keyval; gint length; gchar *string; guint16 hardware_keycode; guint8 group; } 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; gint x, y; gint width; gint 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 time; GdkNativeWindow requestor; } struct _GdkEventProximity { GdkEventType type; GdkWindow *window; gint8 send_event; guint32 time; GdkDevice *device; } struct _GdkEventClient { GdkEventType type; GdkWindow *window; gint8 send_event; GdkAtom message_type; gushort data_format; union data_union { char b[20]; short s[10]; int l[5]; } data_union data; } struct _GdkEventSetting { GdkEventType type; GdkWindow *window; gint8 send_event; GdkSettingAction action; char *name; } struct _GdkEventWindowState { GdkEventType type; GdkWindow *window; gint8 send_event; GdkWindowState changed_mask; GdkWindowState new_window_state; } 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; GdkEventScroll scroll; GdkEventKey key; GdkEventCrossing crossing; GdkEventFocus focus_change; GdkEventConfigure configure; GdkEventProperty property; GdkEventSelection selection; GdkEventProximity proximity; GdkEventClient client; GdkEventDND dnd; GdkEventWindowState window_state; GdkEventSetting setting; } GType gdk_event_get_type (); gboolean gdk_events_pending (); GdkEvent* gdk_event_get (); GdkEvent* gdk_event_peek (); GdkEvent* gdk_event_get_graphics_expose (GdkWindow *window); void gdk_event_put (GdkEvent *event); GdkEvent* gdk_event_new (GdkEventType type); GdkEvent* gdk_event_copy (GdkEvent *event); void gdk_event_free (GdkEvent *event); guint32 gdk_event_get_time (GdkEvent *event); gboolean gdk_event_get_state (GdkEvent *event, GdkModifierType *state); gboolean gdk_event_get_coords (GdkEvent *event, gdouble *x_win, gdouble *y_win); gboolean gdk_event_get_root_coords (GdkEvent *event, gdouble *x_root, gdouble *y_root); gboolean gdk_event_get_axis (GdkEvent *event, GdkAxisUse axis_use, gdouble *value); void gdk_event_handler_set (GdkEventFunc func, gpointer data, GDestroyNotify notify); void gdk_event_set_screen (GdkEvent *event, GdkScreen *screen); GdkScreen *gdk_event_get_screen (GdkEvent *event); void gdk_set_show_events (gboolean show_events); gboolean gdk_get_show_events (); void gdk_add_client_message_filter (GdkAtom message_type, GdkFilterFunc func, gpointer data); gboolean gdk_setting_get ( gchar *name, GValue *value); alias _GdkDisplayClass GdkDisplayClass; alias _GdkDisplayPointerHooks GdkDisplayPointerHooks; struct _GdkDisplay { GObject parent_instance; GList *queued_events; GList *queued_tail; guint32 button_click_time[2]; GdkWindow *button_window[2]; gint button_number[2]; guint double_click_time; GdkDevice *core_pointer; GdkDisplayPointerHooks *pointer_hooks; guint closed; guint double_click_distance; gint button_x[2]; gint button_y[2]; } struct _GdkDisplayClass { GObjectClass parent_class; gchar * (*get_display_name) (GdkDisplay *display); gint (*get_n_screens) (GdkDisplay *display); GdkScreen * (*get_screen) (GdkDisplay *display, gint screen_num); GdkScreen * (*get_default_screen) (GdkDisplay *display); void (*closed) (GdkDisplay *display, gboolean is_error); } struct _GdkDisplayPointerHooks { void (*get_pointer) (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask); GdkWindow* (*window_get_pointer) (GdkDisplay *display, GdkWindow *window, gint *x, gint *y, GdkModifierType *mask); GdkWindow* (*window_at_pointer) (GdkDisplay *display, gint *win_x, gint *win_y); } GType gdk_display_get_type (); GdkDisplay *gdk_display_open ( gchar *display_name); gchar * gdk_display_get_name (GdkDisplay *display); gint gdk_display_get_n_screens (GdkDisplay *display); GdkScreen * gdk_display_get_screen (GdkDisplay *display, gint screen_num); GdkScreen * gdk_display_get_default_screen (GdkDisplay *display); void gdk_display_pointer_ungrab (GdkDisplay *display, guint32 time_); void gdk_display_keyboard_ungrab (GdkDisplay *display, guint32 time_); gboolean gdk_display_pointer_is_grabbed (GdkDisplay *display); void gdk_display_beep (GdkDisplay *display); void gdk_display_sync (GdkDisplay *display); void gdk_display_flush (GdkDisplay *display); void gdk_display_close (GdkDisplay *display); GList * gdk_display_list_devices (GdkDisplay *display); GdkEvent* gdk_display_get_event (GdkDisplay *display); GdkEvent* gdk_display_peek_event (GdkDisplay *display); void gdk_display_put_event (GdkDisplay *display, GdkEvent *event); void gdk_display_add_client_message_filter (GdkDisplay *display, GdkAtom message_type, GdkFilterFunc func, gpointer data); void gdk_display_set_double_click_time (GdkDisplay *display, guint msec); void gdk_display_set_double_click_distance (GdkDisplay *display, guint distance); GdkDisplay *gdk_display_get_default (); GdkDevice *gdk_display_get_core_pointer (GdkDisplay *display); void gdk_display_get_pointer (GdkDisplay *display, GdkScreen **screen, gint *x, gint *y, GdkModifierType *mask); GdkWindow * gdk_display_get_window_at_pointer (GdkDisplay *display, gint *win_x, gint *win_y); GdkDisplayPointerHooks *gdk_display_set_pointer_hooks (GdkDisplay *display, GdkDisplayPointerHooks *new_hooks); GdkDisplay *gdk_display_open_default_libgtk_only (); gboolean gdk_display_supports_cursor_alpha (GdkDisplay *display); gboolean gdk_display_supports_cursor_color (GdkDisplay *display); guint gdk_display_get_default_cursor_size (GdkDisplay *display); void gdk_display_get_maximal_cursor_size (GdkDisplay *display, guint *width, guint *height); GdkWindow *gdk_display_get_default_group (GdkDisplay *display); alias _GdkGCValues GdkGCValues; alias _GdkGCClass GdkGCClass; enum GdkCapStyle { GDK_CAP_NOT_LAST, GDK_CAP_BUTT, GDK_CAP_ROUND, GDK_CAP_PROJECTING }; enum GdkFill { GDK_SOLID, GDK_TILED, GDK_STIPPLED, GDK_OPAQUE_STIPPLED }; enum GdkFunction { 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_NOR, GDK_SET }; enum GdkJoinStyle { GDK_JOIN_MITER, GDK_JOIN_ROUND, GDK_JOIN_BEVEL }; enum GdkLineStyle { GDK_LINE_SOLID, GDK_LINE_ON_OFF_DASH, GDK_LINE_DOUBLE_DASH }; enum GdkSubwindowMode { GDK_CLIP_BY_CHILDREN = 0, GDK_INCLUDE_INFERIORS = 1 }; enum GdkGCValuesMask { 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 }; 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 { GObject parent_instance; gint clip_x_origin; gint clip_y_origin; gint ts_x_origin; gint ts_y_origin; GdkColormap *colormap; } struct _GdkGCClass { GObjectClass parent_class; void (*get_values) (GdkGC *gc, GdkGCValues *values); void (*set_values) (GdkGC *gc, GdkGCValues *values, GdkGCValuesMask mask); void (*set_dashes) (GdkGC *gc, gint dash_offset, gint8* dash_list, gint n); void (*_gdk_reserved1) (); void (*_gdk_reserved2) (); void (*_gdk_reserved3) (); void (*_gdk_reserved4) (); } GType gdk_gc_get_type () ; GdkGC *gdk_gc_new (GdkDrawable *drawable); GdkGC *gdk_gc_new_with_values (GdkDrawable *drawable, GdkGCValues *values, GdkGCValuesMask values_mask); GdkGC *gdk_gc_ref (GdkGC *gc); void gdk_gc_unref (GdkGC *gc); void gdk_gc_get_values (GdkGC *gc, GdkGCValues *values); void gdk_gc_set_values (GdkGC *gc, GdkGCValues *values, GdkGCValuesMask values_mask); 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_offset (GdkGC *gc, gint x_offset, gint y_offset); void gdk_gc_copy (GdkGC *dst_gc, GdkGC *src_gc); void gdk_gc_set_colormap (GdkGC *gc, GdkColormap *colormap); GdkColormap *gdk_gc_get_colormap (GdkGC *gc); void gdk_gc_set_rgb_fg_color (GdkGC *gc, GdkColor *color); void gdk_gc_set_rgb_bg_color (GdkGC *gc, GdkColor *color); GdkScreen * gdk_gc_get_screen (GdkGC *gc); alias _GdkRgbCmap GdkRgbCmap; struct _GdkRgbCmap { guint32 colors[256]; gint n_colors; GSList *info_list; } void gdk_rgb_init (); 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); void gdk_rgb_find_color (GdkColormap *colormap, GdkColor *color); enum GdkRgbDither { GDK_RGB_DITHER_NONE, GDK_RGB_DITHER_NORMAL, GDK_RGB_DITHER_MAX }; 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_rgb_32_image_dithalign (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar *buf, gint rowstride, gint xdith, gint ydith); void gdk_draw_gray_image (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar *buf, gint rowstride); 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); GdkRgbCmap *gdk_rgb_cmap_new (guint32 *colors, gint n_colors); void gdk_rgb_cmap_free (GdkRgbCmap *cmap); 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_colormap (); GdkVisual * gdk_rgb_get_visual (); gboolean gdk_rgb_ditherable (); alias _GdkDrawableClass GdkDrawableClass; struct _GdkDrawable { GObject parent_instance; } struct _GdkDrawableClass { GObjectClass parent_class; GdkGC *(*create_gc) (GdkDrawable *drawable, GdkGCValues *values, GdkGCValuesMask mask); void (*draw_rectangle) (GdkDrawable *drawable, GdkGC *gc, gboolean filled, gint x, gint y, gint width, gint height); void (*draw_arc) (GdkDrawable *drawable, GdkGC *gc, gboolean filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2); void (*draw_polygon) (GdkDrawable *drawable, GdkGC *gc, gboolean filled, GdkPoint *points, gint npoints); void (*draw_text) (GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, gchar *text, gint text_length); void (*draw_text_wc) (GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, GdkWChar *text, gint text_length); void (*draw_drawable) (GdkDrawable *drawable, GdkGC *gc, GdkDrawable *src, gint xsrc, gint ysrc, gint xdest, gint ydest, gint width, gint height); void (*draw_points) (GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints); void (*draw_segments) (GdkDrawable *drawable, GdkGC *gc, GdkSegment *segs, gint nsegs); void (*draw_lines) (GdkDrawable *drawable, GdkGC *gc, GdkPoint *points, gint npoints); void (*draw_glyphs) (GdkDrawable *drawable, GdkGC *gc, PangoFont *font, gint x, gint y, PangoGlyphString *glyphs); void (*draw_image) (GdkDrawable *drawable, GdkGC *gc, GdkImage *image, gint xsrc, gint ysrc, gint xdest, gint ydest, gint width, gint height); gint (*get_depth) (GdkDrawable *drawable); void (*get_size) (GdkDrawable *drawable, gint *width, gint *height); void (*set_colormap) (GdkDrawable *drawable, GdkColormap *cmap); GdkColormap* (*get_colormap) (GdkDrawable *drawable); GdkVisual* (*get_visual) (GdkDrawable *drawable); GdkScreen* (*get_screen) (GdkDrawable *drawable); GdkImage* (*get_image) (GdkDrawable *drawable, gint x, gint y, gint width, gint height); GdkRegion* (*get_clip_region) (GdkDrawable *drawable); GdkRegion* (*get_visible_region) (GdkDrawable *drawable); GdkDrawable* (*get_composite_drawable) (GdkDrawable *drawable, gint x, gint y, gint width, gint height, gint *composite_x_offset, gint *composite_y_offset); void (*draw_pixbuf) (GdkDrawable *drawable, GdkGC *gc, GdkPixbuf *pixbuf, gint src_x, gint src_y, gint dest_x, gint dest_y, gint width, gint height, GdkRgbDither dither, gint x_dither, gint y_dither); GdkImage* (*_copy_to_image) (GdkDrawable *drawable, GdkImage *image, gint src_x, gint src_y, gint dest_x, gint dest_y, gint width, gint height); void (*_gdk_reserved1) (); void (*_gdk_reserved2) (); void (*_gdk_reserved3) (); void (*_gdk_reserved4) (); void (*_gdk_reserved5) (); void (*_gdk_reserved6) (); void (*_gdk_reserved7) (); void (*_gdk_reserved9) (); void (*_gdk_reserved10) (); void (*_gdk_reserved11) (); void (*_gdk_reserved12) (); void (*_gdk_reserved13) (); void (*_gdk_reserved14) (); void (*_gdk_reserved15) (); void (*_gdk_reserved16) (); } GType gdk_drawable_get_type (); void gdk_drawable_set_data (GdkDrawable *drawable, gchar *key, gpointer data, GDestroyNotify destroy_func); gpointer gdk_drawable_get_data (GdkDrawable *drawable, gchar *key); void gdk_drawable_get_size (GdkDrawable *drawable, gint *width, gint *height); void gdk_drawable_set_colormap (GdkDrawable *drawable, GdkColormap *colormap); GdkColormap* gdk_drawable_get_colormap (GdkDrawable *drawable); GdkVisual* gdk_drawable_get_visual (GdkDrawable *drawable); gint gdk_drawable_get_depth (GdkDrawable *drawable); GdkScreen* gdk_drawable_get_screen (GdkDrawable *drawable); GdkDisplay* gdk_drawable_get_display (GdkDrawable *drawable); GdkDrawable* gdk_drawable_ref (GdkDrawable *drawable); void gdk_drawable_unref (GdkDrawable *drawable); 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, gboolean filled, gint x, gint y, gint width, gint height); void gdk_draw_arc (GdkDrawable *drawable, GdkGC *gc, gboolean filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2); void gdk_draw_polygon (GdkDrawable *drawable, GdkGC *gc, gboolean filled, GdkPoint *points, gint npoints); void gdk_draw_string (GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, gchar *string); void gdk_draw_text (GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, gchar *text, gint text_length); void gdk_draw_text_wc (GdkDrawable *drawable, GdkFont *font, GdkGC *gc, gint x, gint y, GdkWChar *text, gint text_length); void gdk_draw_drawable (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); void gdk_draw_pixbuf (GdkDrawable *drawable, GdkGC *gc, GdkPixbuf *pixbuf, gint src_x, gint src_y, gint dest_x, gint dest_y, gint width, gint height, GdkRgbDither dither, gint x_dither, gint y_dither); void gdk_draw_glyphs (GdkDrawable *drawable, GdkGC *gc, PangoFont *font, gint x, gint y, PangoGlyphString *glyphs); void gdk_draw_layout_line (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, PangoLayoutLine *line); void gdk_draw_layout (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, PangoLayout *layout); void gdk_draw_layout_line_with_colors (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, PangoLayoutLine *line, GdkColor *foreground, GdkColor *background); void gdk_draw_layout_with_colors (GdkDrawable *drawable, GdkGC *gc, gint x, gint y, PangoLayout *layout, GdkColor *foreground, GdkColor *background); GdkImage* gdk_drawable_get_image (GdkDrawable *drawable, gint x, gint y, gint width, gint height); GdkImage *gdk_drawable_copy_to_image (GdkDrawable *drawable, GdkImage *image, gint src_x, gint src_y, gint dest_x, gint dest_y, gint width, gint height); GdkRegion *gdk_drawable_get_clip_region (GdkDrawable *drawable); GdkRegion *gdk_drawable_get_visible_region (GdkDrawable *drawable); GType gdk_cursor_type_get_type (); GType gdk_drag_action_get_type (); GType gdk_drag_protocol_get_type (); GType gdk_filter_return_get_type (); GType gdk_event_type_get_type (); GType gdk_event_mask_get_type (); GType gdk_visibility_state_get_type (); GType gdk_scroll_direction_get_type (); GType gdk_notify_type_get_type (); GType gdk_crossing_mode_get_type (); GType gdk_property_state_get_type (); GType gdk_window_state_get_type (); GType gdk_setting_action_get_type (); GType gdk_font_type_get_type (); GType gdk_cap_style_get_type (); GType gdk_fill_get_type (); GType gdk_function_get_type (); GType gdk_join_style_get_type (); GType gdk_line_style_get_type (); GType gdk_subwindow_mode_get_type (); GType gdk_gc_values_mask_get_type (); GType gdk_image_type_get_type (); GType gdk_extension_mode_get_type (); GType gdk_input_source_get_type (); GType gdk_input_mode_get_type (); GType gdk_axis_use_get_type (); GType gdk_prop_mode_get_type (); GType gdk_fill_rule_get_type (); GType gdk_overlap_type_get_type (); GType gdk_rgb_dither_get_type (); GType gdk_byte_order_get_type (); GType gdk_modifier_type_get_type (); GType gdk_input_condition_get_type (); GType gdk_status_get_type (); GType gdk_grab_status_get_type (); GType gdk_visual_type_get_type (); GType gdk_window_class_get_type (); GType gdk_window_type_get_type (); GType gdk_window_attributes_type_get_type (); GType gdk_window_hints_get_type (); GType gdk_window_type_hint_get_type (); GType gdk_wm_decoration_get_type (); GType gdk_wm_function_get_type (); GType gdk_gravity_get_type (); GType gdk_window_edge_get_type (); enum GdkFontType { GDK_FONT_FONT, GDK_FONT_FONTSET }; struct _GdkFont { GdkFontType type; gint ascent; gint descent; } GType gdk_font_get_type (); GdkFont* gdk_font_ref (GdkFont *font); void gdk_font_unref (GdkFont *font); gint gdk_font_id ( GdkFont *font); gboolean gdk_font_equal ( GdkFont *fonta, GdkFont *fontb); GdkFont *gdk_font_load_for_display (GdkDisplay *display, gchar *font_name); GdkFont *gdk_fontset_load_for_display (GdkDisplay *display, gchar *fontset_name); GdkFont *gdk_font_from_description_for_display (GdkDisplay *display, PangoFontDescription *font_desc); GdkFont* gdk_font_load ( gchar *font_name); GdkFont* gdk_fontset_load ( gchar *fontset_name); GdkFont* gdk_font_from_description (PangoFontDescription *font_desc); gint gdk_string_width (GdkFont *font, gchar *string); gint gdk_text_width (GdkFont *font, gchar *text, gint text_length); gint gdk_text_width_wc (GdkFont *font, 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, gchar *string); gint gdk_text_measure (GdkFont *font, gchar *text, gint text_length); gint gdk_char_measure (GdkFont *font, gchar character); gint gdk_string_height (GdkFont *font, gchar *string); gint gdk_text_height (GdkFont *font, gchar *text, gint text_length); gint gdk_char_height (GdkFont *font, gchar character); void gdk_text_extents (GdkFont *font, gchar *text, gint text_length, gint *lbearing, gint *rbearing, gint *width, gint *ascent, gint *descent); void gdk_text_extents_wc (GdkFont *font, GdkWChar *text, gint text_length, gint *lbearing, gint *rbearing, gint *width, gint *ascent, gint *descent); void gdk_string_extents (GdkFont *font, gchar *string, gint *lbearing, gint *rbearing, gint *width, gint *ascent, gint *descent); GdkDisplay * gdk_font_get_display (GdkFont *font); enum GdkImageType { GDK_IMAGE_NORMAL, GDK_IMAGE_SHARED, GDK_IMAGE_FASTEST }; alias _GdkImageClass GdkImageClass; struct _GdkImage { GObject parent_instance; GdkImageType type; GdkVisual *visual; GdkByteOrder byte_order; gint width; gint height; guint16 depth; guint16 bpp; guint16 bpl; guint16 bits_per_pixel; gpointer mem; GdkColormap *colormap; gpointer windowing_data; } struct _GdkImageClass { GObjectClass parent_class; } GType gdk_image_get_type () ; GdkImage* gdk_image_new (GdkImageType type, GdkVisual *visual, gint width, gint height); GdkImage* gdk_image_get (GdkDrawable *drawable, gint x, gint y, gint width, gint height); GdkImage * gdk_image_ref (GdkImage *image); void gdk_image_unref (GdkImage *image); 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_set_colormap (GdkImage *image, GdkColormap *colormap); GdkColormap* gdk_image_get_colormap (GdkImage *image); alias _GdkKeymapKey GdkKeymapKey; struct _GdkKeymapKey { guint keycode; gint group; gint level; } alias _GdkKeymap GdkKeymap; alias _GdkKeymapClass GdkKeymapClass; struct _GdkKeymap { GObject parent_instance; GdkDisplay *display; } struct _GdkKeymapClass { GObjectClass parent_class; void (*direction_changed) (GdkKeymap *keymap); void (*keys_changed) (GdkKeymap *keymap); } GType gdk_keymap_get_type () ; GdkKeymap* gdk_keymap_get_default (); GdkKeymap* gdk_keymap_get_for_display (GdkDisplay *display); guint gdk_keymap_lookup_key (GdkKeymap *keymap, GdkKeymapKey *key); gboolean gdk_keymap_translate_keyboard_state (GdkKeymap *keymap, guint hardware_keycode, GdkModifierType state, gint group, guint *keyval, gint *effective_group, gint *level, GdkModifierType *consumed_modifiers); gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap, guint keyval, GdkKeymapKey **keys, gint *n_keys); gboolean gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap, guint hardware_keycode, GdkKeymapKey **keys, guint **keyvals, gint *n_entries); PangoDirection gdk_keymap_get_direction (GdkKeymap *keymap); gchar* gdk_keyval_name (guint keyval) ; guint gdk_keyval_from_name ( gchar *keyval_name); void gdk_keyval_convert_case (guint symbol, guint *lower, guint *upper); 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) ; guint32 gdk_keyval_to_unicode (guint keyval) ; guint gdk_unicode_to_keyval (guint32 wc) ; alias _GdkDisplayManager GdkDisplayManager; alias void _GdkDisplayManager; alias _GdkDisplayManagerClass GdkDisplayManagerClass; struct _GdkDisplayManagerClass { GObjectClass parent_class; void (*display_opened) (GdkDisplayManager *display_manager, GdkDisplay *display); } GType gdk_display_manager_get_type () ; GdkDisplayManager *gdk_display_manager_get (); GdkDisplay * gdk_display_manager_get_default_display (GdkDisplayManager *display_manager); void gdk_display_manager_set_default_display (GdkDisplayManager *display_manager, GdkDisplay *display); GSList * gdk_display_manager_list_displays (GdkDisplayManager *display_manager); PangoContext *gdk_pango_context_get_for_screen (GdkScreen *screen); PangoContext *gdk_pango_context_get (); void gdk_pango_context_set_colormap (PangoContext *context, GdkColormap *colormap); GdkRegion *gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line, gint x_origin, gint y_origin, gint *index_ranges, gint n_ranges); GdkRegion *gdk_pango_layout_get_clip_region (PangoLayout *layout, gint x_origin, gint y_origin, gint *index_ranges, gint n_ranges); alias _GdkPangoAttrStipple GdkPangoAttrStipple; alias _GdkPangoAttrEmbossed GdkPangoAttrEmbossed; struct _GdkPangoAttrStipple { PangoAttribute attr; GdkBitmap *stipple; } struct _GdkPangoAttrEmbossed { PangoAttribute attr; gboolean embossed; } PangoAttribute *gdk_pango_attr_stipple_new (GdkBitmap *stipple); PangoAttribute *gdk_pango_attr_embossed_new (gboolean embossed); void gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height, int alpha_threshold); void gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, GdkDrawable *drawable, GdkGC *gc, int src_x, int src_y, int dest_x, int dest_y, int width, int height, GdkRgbDither dither, int x_dither, int y_dither); void gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, int src_x, int src_y, int dest_x, int dest_y, int width, int height, GdkPixbufAlphaMode alpha_mode, int alpha_threshold, GdkRgbDither dither, int x_dither, int y_dither); void gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf *pixbuf, GdkColormap *colormap, GdkPixmap **pixmap_return, GdkBitmap **mask_return, int alpha_threshold); void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, GdkPixmap **pixmap_return, GdkBitmap **mask_return, int alpha_threshold); GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, GdkDrawable *src, GdkColormap *cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); GdkPixbuf *gdk_pixbuf_get_from_image (GdkPixbuf *dest, GdkImage *src, GdkColormap *cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); alias _GdkPixmapObject GdkPixmapObject; alias _GdkPixmapObjectClass GdkPixmapObjectClass; struct _GdkPixmapObject { GdkDrawable parent_instance; GdkDrawable *impl; gint depth; } struct _GdkPixmapObjectClass { GdkDrawableClass parent_class; } GType gdk_pixmap_get_type () ; GdkPixmap* gdk_pixmap_new (GdkDrawable *drawable, gint width, gint height, gint depth); GdkBitmap* gdk_bitmap_create_from_data (GdkDrawable *drawable, gchar *data, gint width, gint height); GdkPixmap* gdk_pixmap_create_from_data (GdkDrawable *drawable, gchar *data, gint width, gint height, gint depth, GdkColor *fg, GdkColor *bg); GdkPixmap* gdk_pixmap_create_from_xpm (GdkDrawable *drawable, GdkBitmap **mask, GdkColor *transparent_color, gchar *filename); GdkPixmap* gdk_pixmap_colormap_create_from_xpm (GdkDrawable *drawable, GdkColormap *colormap, GdkBitmap **mask, GdkColor *transparent_color, gchar *filename); GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkDrawable *drawable, GdkBitmap **mask, GdkColor *transparent_color, gchar **data); GdkPixmap* gdk_pixmap_colormap_create_from_xpm_d (GdkDrawable *drawable, GdkColormap *colormap, GdkBitmap **mask, GdkColor *transparent_color, gchar **data); GdkPixmap* gdk_pixmap_foreign_new (GdkNativeWindow anid); GdkPixmap* gdk_pixmap_lookup (GdkNativeWindow anid); GdkPixmap* gdk_pixmap_foreign_new_for_display (GdkDisplay *display, GdkNativeWindow anid); GdkPixmap* gdk_pixmap_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid); enum GdkPropMode { GDK_PROP_MODE_REPLACE, GDK_PROP_MODE_PREPEND, GDK_PROP_MODE_APPEND }; GdkAtom gdk_atom_intern ( gchar *atom_name, gboolean 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); gint gdk_text_property_to_text_list (GdkAtom encoding, gint format, guchar *text, gint length, gchar ***list); gint gdk_text_property_to_utf8_list (GdkAtom encoding, gint format, guchar *text, gint length, gchar ***list); gboolean gdk_utf8_to_compound_text ( gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length); gint gdk_string_to_compound_text ( gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length); gint gdk_text_property_to_text_list_for_display (GdkDisplay *display, GdkAtom encoding, gint format, guchar *text, gint length, gchar ***list); gint gdk_text_property_to_utf8_list_for_display (GdkDisplay *display, GdkAtom encoding, gint format, guchar *text, gint length, gchar ***list); gchar *gdk_utf8_to_string_target ( gchar *str); gint gdk_string_to_compound_text_for_display (GdkDisplay *display, gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length); gboolean gdk_utf8_to_compound_text_for_display (GdkDisplay *display, gchar *str, GdkAtom *encoding, gint *format, guchar **ctext, gint *length); void gdk_free_text_list (gchar **list); void gdk_free_compound_text (guchar *ctext); enum GdkFillRule { GDK_EVEN_ODD_RULE, GDK_WINDING_RULE }; enum GdkOverlapType { GDK_OVERLAP_RECTANGLE_IN, GDK_OVERLAP_RECTANGLE_OUT, GDK_OVERLAP_RECTANGLE_PART }; alias void (*GdkSpanFunc) (GdkSpan *span, gpointer data); GdkRegion *gdk_region_new (); GdkRegion *gdk_region_polygon (GdkPoint *points, gint npoints, GdkFillRule fill_rule); GdkRegion *gdk_region_copy (GdkRegion *region); GdkRegion *gdk_region_rectangle (GdkRectangle *rectangle); void gdk_region_destroy (GdkRegion *region); void gdk_region_get_clipbox (GdkRegion *region, GdkRectangle *rectangle); void gdk_region_get_rectangles (GdkRegion *region, GdkRectangle **rectangles, gint *n_rectangles); 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); void gdk_region_offset (GdkRegion *region, gint dx, gint dy); void gdk_region_shrink (GdkRegion *region, gint dx, gint dy); void gdk_region_union_with_rect (GdkRegion *region, GdkRectangle *rect); void gdk_region_intersect (GdkRegion *source1, GdkRegion *source2); void gdk_region_union (GdkRegion *source1, GdkRegion *source2); void gdk_region_subtract (GdkRegion *source1, GdkRegion *source2); void gdk_region_xor (GdkRegion *source1, GdkRegion *source2); void gdk_region_spans_intersect_foreach (GdkRegion *region, GdkSpan *spans, int n_spans, gboolean sorted, GdkSpanFunc Function, gpointer data); alias _GdkScreenClass GdkScreenClass; struct _GdkScreen { GObject parent_instance; guint closed; GdkGC *normal_gcs[32]; GdkGC *exposure_gcs[32]; } struct _GdkScreenClass { GObjectClass parent_class; void (*size_changed) (GdkScreen *screen); } GType gdk_screen_get_type (); GdkColormap *gdk_screen_get_default_colormap (GdkScreen *screen); void gdk_screen_set_default_colormap (GdkScreen *screen, GdkColormap *colormap); GdkColormap* gdk_screen_get_system_colormap (GdkScreen *screen); GdkVisual* gdk_screen_get_system_visual (GdkScreen *screen); GdkColormap *gdk_screen_get_rgb_colormap (GdkScreen *screen); GdkVisual * gdk_screen_get_rgb_visual (GdkScreen *screen); GdkWindow * gdk_screen_get_root_window (GdkScreen *screen); GdkDisplay * gdk_screen_get_display (GdkScreen *screen); gint gdk_screen_get_number (GdkScreen *screen); gint gdk_screen_get_width (GdkScreen *screen); gint gdk_screen_get_height (GdkScreen *screen); gint gdk_screen_get_width_mm (GdkScreen *screen); gint gdk_screen_get_height_mm (GdkScreen *screen); GList * gdk_screen_list_visuals (GdkScreen *screen); GList * gdk_screen_get_toplevel_windows (GdkScreen *screen); gchar * gdk_screen_make_display_name (GdkScreen *screen); gint gdk_screen_get_n_monitors (GdkScreen *screen); void gdk_screen_get_monitor_geometry (GdkScreen *screen, gint monitor_num, GdkRectangle *dest); gint gdk_screen_get_monitor_at_point (GdkScreen *screen, gint x, gint y); gint gdk_screen_get_monitor_at_window (GdkScreen *screen, GdkWindow *window); void gdk_screen_broadcast_client_message (GdkScreen *screen, GdkEvent *event); GdkScreen *gdk_screen_get_default (); gboolean gdk_screen_get_setting (GdkScreen *screen, gchar *name, GValue *value); alias GdkAtom GdkSelection; alias GdkAtom GdkTarget; alias GdkAtom GdkSelectionType; gboolean gdk_selection_owner_set (GdkWindow *owner, GdkAtom selection, guint32 time_, gboolean send_event); GdkWindow* gdk_selection_owner_get (GdkAtom selection); gboolean gdk_selection_owner_set_for_display (GdkDisplay *display, GdkWindow *owner, GdkAtom selection, guint32 time_, gboolean send_event); GdkWindow *gdk_selection_owner_get_for_display (GdkDisplay *display, 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_); void gdk_selection_send_notify_for_display (GdkDisplay *display, guint32 requestor, GdkAtom selection, GdkAtom target, GdkAtom property, guint32 time_); gboolean gdk_spawn_on_screen (GdkScreen *screen, gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup, gpointer user_data, gint *child_pid, GError **error); gboolean gdk_spawn_on_screen_with_pipes (GdkScreen *screen, gchar *working_directory, gchar **argv, gchar **envp, GSpawnFlags flags, GSpawnChildSetupFunc child_setup, gpointer user_data, gint *child_pid, gint *standard_input, gint *standard_output, gint *standard_error, GError **error); gboolean gdk_spawn_command_line_on_screen (GdkScreen *screen, gchar *command_line, GError **error); alias _GdkVisualClass GdkVisualClass; alias void _GdkVisualClass; enum GdkVisualType { GDK_VISUAL_STATIC_GRAY, GDK_VISUAL_GRAYSCALE, GDK_VISUAL_STATIC_COLOR, GDK_VISUAL_PSEUDO_COLOR, GDK_VISUAL_TRUE_COLOR, GDK_VISUAL_DIRECT_COLOR }; struct _GdkVisual { GObject parent_instance; 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; } GType gdk_visual_get_type (); gint gdk_visual_get_best_depth (); GdkVisualType gdk_visual_get_best_type (); GdkVisual* gdk_visual_get_system (); GdkVisual* gdk_visual_get_best (); 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); void gdk_query_depths (gint **depths, gint *count); void gdk_query_visual_types (GdkVisualType **visual_types, gint *count); GList* gdk_list_visuals (); GdkScreen *gdk_visual_get_screen (GdkVisual *visual); alias _GdkGeometry GdkGeometry; alias _GdkWindowAttr GdkWindowAttr; alias _GdkPointerHooks GdkPointerHooks; enum GdkWindowClass { GDK_INPUT_OUTPUT, GDK_INPUT_ONLY }; enum GdkWindowType { GDK_WINDOW_ROOT, GDK_WINDOW_TOPLEVEL, GDK_WINDOW_CHILD, GDK_WINDOW_DIALOG, GDK_WINDOW_TEMP, GDK_WINDOW_FOREIGN }; enum GdkWindowAttributesType { 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 }; enum GdkWindowHints { 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, GDK_HINT_WIN_GRAVITY = 1 << 6, GDK_HINT_USER_POS = 1 << 7, GDK_HINT_USER_SIZE = 1 << 8 }; enum GdkWindowTypeHint { GDK_WINDOW_TYPE_HINT_NORMAL, GDK_WINDOW_TYPE_HINT_DIALOG, GDK_WINDOW_TYPE_HINT_MENU, GDK_WINDOW_TYPE_HINT_TOOLBAR, GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, GDK_WINDOW_TYPE_HINT_UTILITY, GDK_WINDOW_TYPE_HINT_DOCK, GDK_WINDOW_TYPE_HINT_DESKTOP }; enum GdkWMDecoration { 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 }; enum GdkWMFunction { 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 }; enum GdkGravity { GDK_GRAVITY_NORTH_WEST = 1, GDK_GRAVITY_NORTH, GDK_GRAVITY_NORTH_EAST, GDK_GRAVITY_WEST, GDK_GRAVITY_CENTER, GDK_GRAVITY_EAST, GDK_GRAVITY_SOUTH_WEST, GDK_GRAVITY_SOUTH, GDK_GRAVITY_SOUTH_EAST, GDK_GRAVITY_STATIC }; enum GdkWindowEdge { GDK_WINDOW_EDGE_NORTH_WEST, GDK_WINDOW_EDGE_NORTH, GDK_WINDOW_EDGE_NORTH_EAST, GDK_WINDOW_EDGE_WEST, GDK_WINDOW_EDGE_EAST, GDK_WINDOW_EDGE_SOUTH_WEST, GDK_WINDOW_EDGE_SOUTH, GDK_WINDOW_EDGE_SOUTH_EAST }; struct _GdkWindowAttr { gchar *title; gint event_mask; gint x, y; gint width; gint height; GdkWindowClass wclass; GdkVisual *visual; GdkColormap *colormap; GdkWindowType window_type; GdkCursor *cursor; gchar *wmclass_name; gchar *wmclass_class; gboolean override_redirect; } 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; GdkGravity win_gravity; } struct _GdkPointerHooks { GdkWindow* (*get_pointer) (GdkWindow *window, gint *x, gint *y, GdkModifierType *mask); GdkWindow* (*window_at_pointer) (GdkScreen *screen, gint *win_x, gint *win_y); } alias _GdkWindowObject GdkWindowObject; alias _GdkWindowObjectClass GdkWindowObjectClass; struct _GdkWindowObject { GdkDrawable parent_instance; GdkDrawable *impl; GdkWindowObject *parent; gpointer user_data; gint x; gint y; gint extension_events; GList *filters; GList *children; GdkColor bg_color; GdkPixmap *bg_pixmap; GSList *paint_stack; GdkRegion *update_area; guint update_freeze_count; guint8 window_type; guint8 depth; guint8 resize_count; GdkWindowState state; guint guffaw_gravity; guint input_only; guint modal_hint; guint destroyed; guint accept_focus; GdkEventMask event_mask; } struct _GdkWindowObjectClass { GdkDrawableClass parent_class; } GType gdk_window_object_get_type () ; GdkWindow* gdk_window_new (GdkWindow *parent, GdkWindowAttr *attributes, gint attributes_mask); void gdk_window_destroy (GdkWindow *window); GdkWindowType gdk_window_get_window_type (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_show_unraised (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_raise (GdkWindow *window); void gdk_window_lower (GdkWindow *window); void gdk_window_focus (GdkWindow *window, guint32 timestamp); 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_set_accept_focus (GdkWindow *window, gboolean accept_focus); 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_scroll (GdkWindow *window, gint dx, gint dy); void gdk_window_shape_combine_mask (GdkWindow *window, GdkBitmap *mask, gint x, gint y); void gdk_window_shape_combine_region (GdkWindow *window, GdkRegion *shape_region, gint offset_x, gint offset_y); void gdk_window_set_child_shapes (GdkWindow *window); void gdk_window_merge_child_shapes (GdkWindow *window); gboolean gdk_window_is_visible (GdkWindow *window); gboolean gdk_window_is_viewable (GdkWindow *window); GdkWindowState gdk_window_get_state (GdkWindow *window); gboolean gdk_window_set_static_gravities (GdkWindow *window, gboolean use_static); GdkWindow* gdk_window_foreign_new (GdkNativeWindow anid); GdkWindow* gdk_window_lookup (GdkNativeWindow anid); GdkWindow *gdk_window_foreign_new_for_display (GdkDisplay *display, GdkNativeWindow anid); GdkWindow* gdk_window_lookup_for_display (GdkDisplay *display, GdkNativeWindow anid); 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_type_hint (GdkWindow *window, GdkWindowTypeHint hint); void gdk_window_set_modal_hint (GdkWindow *window, gboolean modal); void gdk_window_set_skip_taskbar_hint (GdkWindow *window, gboolean skips_taskbar); void gdk_window_set_skip_pager_hint (GdkWindow *window, gboolean skips_pager); void gdk_window_set_geometry_hints (GdkWindow *window, GdkGeometry *geometry, GdkWindowHints geom_mask); void gdk_set_sm_client_id ( gchar *sm_client_id); void gdk_window_begin_paint_rect (GdkWindow *window, GdkRectangle *rectangle); void gdk_window_begin_paint_region (GdkWindow *window, GdkRegion *region); void gdk_window_end_paint (GdkWindow *window); void gdk_window_set_title (GdkWindow *window, gchar *title); void gdk_window_set_role (GdkWindow *window, gchar *role); void gdk_window_set_transient_for (GdkWindow *window, GdkWindow *parent); 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_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); 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); void gdk_window_get_frame_extents (GdkWindow *window, GdkRectangle *rect); 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); GList * gdk_window_peek_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_list (GdkWindow *window, GList *pixbufs); void gdk_window_set_icon (GdkWindow *window, GdkWindow *icon_window, GdkPixmap *pixmap, GdkBitmap *mask); void gdk_window_set_icon_name (GdkWindow *window, gchar *name); void gdk_window_set_group (GdkWindow *window, GdkWindow *leader); GdkWindow* gdk_window_get_group (GdkWindow *window); void gdk_window_set_decorations (GdkWindow *window, GdkWMDecoration decorations); gboolean gdk_window_get_decorations (GdkWindow *window, GdkWMDecoration *decorations); void gdk_window_set_functions (GdkWindow *window, GdkWMFunction functions); GList * gdk_window_get_toplevels (); void gdk_window_iconify (GdkWindow *window); void gdk_window_deiconify (GdkWindow *window); void gdk_window_stick (GdkWindow *window); void gdk_window_unstick (GdkWindow *window); void gdk_window_maximize (GdkWindow *window); void gdk_window_unmaximize (GdkWindow *window); void gdk_window_fullscreen (GdkWindow *window); void gdk_window_unfullscreen (GdkWindow *window); void gdk_window_set_keep_above (GdkWindow *window, gboolean setting); void gdk_window_set_keep_below (GdkWindow *window, gboolean setting); void gdk_window_register_dnd (GdkWindow *window); void gdk_window_begin_resize_drag (GdkWindow *window, GdkWindowEdge edge, gint button, gint root_x, gint root_y, guint32 timestamp); void gdk_window_begin_move_drag (GdkWindow *window, gint button, gint root_x, gint root_y, guint32 timestamp); void gdk_window_invalidate_rect (GdkWindow *window, GdkRectangle *rect, gboolean invalidate_children); void gdk_window_invalidate_region (GdkWindow *window, GdkRegion *region, gboolean invalidate_children); void gdk_window_invalidate_maybe_recurse (GdkWindow *window, GdkRegion *region, gboolean (*child_func) (GdkWindow *, gpointer), gpointer user_data); GdkRegion *gdk_window_get_update_area (GdkWindow *window); void gdk_window_freeze_updates (GdkWindow *window); void gdk_window_thaw_updates (GdkWindow *window); gint gdk_window_get_update_serial (); void gdk_window_process_all_updates (); void gdk_window_process_updates (GdkWindow *window, gboolean update_children); void gdk_window_set_debug_updates (gboolean setting); void gdk_window_rain_size (GdkGeometry *geometry, guint flags, gint width, gint height, gint *new_width, gint *new_height); void gdk_window_get_internal_paint_info (GdkWindow *window, GdkDrawable **real_drawable, gint *x_offset, gint *y_offset); GdkPointerHooks *gdk_set_pointer_hooks ( GdkPointerHooks *new_hooks); GdkWindow *gdk_get_default_root_window (); void gdk_parse_args (gint *argc, gchar ***argv); 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 (); char *gdk_get_program_class (); void gdk_set_program_class ( char *program_class); void gdk_error_trap_push (); gint gdk_error_trap_pop (); void gdk_set_use_xshm (gboolean use_xshm); gboolean gdk_get_use_xshm (); gchar* gdk_get_display (); gchar* gdk_get_display_arg_name (); 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); GdkGrabStatus gdk_pointer_grab (GdkWindow *window, gboolean owner_events, GdkEventMask event_mask, GdkWindow *confine_to, GdkCursor *cursor, guint32 time_); GdkGrabStatus gdk_keyboard_grab (GdkWindow *window, gboolean owner_events, guint32 time_); void gdk_pointer_ungrab (guint32 time_); void gdk_keyboard_ungrab (guint32 time_); gboolean gdk_pointer_is_grabbed (); gint gdk_screen_width () ; gint gdk_screen_height () ; gint gdk_screen_width_mm () ; gint gdk_screen_height_mm () ; void gdk_beep (); void gdk_flush (); void gdk_set_double_click_time (guint msec); gboolean gdk_rectangle_intersect (GdkRectangle *src1, GdkRectangle *src2, GdkRectangle *dest); void gdk_rectangle_union (GdkRectangle *src1, GdkRectangle *src2, GdkRectangle *dest); GType gdk_rectangle_get_type (); gchar *gdk_wcstombs ( GdkWChar *src); gint gdk_mbstowcs (GdkWChar *dest, gchar *src, gint dest_max); gboolean gdk_event_send_client_message (GdkEvent *event, GdkNativeWindow winid); void gdk_event_send_clientmessage_toall (GdkEvent *event); gboolean gdk_event_send_client_message_for_display (GdkDisplay *display, GdkEvent *event, GdkNativeWindow winid); void gdk_notify_startup_complete (); GMutex *gdk_threads_mutex; GCallback gdk_threads_lock; GCallback gdk_threads_unlock; void gdk_threads_enter (); void gdk_threads_leave (); void gdk_threads_init (); void gdk_threads_set_lock_functions (GCallback enter_fn, GCallback leave_fn); enum GtkAnchorType { 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 }; enum GtkArrowType { GTK_ARROW_UP, GTK_ARROW_DOWN, GTK_ARROW_LEFT, GTK_ARROW_RIGHT }; enum GtkAttachOptions { GTK_EXPAND = 1 << 0, GTK_SHRINK = 1 << 1, GTK_FILL = 1 << 2 }; enum GtkButtonBoxStyle { GTK_BUTTONBOX_DEFAULT_STYLE, GTK_BUTTONBOX_SPREAD, GTK_BUTTONBOX_EDGE, GTK_BUTTONBOX_START, GTK_BUTTONBOX_END }; enum GtkCurveType { GTK_CURVE_TYPE_LINEAR, GTK_CURVE_TYPE_SPLINE, GTK_CURVE_TYPE_FREE }; enum GtkDeleteType { GTK_DELETE_CHARS, GTK_DELETE_WORD_ENDS, GTK_DELETE_WORDS, GTK_DELETE_DISPLAY_LINES, GTK_DELETE_DISPLAY_LINE_ENDS, GTK_DELETE_PARAGRAPH_ENDS, GTK_DELETE_PARAGRAPHS, GTK_DELETE_WHITESPACE }; enum GtkDirectionType { GTK_DIR_TAB_FORWARD, GTK_DIR_TAB_BACKWARD, GTK_DIR_UP, GTK_DIR_DOWN, GTK_DIR_LEFT, GTK_DIR_RIGHT }; enum GtkExpanderStyle { GTK_EXPANDER_COLLAPSED, GTK_EXPANDER_SEMI_COLLAPSED, GTK_EXPANDER_SEMI_EXPANDED, GTK_EXPANDER_EXPANDED }; enum GtkIconSize { GTK_ICON_SIZE_INVALID, GTK_ICON_SIZE_MENU, GTK_ICON_SIZE_SMALL_TOOLBAR, GTK_ICON_SIZE_LARGE_TOOLBAR, GTK_ICON_SIZE_BUTTON, GTK_ICON_SIZE_DND, GTK_ICON_SIZE_DIALOG }; enum GtkSideType { GTK_SIDE_TOP, GTK_SIDE_BOTTOM, GTK_SIDE_LEFT, GTK_SIDE_RIGHT }; enum GtkTextDirection { GTK_TEXT_DIR_NONE, GTK_TEXT_DIR_LTR, GTK_TEXT_DIR_RTL }; enum GtkJustification { GTK_JUSTIFY_LEFT, GTK_JUSTIFY_RIGHT, GTK_JUSTIFY_CENTER, GTK_JUSTIFY_FILL }; enum GtkMatchType { GTK_MATCH_ALL, GTK_MATCH_ALL_TAIL, GTK_MATCH_HEAD, GTK_MATCH_TAIL, GTK_MATCH_EXACT, GTK_MATCH_LAST }; enum GtkMenuDirectionType { GTK_MENU_DIR_PARENT, GTK_MENU_DIR_CHILD, GTK_MENU_DIR_NEXT, GTK_MENU_DIR_PREV }; enum GtkMetricType { GTK_PIXELS, GTK_INCHES, GTK_CENTIMETERS }; enum GtkMovementStep { GTK_MOVEMENT_LOGICAL_POSITIONS, GTK_MOVEMENT_VISUAL_POSITIONS, GTK_MOVEMENT_WORDS, GTK_MOVEMENT_DISPLAY_LINES, GTK_MOVEMENT_DISPLAY_LINE_ENDS, GTK_MOVEMENT_PARAGRAPHS, GTK_MOVEMENT_PARAGRAPH_ENDS, GTK_MOVEMENT_PAGES, GTK_MOVEMENT_BUFFER_ENDS, GTK_MOVEMENT_HORIZONTAL_PAGES }; enum GtkScrollStep { GTK_SCROLL_STEPS, GTK_SCROLL_PAGES, GTK_SCROLL_ENDS, GTK_SCROLL_HORIZONTAL_STEPS, GTK_SCROLL_HORIZONTAL_PAGES, GTK_SCROLL_HORIZONTAL_ENDS }; enum GtkOrientation { GTK_ORIENTATION_HORIZONTAL, GTK_ORIENTATION_VERTICAL }; enum GtkCornerType { GTK_CORNER_TOP_LEFT, GTK_CORNER_BOTTOM_LEFT, GTK_CORNER_TOP_RIGHT, GTK_CORNER_BOTTOM_RIGHT }; enum GtkPackType { GTK_PACK_START, GTK_PACK_END }; enum GtkPathPriorityType { GTK_PATH_PRIO_LOWEST = 0, GTK_PATH_PRIO_GTK = 4, GTK_PATH_PRIO_APPLICATION = 8, GTK_PATH_PRIO_THEME = 10, GTK_PATH_PRIO_RC = 12, GTK_PATH_PRIO_HIGHEST = 15 }; enum GtkPathType { GTK_PATH_WIDGET, GTK_PATH_WIDGET_CLASS, GTK_PATH_CLASS }; enum GtkPolicyType { GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER }; enum GtkPositionType { GTK_POS_LEFT, GTK_POS_RIGHT, GTK_POS_TOP, GTK_POS_BOTTOM }; enum GtkPreviewType { GTK_PREVIEW_COLOR, GTK_PREVIEW_GRAYSCALE }; enum GtkReliefStyle { GTK_RELIEF_NORMAL, GTK_RELIEF_HALF, GTK_RELIEF_NONE }; enum GtkResizeMode { GTK_RESIZE_PARENT, GTK_RESIZE_QUEUE, GTK_RESIZE_IMMEDIATE }; enum GtkSignalRunType { GTK_RUN_FIRST = GSignalFlags.G_SIGNAL_RUN_FIRST, GTK_RUN_LAST = GSignalFlags.G_SIGNAL_RUN_LAST, GTK_RUN_BOTH = (GTK_RUN_FIRST | GTK_RUN_LAST), GTK_RUN_NO_RECURSE = GSignalFlags.G_SIGNAL_NO_RECURSE, GTK_RUN_ACTION = GSignalFlags.G_SIGNAL_ACTION, GTK_RUN_NO_HOOKS = GSignalFlags.G_SIGNAL_NO_HOOKS }; enum GtkScrollType { GTK_SCROLL_NONE, GTK_SCROLL_JUMP, GTK_SCROLL_STEP_BACKWARD, GTK_SCROLL_STEP_FORWARD, GTK_SCROLL_PAGE_BACKWARD, GTK_SCROLL_PAGE_FORWARD, GTK_SCROLL_STEP_UP, GTK_SCROLL_STEP_DOWN, GTK_SCROLL_PAGE_UP, GTK_SCROLL_PAGE_DOWN, GTK_SCROLL_STEP_LEFT, GTK_SCROLL_STEP_RIGHT, GTK_SCROLL_PAGE_LEFT, GTK_SCROLL_PAGE_RIGHT, GTK_SCROLL_START, GTK_SCROLL_END }; enum GtkSelectionMode { GTK_SELECTION_NONE, GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE, GTK_SELECTION_EXTENDED = GTK_SELECTION_MULTIPLE }; enum GtkShadowType { GTK_SHADOW_NONE, GTK_SHADOW_IN, GTK_SHADOW_OUT, GTK_SHADOW_ETCHED_IN, GTK_SHADOW_ETCHED_OUT }; enum GtkStateType { GTK_STATE_NORMAL, GTK_STATE_ACTIVE, GTK_STATE_PRELIGHT, GTK_STATE_SELECTED, GTK_STATE_INSENSITIVE }; enum GtkSubmenuDirection { GTK_DIRECTION_LEFT, GTK_DIRECTION_RIGHT }; enum GtkSubmenuPlacement { GTK_TOP_BOTTOM, GTK_LEFT_RIGHT }; enum GtkToolbarStyle { GTK_TOOLBAR_ICONS, GTK_TOOLBAR_TEXT, GTK_TOOLBAR_BOTH, GTK_TOOLBAR_BOTH_HORIZ }; enum GtkUpdateType { GTK_UPDATE_CONTINUOUS, GTK_UPDATE_DISCONTINUOUS, GTK_UPDATE_DELAYED }; enum GtkVisibility { GTK_VISIBILITY_NONE, GTK_VISIBILITY_PARTIAL, GTK_VISIBILITY_FULL }; enum GtkWindowPosition { GTK_WIN_POS_NONE, GTK_WIN_POS_CENTER, GTK_WIN_POS_MOUSE, GTK_WIN_POS_CENTER_ALWAYS, GTK_WIN_POS_CENTER_ON_PARENT }; enum GtkWindowType { GTK_WINDOW_TOPLEVEL, GTK_WINDOW_POPUP }; enum GtkWrapMode { GTK_WRAP_NONE, GTK_WRAP_CHAR, GTK_WRAP_WORD, GTK_WRAP_WORD_CHAR }; enum GtkSortType { GTK_SORT_ASCENDING, GTK_SORT_DESCENDING }; enum GtkIMPreeditStyle { GTK_IM_PREEDIT_NOTHING, GTK_IM_PREEDIT_CALLBACK, GTK_IM_PREEDIT_NONE }; enum GtkIMStatusStyle { GTK_IM_STATUS_NOTHING, GTK_IM_STATUS_CALLBACK, GTK_IM_STATUS_NONE }; enum GtkAccelFlags { GTK_ACCEL_VISIBLE = 1 << 0, GTK_ACCEL_LOCKED = 1 << 1, GTK_ACCEL_MASK = 0x07 }; alias _GtkAccelGroup GtkAccelGroup; alias _GtkAccelGroupClass GtkAccelGroupClass; alias _GtkAccelKey GtkAccelKey; alias _GtkAccelGroupEntry GtkAccelGroupEntry; alias gboolean (*GtkAccelGroupActivate) (GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier); alias gboolean (*GtkAccelGroupFindFunc) (GtkAccelKey *key, GClosure *closure, gpointer data); struct _GtkAccelGroup { GObject parent; guint lock_count; GdkModifierType modifier_mask; GSList *acceleratables; guint n_accels; GtkAccelGroupEntry *priv_accels; } struct _GtkAccelGroupClass { GObjectClass parent_class; void (*accel_changed) (GtkAccelGroup *accel_group, guint keyval, GdkModifierType modifier, GClosure *accel_closure); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkAccelKey { guint accel_key; GdkModifierType accel_mods; guint accel_flags; } GType gtk_accel_group_get_type (); GtkAccelGroup* gtk_accel_group_new (); void gtk_accel_group_lock (GtkAccelGroup *accel_group); void gtk_accel_group_unlock (GtkAccelGroup *accel_group); void gtk_accel_group_connect (GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags, GClosure *closure); void gtk_accel_group_connect_by_path (GtkAccelGroup *accel_group, gchar *accel_path, GClosure *closure); gboolean gtk_accel_group_disconnect (GtkAccelGroup *accel_group, GClosure *closure); gboolean gtk_accel_group_disconnect_key (GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods); gboolean gtk_accel_group_activate (GtkAccelGroup *accel_group, GQuark accel_quark, GObject *acceleratable, guint accel_key, GdkModifierType accel_mods); void _gtk_accel_group_attach (GtkAccelGroup *accel_group, GObject *object); void _gtk_accel_group_detach (GtkAccelGroup *accel_group, GObject *object); gboolean gtk_accel_groups_activate (GObject *object, guint accel_key, GdkModifierType accel_mods); GSList* gtk_accel_groups_from_object (GObject *object); GtkAccelKey* gtk_accel_group_find (GtkAccelGroup *accel_group, GtkAccelGroupFindFunc find_func, gpointer data); GtkAccelGroup* gtk_accel_group_from_accel_closure (GClosure *closure); gboolean gtk_accelerator_valid (guint keyval, GdkModifierType modifiers) ; void gtk_accelerator_parse ( 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 (); GtkAccelGroupEntry* gtk_accel_group_query (GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, guint *n_entries); void _gtk_accel_group_reconnect (GtkAccelGroup *accel_group, GQuark accel_path_quark); struct _GtkAccelGroupEntry { GtkAccelKey key; GClosure *closure; GQuark accel_path_quark; } alias GType GtkFundamentalType; alias GType GtkType; alias GTypeInstance GtkTypeObject; alias GTypeClass GtkTypeClass; alias GBaseInitFunc GtkClassInitFunc; alias GInstanceInitFunc GtkObjectInitFunc; GType gtk_accel_flags_get_type (); GType gtk_calendar_display_options_get_type (); GType gtk_cell_renderer_state_get_type (); GType gtk_cell_renderer_mode_get_type (); GType gtk_cell_type_get_type (); GType gtk_clist_drag_pos_get_type (); GType gtk_button_action_get_type (); GType gtk_ctree_pos_get_type (); GType gtk_ctree_line_style_get_type (); GType gtk_ctree_expander_style_get_type (); GType gtk_ctree_expansion_type_get_type (); GType gtk_debug_flag_get_type (); GType gtk_dialog_flags_get_type (); GType gtk_response_type_get_type (); GType gtk_dest_defaults_get_type (); GType gtk_target_flags_get_type (); GType gtk_anchor_type_get_type (); GType gtk_arrow_type_get_type (); GType gtk_attach_options_get_type (); GType gtk_button_box_style_get_type (); GType gtk_curve_type_get_type (); GType gtk_delete_type_get_type (); GType gtk_direction_type_get_type (); GType gtk_expander_style_get_type (); GType gtk_icon_size_get_type (); GType gtk_side_type_get_type (); GType gtk_text_direction_get_type (); GType gtk_justification_get_type (); GType gtk_match_type_get_type (); GType gtk_menu_direction_type_get_type (); GType gtk_metric_type_get_type (); GType gtk_movement_step_get_type (); GType gtk_scroll_step_get_type (); GType gtk_orientation_get_type (); GType gtk_corner_type_get_type (); GType gtk_pack_type_get_type (); GType gtk_path_priority_type_get_type (); GType gtk_path_type_get_type (); GType gtk_policy_type_get_type (); GType gtk_position_type_get_type (); GType gtk_preview_type_get_type (); GType gtk_relief_style_get_type (); GType gtk_resize_mode_get_type (); GType gtk_signal_run_type_get_type (); GType gtk_scroll_type_get_type (); GType gtk_selection_mode_get_type (); GType gtk_shadow_type_get_type (); GType gtk_state_type_get_type (); GType gtk_submenu_direction_get_type (); GType gtk_submenu_placement_get_type (); GType gtk_toolbar_style_get_type (); GType gtk_update_type_get_type (); GType gtk_visibility_get_type (); GType gtk_window_position_get_type (); GType gtk_window_type_get_type (); GType gtk_wrap_mode_get_type (); GType gtk_sort_type_get_type (); GType gtk_im_preedit_style_get_type (); GType gtk_im_status_style_get_type (); GType gtk_file_chooser_action_get_type (); GType gtk_file_chooser_error_get_type (); GType gtk_file_filter_flags_get_type (); GType gtk_icon_lookup_flags_get_type (); GType gtk_icon_theme_error_get_type (); GType gtk_image_type_get_type (); GType gtk_message_type_get_type (); GType gtk_buttons_type_get_type (); GType gtk_notebook_tab_get_type (); GType gtk_object_flags_get_type (); GType gtk_arg_flags_get_type (); GType gtk_private_flags_get_type (); GType gtk_progress_bar_style_get_type (); GType gtk_progress_bar_orientation_get_type (); GType gtk_rc_flags_get_type (); GType gtk_rc_token_type_get_type (); GType gtk_size_group_mode_get_type (); GType gtk_spin_button_update_policy_get_type (); GType gtk_spin_type_get_type (); GType gtk_text_search_flags_get_type (); GType gtk_text_window_type_get_type (); GType gtk_toolbar_child_type_get_type (); GType gtk_toolbar_space_style_get_type (); GType gtk_tree_view_mode_get_type (); GType gtk_tree_model_flags_get_type (); GType gtk_tree_view_drop_position_get_type (); GType gtk_tree_view_column_sizing_get_type (); GType gtk_ui_manager_item_type_get_type (); GType gtk_widget_flags_get_type (); GType gtk_widget_help_type_get_type (); GType gtk_identifier_get_type (); alias _GtkArg GtkArg; alias _GtkObject GtkObject; alias gboolean (*GtkFunction) (gpointer data); alias void (*GtkDestroyNotify) (gpointer data); alias void (*GtkCallbackMarshal) (GtkObject *object, gpointer data, guint n_args, GtkArg *args); alias void (*GtkSignalFunc) (); alias _GtkTypeInfo GtkTypeInfo; alias GSignalCMarshaller GtkSignalMarshaller; struct _GtkArg { GtkType type; gchar *name; union d_union { gchar char_data; guchar uchar_data; gboolean int_data1; gint int_data2; guint uint_data; glong int_data3; gulong ulong_data; gfloat float_data; gdouble double_data; gchar *string_data; GtkObject *object_data; gpointer pointer_data; struct signal_data_struct { GtkSignalFunc f; gpointer d; } } d_union d; } 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; } gpointer gtk_type_class (GtkType type); GtkType gtk_type_unique (GtkType parent_type, GtkTypeInfo *gtkinfo); gpointer gtk_type_new (GtkType type); alias GEnumValue GtkEnumValue; alias GFlagsValue GtkFlagValue; 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, gchar *value_name); GtkFlagValue* gtk_type_flags_find_value (GtkType flags_type, gchar *value_name); void gtk_type_init (GTypeDebugFlags debug_flags); enum GtkDebugFlag { GTK_DEBUG_MISC = 1 << 0, GTK_DEBUG_PLUGSOCKET = 1 << 1, GTK_DEBUG_TEXT = 1 << 2, GTK_DEBUG_TREE = 1 << 3, GTK_DEBUG_UPDATES = 1 << 4, GTK_DEBUG_KEYBINDINGS = 1 << 5, GTK_DEBUG_MULTIHEAD = 1 << 6 }; guint gtk_debug_flags; enum GtkObjectFlags { GTK_IN_DESTRUCTION = 1 << 0, GTK_FLOATING = 1 << 1, GTK_RESERVED_1 = 1 << 2, GTK_RESERVED_2 = 1 << 3 }; alias _GtkObjectClass GtkObjectClass; struct _GtkObject { GObject parent_instance; guint32 flags; } struct _GtkObjectClass { GObjectClass parent_class; void (*set_arg) (GtkObject *object, GtkArg *arg, guint arg_id); void (*get_arg) (GtkObject *object, GtkArg *arg, guint arg_id); void (*destroy) (GtkObject *object); } GtkType gtk_object_get_type () ; void gtk_object_sink (GtkObject *object); void gtk_object_destroy (GtkObject *object); GtkObject* gtk_object_new (GtkType type, gchar *first_property_name, ...); GtkObject* 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_set_data (GtkObject *object, gchar *key, gpointer data); void gtk_object_set_data_full (GtkObject *object, gchar *key, gpointer data, GtkDestroyNotify destroy); void gtk_object_remove_data (GtkObject *object, gchar *key); gpointer gtk_object_get_data (GtkObject *object, gchar *key); void gtk_object_remove_no_notify (GtkObject *object, gchar *key); void gtk_object_set_user_data (GtkObject *object, gpointer data); gpointer gtk_object_get_user_data (GtkObject *object); 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); enum GtkArgFlags { GTK_ARG_READABLE = GParamFlags.G_PARAM_READABLE, GTK_ARG_WRITABLE = GParamFlags.G_PARAM_WRITABLE, GTK_ARG_CONSTRUCT = GParamFlags.G_PARAM_CONSTRUCT, GTK_ARG_CONSTRUCT_ONLY = GParamFlags.G_PARAM_CONSTRUCT_ONLY, GTK_ARG_CHILD_ARG = 1 << 4 }; void gtk_object_get (GtkObject *object, gchar *first_property_name, ...); void gtk_object_set (GtkObject *object, gchar *first_property_name, ...); void gtk_object_add_arg_type ( gchar *arg_name, GtkType arg_type, guint arg_flags, guint arg_id); alias _GtkAdjustment GtkAdjustment; alias _GtkAdjustmentClass GtkAdjustmentClass; struct _GtkAdjustment { GtkObject parent_instance; gdouble lower; gdouble upper; gdouble value; gdouble step_increment; gdouble page_increment; gdouble page_size; } struct _GtkAdjustmentClass { GtkObjectClass parent_class; void (* changed) (GtkAdjustment *adjustment); void (* value_changed) (GtkAdjustment *adjustment); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_adjustment_get_type () ; GtkObject* gtk_adjustment_new (gdouble value, gdouble lower, gdouble upper, gdouble step_increment, gdouble page_increment, gdouble page_size); void gtk_adjustment_changed (GtkAdjustment *adjustment); void gtk_adjustment_value_changed (GtkAdjustment *adjustment); void gtk_adjustment_clamp_page (GtkAdjustment *adjustment, gdouble lower, gdouble upper); gdouble gtk_adjustment_get_value (GtkAdjustment *adjustment); void gtk_adjustment_set_value (GtkAdjustment *adjustment, gdouble value); void gtk_adjustment_goto_value (GtkAdjustment *adjustment, gdouble value); void gtk_adjustment_home (GtkAdjustment *adjustment); void gtk_adjustment_end (GtkAdjustment *adjustment); void gtk_adjustment_step_up (GtkAdjustment *adjustment); void gtk_adjustment_step_down (GtkAdjustment *adjustment); void gtk_adjustment_wheel_up (GtkAdjustment *adjustment); void gtk_adjustment_wheel_down (GtkAdjustment *adjustment); void gtk_adjustment_page_up (GtkAdjustment *adjustment); void gtk_adjustment_page_down (GtkAdjustment *adjustment); alias _GtkBorder GtkBorder; alias _GtkStyle GtkStyle; alias _GtkStyleClass GtkStyleClass; alias _GtkThemeEngine GtkThemeEngine; alias void _GtkThemeEngine; alias _GtkRcStyle GtkRcStyle; alias _GtkIconSet GtkIconSet; alias void _GtkIconSet; alias _GtkIconSource GtkIconSource; alias void _GtkIconSource; alias _GtkRcProperty GtkRcProperty; alias _GtkSettings GtkSettings; alias gboolean (*GtkRcPropertyParser) ( GParamSpec *pspec, GString *rc_string, GValue *property_value); alias _GtkWidget GtkWidget; align(1) struct _GtkStyle { GObject parent_instance; GdkColor fg[5]; GdkColor bg[5]; GdkColor light[5]; GdkColor dark[5]; GdkColor mid[5]; GdkColor text[5]; GdkColor base[5]; GdkColor text_aa[5]; GdkColor black; GdkColor white; PangoFontDescription *font_desc; gint xthickness; gint ythickness; 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 *text_aa_gc[5]; GdkGC *black_gc; GdkGC *white_gc; GdkPixmap *bg_pixmap[5]; gint attach_count; gint depth; GdkColormap *colormap; GdkFont *private_font; PangoFontDescription *private_font_desc; GtkRcStyle *rc_style; GSList *styles; GArray *property_cache; GSList *icon_factories; } struct _GtkStyleClass { GObjectClass parent_class; void (*realize) (GtkStyle *style); void (*unrealize) (GtkStyle *style); void (*copy) (GtkStyle *style, GtkStyle *src); GtkStyle *(*clone) (GtkStyle *style); void (*init_from_rc) (GtkStyle *style, GtkRcStyle *rc_style); void (*set_background) (GtkStyle *style, GdkWindow *window, GtkStateType state_type); GdkPixbuf * (* render_icon) (GtkStyle *style, GtkIconSource *source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget, gchar *detail); 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_string) (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, 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_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, GtkStateType state_type, 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); void (*draw_expander) (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, GtkExpanderStyle expander_style); void (*draw_layout) (GtkStyle *style, GdkWindow *window, GtkStateType state_type, gboolean use_text, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, PangoLayout *layout); void (*draw_resize_grip) (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); void (*_gtk_reserved5) (); void (*_gtk_reserved6) (); void (*_gtk_reserved7) (); void (*_gtk_reserved8) (); void (*_gtk_reserved9) (); void (*_gtk_reserved10) (); void (*_gtk_reserved11) (); void (*_gtk_reserved12) (); } struct _GtkBorder { gint left; gint right; gint top; gint bottom; } GType gtk_style_get_type () ; GtkStyle* gtk_style_new (); 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); GdkFont * gtk_style_get_font (GtkStyle *style); void gtk_style_set_font (GtkStyle *style, GdkFont *font); 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); GtkIconSet* gtk_style_lookup_icon_set (GtkStyle *style, gchar *stock_id); GdkPixbuf* gtk_style_render_icon (GtkStyle *style, GtkIconSource *source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget, gchar *detail); 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_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_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_draw_expander (GtkStyle *style, GdkWindow *window, GtkStateType state_type, gint x, gint y, GtkExpanderStyle expander_style); void gtk_draw_layout (GtkStyle *style, GdkWindow *window, GtkStateType state_type, gboolean use_text, gint x, gint y, PangoLayout *layout); void gtk_draw_resize_grip (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkWindowEdge edge, gint x, gint y, gint width, gint height); 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_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_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, GtkStateType state_type, 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_paint_expander (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, GtkExpanderStyle expander_style); void gtk_paint_layout (GtkStyle *style, GdkWindow *window, GtkStateType state_type, gboolean use_text, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, PangoLayout *layout); void gtk_paint_resize_grip (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height); GType gtk_border_get_type (); GtkBorder *gtk_border_copy ( GtkBorder *border_); void gtk_border_free ( GtkBorder *border_); GValue* _gtk_style_peek_property_value (GtkStyle *style, GType widget_type, GParamSpec *pspec, GtkRcPropertyParser parser); void _gtk_style_init_for_settings (GtkStyle *style, GtkSettings *settings); void gtk_draw_string (GtkStyle *style, GdkWindow *window, GtkStateType state_type, gint x, gint y, gchar *string); void gtk_paint_string (GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget, gchar *detail, gint x, gint y, gchar *string); void gtk_draw_insertion_cursor (GtkWidget *widget, GdkDrawable *drawable, GdkRectangle *area, GdkRectangle *location, gboolean is_primary, GtkTextDirection direction, gboolean draw_arrow); alias _GtkIconFactory GtkIconFactory; alias _GtkRcContext GtkRcContext; alias void _GtkRcContext; alias _GtkRcStyleClass GtkRcStyleClass; enum GtkRcFlags { GTK_RC_FG = 1 << 0, GTK_RC_BG = 1 << 1, GTK_RC_TEXT = 1 << 2, GTK_RC_BASE = 1 << 3 }; struct _GtkRcStyle { GObject parent_instance; gchar *name; gchar *bg_pixmap_name[5]; PangoFontDescription *font_desc; GtkRcFlags color_flags[5]; GdkColor fg[5]; GdkColor bg[5]; GdkColor text[5]; GdkColor base[5]; gint xthickness; gint ythickness; GArray *rc_properties; GSList *rc_style_lists; GSList *icon_factories; guint engine_specified; } struct _GtkRcStyleClass { GObjectClass parent_class; GtkRcStyle * (*create_rc_style) (GtkRcStyle *rc_style); guint (*parse) (GtkRcStyle *rc_style, GtkSettings *settings, GScanner *scanner); void (*merge) (GtkRcStyle *dest, GtkRcStyle *src); GtkStyle * (*create_style) (GtkRcStyle *rc_style); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } void _gtk_rc_init (); void gtk_rc_add_default_file ( gchar *filename); void gtk_rc_set_default_files (gchar **filenames); gchar** gtk_rc_get_default_files (); GtkStyle* gtk_rc_get_style (GtkWidget *widget); GtkStyle* gtk_rc_get_style_by_paths (GtkSettings *settings, char *widget_path, char *class_path, GType type); gboolean gtk_rc_reparse_all_for_settings (GtkSettings *settings, gboolean force_load); void gtk_rc_reset_styles (GtkSettings *settings); gchar* gtk_rc_find_pixmap_in_path (GtkSettings *settings, GScanner *scanner, gchar *pixmap_file); void gtk_rc_parse ( gchar *filename); void gtk_rc_parse_string ( gchar *rc_string); gboolean gtk_rc_reparse_all (); void gtk_rc_add_widget_name_style (GtkRcStyle *rc_style, gchar *pattern); void gtk_rc_add_widget_class_style (GtkRcStyle *rc_style, gchar *pattern); void gtk_rc_add_class_style (GtkRcStyle *rc_style, gchar *pattern); GType gtk_rc_style_get_type () ; GtkRcStyle* gtk_rc_style_new (); GtkRcStyle* gtk_rc_style_copy (GtkRcStyle *orig); void gtk_rc_style_ref (GtkRcStyle *rc_style); void gtk_rc_style_unref (GtkRcStyle *rc_style); gchar* gtk_rc_find_module_in_path ( gchar *module_file); gchar* gtk_rc_get_theme_dir (); gchar* gtk_rc_get_module_dir (); gchar* gtk_rc_get_im_module_path (); gchar* gtk_rc_get_im_module_file (); enum GtkRcTokenType { GTK_RC_TOKEN_INVALID = GTokenType.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_TEXT, GTK_RC_TOKEN_BASE, GTK_RC_TOKEN_XTHICKNESS, GTK_RC_TOKEN_YTHICKNESS, GTK_RC_TOKEN_FONT, GTK_RC_TOKEN_FONTSET, GTK_RC_TOKEN_FONT_NAME, 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_THEME, GTK_RC_TOKEN_RC, GTK_RC_TOKEN_HIGHEST, GTK_RC_TOKEN_ENGINE, GTK_RC_TOKEN_MODULE_PATH, GTK_RC_TOKEN_IM_MODULE_PATH, GTK_RC_TOKEN_IM_MODULE_FILE, GTK_RC_TOKEN_STOCK, GTK_RC_TOKEN_LTR, GTK_RC_TOKEN_RTL, GTK_RC_TOKEN_LAST }; GScanner* gtk_rc_scanner_new (); 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); struct _GtkRcProperty { GQuark type_name; GQuark property_name; gchar *origin; GValue value; } GtkRcProperty* _gtk_rc_style_lookup_rc_property (GtkRcStyle *rc_style, GQuark type_name, GQuark property_name); gchar* _gtk_rc_context_get_default_font_name (GtkSettings *settings); alias _GtkSettingsClass GtkSettingsClass; alias _GtkSettingsValue GtkSettingsValue; alias _GtkSettingsPropertyValue GtkSettingsPropertyValue; alias void _GtkSettingsPropertyValue; struct _GtkSettings { GObject parent_instance; GData *queued_settings; GtkSettingsPropertyValue *property_values; GtkRcContext *rc_context; GdkScreen *screen; } struct _GtkSettingsClass { GObjectClass parent_class; } struct _GtkSettingsValue { gchar *origin; GValue value; } GType gtk_settings_get_type (); GtkSettings* gtk_settings_get_default (); GtkSettings* gtk_settings_get_for_screen (GdkScreen *screen); void gtk_settings_install_property (GParamSpec *pspec); void gtk_settings_install_property_parser (GParamSpec *pspec, GtkRcPropertyParser parser); gboolean gtk_rc_property_parse_color ( GParamSpec *pspec, GString *gstring, GValue *property_value); gboolean gtk_rc_property_parse_enum ( GParamSpec *pspec, GString *gstring, GValue *property_value); gboolean gtk_rc_property_parse_flags ( GParamSpec *pspec, GString *gstring, GValue *property_value); gboolean gtk_rc_property_parse_requisition ( GParamSpec *pspec, GString *gstring, GValue *property_value); gboolean gtk_rc_property_parse_border ( GParamSpec *pspec, GString *gstring, GValue *property_value); void gtk_settings_set_property_value (GtkSettings *settings, gchar *name, GtkSettingsValue *svalue); void gtk_settings_set_string_property (GtkSettings *settings, gchar *name, gchar *v_string, gchar *origin); void gtk_settings_set_long_property (GtkSettings *settings, gchar *name, glong v_long, gchar *origin); void gtk_settings_set_double_property (GtkSettings *settings, gchar *name, gdouble v_double, gchar *origin); void _gtk_settings_set_property_value_from_rc (GtkSettings *settings, gchar *name, GtkSettingsValue *svalue); void _gtk_settings_reset_rc_values (GtkSettings *settings); void _gtk_settings_handle_event (GdkEventSetting *event); GtkRcPropertyParser _gtk_rc_property_parser_from_type (GType type); gboolean _gtk_settings_parse_convert (GtkRcPropertyParser parser, GValue *src_value, GParamSpec *pspec, GValue *dest_value); enum AtkStateType { ATK_STATE_INVALID, ATK_STATE_ACTIVE, ATK_STATE_ARMED, ATK_STATE_BUSY, ATK_STATE_CHECKED, ATK_STATE_DEFUNCT, ATK_STATE_EDITABLE, ATK_STATE_ENABLED, ATK_STATE_EXPANDABLE, ATK_STATE_EXPANDED, ATK_STATE_FOCUSABLE, ATK_STATE_FOCUSED, ATK_STATE_HORIZONTAL, ATK_STATE_ICONIFIED, ATK_STATE_MODAL, ATK_STATE_MULTI_LINE, ATK_STATE_MULTISELECTABLE, ATK_STATE_OPAQUE, ATK_STATE_PRESSED, ATK_STATE_RESIZABLE, ATK_STATE_SELECTABLE, ATK_STATE_SELECTED, ATK_STATE_SENSITIVE, ATK_STATE_SHOWING, ATK_STATE_SINGLE_LINE, ATK_STATE_STALE, ATK_STATE_TRANSIENT, ATK_STATE_VERTICAL, ATK_STATE_VISIBLE, ATK_STATE_MANAGES_DESCENDANTS, ATK_STATE_INDETERMINATE, ATK_STATE_LAST_DEFINED }; alias guint64 AtkState; AtkStateType atk_state_type_register ( gchar *name); gchar* atk_state_type_get_name (AtkStateType type); AtkStateType atk_state_type_for_name ( gchar *name); enum AtkRelationType { ATK_RELATION_NULL = 0, ATK_RELATION_CONTROLLED_BY, ATK_RELATION_CONTROLLER_FOR, ATK_RELATION_LABEL_FOR, ATK_RELATION_LABELLED_BY, ATK_RELATION_MEMBER_OF, ATK_RELATION_NODE_CHILD_OF, ATK_RELATION_FLOWS_TO, ATK_RELATION_FLOWS_FROM, ATK_RELATION_SUBWINDOW_OF, ATK_RELATION_EMBEDS, ATK_RELATION_EMBEDDED_BY, ATK_RELATION_POPUP_FOR, ATK_RELATION_LAST_DEFINED }; enum AtkRole { ATK_ROLE_INVALID = 0, ATK_ROLE_ACCEL_LABEL, ATK_ROLE_ALERT, ATK_ROLE_ANIMATION, ATK_ROLE_ARROW, ATK_ROLE_CALENDAR, ATK_ROLE_CANVAS, ATK_ROLE_CHECK_BOX, ATK_ROLE_CHECK_MENU_ITEM, ATK_ROLE_COLOR_CHOOSER, ATK_ROLE_COLUMN_HEADER, ATK_ROLE_COMBO_BOX, ATK_ROLE_DATE_EDITOR, ATK_ROLE_DESKTOP_ICON, ATK_ROLE_DESKTOP_FRAME, ATK_ROLE_DIAL, ATK_ROLE_DIALOG, ATK_ROLE_DIRECTORY_PANE, ATK_ROLE_DRAWING_AREA, ATK_ROLE_FILE_CHOOSER, ATK_ROLE_FILLER, ATK_ROLE_FONT_CHOOSER, ATK_ROLE_FRAME, ATK_ROLE_GLASS_PANE, ATK_ROLE_HTML_CONTAINER, ATK_ROLE_ICON, ATK_ROLE_IMAGE, ATK_ROLE_INTERNAL_FRAME, ATK_ROLE_LABEL, ATK_ROLE_LAYERED_PANE, ATK_ROLE_LIST, ATK_ROLE_LIST_ITEM, ATK_ROLE_MENU, ATK_ROLE_MENU_BAR, ATK_ROLE_MENU_ITEM, ATK_ROLE_OPTION_PANE, ATK_ROLE_PAGE_TAB, ATK_ROLE_PAGE_TAB_LIST, ATK_ROLE_PANEL, ATK_ROLE_PASSWORD_TEXT, ATK_ROLE_POPUP_MENU, ATK_ROLE_PROGRESS_BAR, ATK_ROLE_PUSH_BUTTON, ATK_ROLE_RADIO_BUTTON, ATK_ROLE_RADIO_MENU_ITEM, ATK_ROLE_ROOT_PANE, ATK_ROLE_ROW_HEADER, ATK_ROLE_SCROLL_BAR, ATK_ROLE_SCROLL_PANE, ATK_ROLE_SEPARATOR, ATK_ROLE_SLIDER, ATK_ROLE_SPLIT_PANE, ATK_ROLE_SPIN_BUTTON, ATK_ROLE_STATUSBAR, ATK_ROLE_TABLE, ATK_ROLE_TABLE_CELL, ATK_ROLE_TABLE_COLUMN_HEADER, ATK_ROLE_TABLE_ROW_HEADER, ATK_ROLE_TEAR_OFF_MENU_ITEM, ATK_ROLE_TERMINAL, ATK_ROLE_TEXT, ATK_ROLE_TOGGLE_BUTTON, ATK_ROLE_TOOL_BAR, ATK_ROLE_TOOL_TIP, ATK_ROLE_TREE, ATK_ROLE_TREE_TABLE, ATK_ROLE_UNKNOWN, ATK_ROLE_VIEWPORT, ATK_ROLE_WINDOW, ATK_ROLE_HEADER, ATK_ROLE_FOOTER, ATK_ROLE_PARAGRAPH, ATK_ROLE_RULER, ATK_ROLE_APPLICATION, ATK_ROLE_AUTOCOMPLETE, ATK_ROLE_EDITBAR, ATK_ROLE_LAST_DEFINED }; AtkRole atk_role_register ( gchar *name); enum AtkLayer { ATK_LAYER_INVALID, ATK_LAYER_BACKGROUND, ATK_LAYER_CANVAS, ATK_LAYER_WIDGET, ATK_LAYER_MDI, ATK_LAYER_POPUP, ATK_LAYER_OVERLAY, ATK_LAYER_WINDOW }; alias _AtkImplementor AtkImplementor; alias void _AtkImplementor; alias _AtkImplementorIface AtkImplementorIface; alias _AtkObject AtkObject; alias _AtkObjectClass AtkObjectClass; alias _AtkRelationSet AtkRelationSet; alias _AtkStateSet AtkStateSet; struct _AtkPropertyValues { gchar *property_name; GValue old_value; GValue new_value; } alias _AtkPropertyValues AtkPropertyValues; alias gboolean (*AtkFunction) (gpointer data); alias void (*AtkPropertyChangeHandler) (AtkObject*, AtkPropertyValues*); struct _AtkObject { GObject parent; gchar *description; gchar *name; AtkObject *accessible_parent; AtkRole role; AtkRelationSet *relation_set; AtkLayer layer; } struct _AtkObjectClass { GObjectClass parent; gchar* (* get_name) (AtkObject *accessible); gchar* (* get_description) (AtkObject *accessible); AtkObject* (*get_parent) (AtkObject *accessible); gint (* get_n_children) (AtkObject *accessible); AtkObject* (* ref_child) (AtkObject *accessible, gint i); gint (* get_index_in_parent) (AtkObject *accessible); AtkRelationSet* (* ref_relation_set) (AtkObject *accessible); AtkRole (* get_role) (AtkObject *accessible); AtkLayer (* get_layer) (AtkObject *accessible); gint (* get_mdi_zorder) (AtkObject *accessible); AtkStateSet* (* ref_state_set) (AtkObject *accessible); void (* set_name) (AtkObject *accessible, gchar *name); void (* set_description) (AtkObject *accessible, gchar *description); void (* set_parent) (AtkObject *accessible, AtkObject *parent); void (* set_role) (AtkObject *accessible, AtkRole role); guint (* connect_property_change_handler) (AtkObject *accessible, AtkPropertyChangeHandler *handler); void (* remove_property_change_handler) (AtkObject *accessible, guint handler_id); void (* initialize) (AtkObject *accessible, gpointer data); void (* children_changed) (AtkObject *accessible, guint change_index, gpointer changed_child); void (* focus_event) (AtkObject *accessible, gboolean focus_in); void (* property_change) (AtkObject *accessible, AtkPropertyValues *values); void (* state_change) (AtkObject *accessible, gchar *name, gboolean state_set); void (*visible_data_changed) (AtkObject *accessible); void (*active_descendant_changed) (AtkObject *accessible, gpointer *child); AtkFunction pad1; AtkFunction pad2; AtkFunction pad3; } GType atk_object_get_type (); struct _AtkImplementorIface { GTypeInterface parent; AtkObject* (*ref_accessible) (AtkImplementor *implementor); } GType atk_implementor_get_type (); AtkObject* atk_implementor_ref_accessible (AtkImplementor *implementor); gchar* atk_object_get_name (AtkObject *accessible); gchar* atk_object_get_description (AtkObject *accessible); AtkObject* atk_object_get_parent (AtkObject *accessible); gint atk_object_get_n_accessible_children (AtkObject *accessible); AtkObject* atk_object_ref_accessible_child (AtkObject *accessible, gint i); AtkRelationSet* atk_object_ref_relation_set (AtkObject *accessible); AtkRole atk_object_get_role (AtkObject *accessible); AtkLayer atk_object_get_layer (AtkObject *accessible); gint atk_object_get_mdi_zorder (AtkObject *accessible); AtkStateSet* atk_object_ref_state_set (AtkObject *accessible); gint atk_object_get_index_in_parent (AtkObject *accessible); void atk_object_set_name (AtkObject *accessible, gchar *name); void atk_object_set_description (AtkObject *accessible, gchar *description); void atk_object_set_parent (AtkObject *accessible, AtkObject *parent); void atk_object_set_role (AtkObject *accessible, AtkRole role); guint atk_object_connect_property_change_handler (AtkObject *accessible, AtkPropertyChangeHandler *handler); void atk_object_remove_property_change_handler (AtkObject *accessible, guint handler_id); void atk_object_notify_state_change (AtkObject *accessible, AtkState state, gboolean value); void atk_object_initialize (AtkObject *accessible, gpointer data); gchar* atk_role_get_name (AtkRole role); AtkRole atk_role_for_name ( gchar *name); gboolean atk_object_add_relationship (AtkObject *object, AtkRelationType relationship, AtkObject *target); gboolean atk_object_remove_relationship (AtkObject *object, AtkRelationType relationship, AtkObject *target); gchar* atk_role_get_localized_name (AtkRole role); enum GtkWidgetFlags { 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, GTK_DOUBLE_BUFFERED = 1 << 21, GTK_NO_SHOW_ALL = 1 << 22 }; enum GtkWidgetHelpType { GTK_WIDGET_HELP_TOOLTIP, GTK_WIDGET_HELP_WHATS_THIS }; alias _GtkRequisition GtkRequisition; alias GdkRectangle GtkAllocation; alias _GtkSelectionData GtkSelectionData; alias _GtkWidgetClass GtkWidgetClass; alias _GtkWidgetAuxInfo GtkWidgetAuxInfo; alias _GtkWidgetShapeInfo GtkWidgetShapeInfo; alias _GtkClipboard GtkClipboard; alias void _GtkClipboard; alias void (*GtkCallback) (GtkWidget *widget, gpointer data); struct _GtkRequisition { gint width; gint height; } 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 (*dispatch_child_properties_changed) (GtkWidget *widget, guint n_pspecs, GParamSpec **pspecs); 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 (* 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 (* hierarchy_changed) (GtkWidget *widget, GtkWidget *previous_toplevel); void (* style_set) (GtkWidget *widget, GtkStyle *previous_style); void (* direction_changed) (GtkWidget *widget, GtkTextDirection previous_direction); void (* grab_notify) (GtkWidget *widget, gboolean was_grabbed); void (* child_notify) (GtkWidget *widget, GParamSpec *pspec); gboolean (* mnemonic_activate) (GtkWidget *widget, gboolean group_cycling); void (* grab_focus) (GtkWidget *widget); gboolean (* focus) (GtkWidget *widget, GtkDirectionType direction); gboolean (* event) (GtkWidget *widget, GdkEvent *event); gboolean (* button_press_event) (GtkWidget *widget, GdkEventButton *event); gboolean (* button_release_event) (GtkWidget *widget, GdkEventButton *event); gboolean (* scroll_event) (GtkWidget *widget, GdkEventScroll *event); gboolean (* motion_notify_event) (GtkWidget *widget, GdkEventMotion *event); gboolean (* delete_event) (GtkWidget *widget, GdkEventAny *event); gboolean (* destroy_event) (GtkWidget *widget, GdkEventAny *event); gboolean (* expose_event) (GtkWidget *widget, GdkEventExpose *event); gboolean (* key_press_event) (GtkWidget *widget, GdkEventKey *event); gboolean (* key_release_event) (GtkWidget *widget, GdkEventKey *event); gboolean (* enter_notify_event) (GtkWidget *widget, GdkEventCrossing *event); gboolean (* leave_notify_event) (GtkWidget *widget, GdkEventCrossing *event); gboolean (* configure_event) (GtkWidget *widget, GdkEventConfigure *event); gboolean (* focus_in_event) (GtkWidget *widget, GdkEventFocus *event); gboolean (* focus_out_event) (GtkWidget *widget, GdkEventFocus *event); gboolean (* map_event) (GtkWidget *widget, GdkEventAny *event); gboolean (* unmap_event) (GtkWidget *widget, GdkEventAny *event); gboolean (* property_notify_event) (GtkWidget *widget, GdkEventProperty *event); gboolean (* selection_clear_event) (GtkWidget *widget, GdkEventSelection *event); gboolean (* selection_request_event) (GtkWidget *widget, GdkEventSelection *event); gboolean (* selection_notify_event) (GtkWidget *widget, GdkEventSelection *event); gboolean (* proximity_in_event) (GtkWidget *widget, GdkEventProximity *event); gboolean (* proximity_out_event) (GtkWidget *widget, GdkEventProximity *event); gboolean (* visibility_notify_event) (GtkWidget *widget, GdkEventVisibility *event); gboolean (* client_event) (GtkWidget *widget, GdkEventClient *event); gboolean (* no_expose_event) (GtkWidget *widget, GdkEventAny *event); gboolean (* window_state_event) (GtkWidget *widget, GdkEventWindowState *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_); gboolean (* popup_menu) (GtkWidget *widget); gboolean (* show_help) (GtkWidget *widget, GtkWidgetHelpType help_type); AtkObject* (*get_accessible) (GtkWidget *widget); void (*screen_changed) (GtkWidget *widget, GdkScreen *previous_screen); gboolean (*can_activate_accel) (GtkWidget *widget, guint signal_id); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); void (*_gtk_reserved5) (); void (*_gtk_reserved6) (); void (*_gtk_reserved7) (); } struct _GtkWidgetAuxInfo { gint x; gint y; gint width; gint height; guint x_set; guint y_set; } struct _GtkWidgetShapeInfo { gint16 offset_x; gint16 offset_y; GdkBitmap *shape_mask; } GType gtk_widget_get_type () ; GtkWidget* gtk_widget_new (GType type, gchar *first_property_name, ...); GtkWidget* 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_set (GtkWidget *widget, gchar *first_property_name, ...); 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_set_no_show_all (GtkWidget *widget, gboolean no_show_all); gboolean gtk_widget_get_no_show_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_queue_resize_no_redraw (GtkWidget *widget); void gtk_widget_draw (GtkWidget *widget, GdkRectangle *area); 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, gchar *accel_signal, GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags); gboolean gtk_widget_remove_accelerator (GtkWidget *widget, GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods); void gtk_widget_set_accel_path (GtkWidget *widget, gchar *accel_path, GtkAccelGroup *accel_group); gchar* _gtk_widget_get_accel_path (GtkWidget *widget, gboolean *locked); GList* gtk_widget_list_accel_closures (GtkWidget *widget); gboolean gtk_widget_can_activate_accel (GtkWidget *widget, guint signal_id); gboolean gtk_widget_mnemonic_activate (GtkWidget *widget, gboolean group_cycling); gboolean gtk_widget_event (GtkWidget *widget, GdkEvent *event); gint gtk_widget_send_expose (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); gboolean gtk_widget_intersect (GtkWidget *widget, GdkRectangle *area, GdkRectangle *intersection); GdkRegion *gtk_widget_region_intersect (GtkWidget *widget, GdkRegion *region); void gtk_widget_freeze_child_notify (GtkWidget *widget); void gtk_widget_child_notify (GtkWidget *widget, gchar *child_property); void gtk_widget_thaw_child_notify (GtkWidget *widget); gboolean gtk_widget_is_focus (GtkWidget *widget); void gtk_widget_grab_focus (GtkWidget *widget); void gtk_widget_grab_default (GtkWidget *widget); void gtk_widget_set_name (GtkWidget *widget, 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_double_buffered (GtkWidget *widget, gboolean double_buffered); void gtk_widget_set_redraw_on_allocate (GtkWidget *widget, gboolean redraw_on_allocate); void gtk_widget_set_parent (GtkWidget *widget, GtkWidget *parent); void gtk_widget_set_parent_window (GtkWidget *widget, GdkWindow *parent_window); void gtk_widget_set_child_visible (GtkWidget *widget, gboolean is_visible); gboolean gtk_widget_get_child_visible (GtkWidget *widget); GtkWidget *gtk_widget_get_parent (GtkWidget *widget); GdkWindow *gtk_widget_get_parent_window (GtkWidget *widget); gboolean gtk_widget_child_focus (GtkWidget *widget, GtkDirectionType direction); void gtk_widget_set_size_request (GtkWidget *widget, gint width, gint height); void gtk_widget_get_size_request (GtkWidget *widget, gint *width, gint *height); 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, GType widget_type); GdkColormap* gtk_widget_get_colormap (GtkWidget *widget); GdkVisual* gtk_widget_get_visual (GtkWidget *widget); GdkScreen * gtk_widget_get_screen (GtkWidget *widget); gboolean gtk_widget_has_screen (GtkWidget *widget); GdkDisplay * gtk_widget_get_display (GtkWidget *widget); GdkWindow * gtk_widget_get_root_window (GtkWidget *widget); GtkSettings* gtk_widget_get_settings (GtkWidget *widget); GtkClipboard *gtk_widget_get_clipboard (GtkWidget *widget, GdkAtom selection); AtkObject* gtk_widget_get_accessible (GtkWidget *widget); void gtk_widget_set_colormap (GtkWidget *widget, GdkColormap *colormap); 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); gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget, GtkWidget *dest_widget, gint src_x, gint src_y, gint *dest_x, gint *dest_y); gboolean gtk_widget_hide_on_delete (GtkWidget *widget); void gtk_widget_set_style (GtkWidget *widget, GtkStyle *style); void gtk_widget_ensure_style (GtkWidget *widget); GtkStyle* gtk_widget_get_style (GtkWidget *widget); void gtk_widget_modify_style (GtkWidget *widget, GtkRcStyle *style); GtkRcStyle *gtk_widget_get_modifier_style (GtkWidget *widget); void gtk_widget_modify_fg (GtkWidget *widget, GtkStateType state, GdkColor *color); void gtk_widget_modify_bg (GtkWidget *widget, GtkStateType state, GdkColor *color); void gtk_widget_modify_text (GtkWidget *widget, GtkStateType state, GdkColor *color); void gtk_widget_modify_base (GtkWidget *widget, GtkStateType state, GdkColor *color); void gtk_widget_modify_font (GtkWidget *widget, PangoFontDescription *font_desc); PangoContext *gtk_widget_create_pango_context (GtkWidget *widget); PangoContext *gtk_widget_get_pango_context (GtkWidget *widget); PangoLayout *gtk_widget_create_pango_layout (GtkWidget *widget, gchar *text); GdkPixbuf *gtk_widget_render_icon (GtkWidget *widget, gchar *stock_id, GtkIconSize size, gchar *detail); void gtk_widget_set_composite_name (GtkWidget *widget, gchar *name); gchar* gtk_widget_get_composite_name (GtkWidget *widget); void gtk_widget_reset_rc_styles (GtkWidget *widget); void gtk_widget_push_colormap (GdkColormap *cmap); void gtk_widget_push_composite_child (); void gtk_widget_pop_composite_child (); void gtk_widget_pop_colormap (); void gtk_widget_class_install_style_property (GtkWidgetClass *klass, GParamSpec *pspec); void gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, GParamSpec *pspec, GtkRcPropertyParser parser); GParamSpec* gtk_widget_class_find_style_property (GtkWidgetClass *klass, gchar *property_name); GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass *klass, guint *n_properties); void gtk_widget_style_get_property (GtkWidget *widget, gchar *property_name, GValue *value); void gtk_widget_style_get_valist (GtkWidget *widget, gchar *first_property_name, va_list var_args); void gtk_widget_style_get (GtkWidget *widget, gchar *first_property_name, ...); void gtk_widget_set_default_colormap (GdkColormap *colormap); GtkStyle* gtk_widget_get_default_style (); GdkColormap* gtk_widget_get_default_colormap (); GdkVisual* gtk_widget_get_default_visual (); void gtk_widget_set_direction (GtkWidget *widget, GtkTextDirection dir); GtkTextDirection gtk_widget_get_direction (GtkWidget *widget); void gtk_widget_set_default_direction (GtkTextDirection dir); GtkTextDirection gtk_widget_get_default_direction (); 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); GList* gtk_widget_list_mnemonic_labels (GtkWidget *widget); void gtk_widget_add_mnemonic_label (GtkWidget *widget, GtkWidget *label); void gtk_widget_remove_mnemonic_label (GtkWidget *widget, GtkWidget *label); GType gtk_requisition_get_type (); GtkRequisition *gtk_requisition_copy ( GtkRequisition *requisition); void gtk_requisition_free (GtkRequisition *requisition); void _gtk_widget_grab_notify (GtkWidget *widget, gboolean was_grabbed); GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget, gboolean create); void _gtk_widget_propagate_hierarchy_changed (GtkWidget *widget, GtkWidget *previous_toplevel); void _gtk_widget_propagate_screen_changed (GtkWidget *widget, GdkScreen *previous_screen); GdkColormap* _gtk_widget_peek_colormap (); alias _GtkMisc GtkMisc; alias _GtkMiscClass GtkMiscClass; struct _GtkMisc { GtkWidget widget; gfloat xalign; gfloat yalign; guint16 xpad; guint16 ypad; } struct _GtkMiscClass { GtkWidgetClass parent_class; } GType gtk_misc_get_type () ; void gtk_misc_set_alignment (GtkMisc *misc, gfloat xalign, gfloat yalign); void gtk_misc_get_alignment (GtkMisc *misc, gfloat *xalign, gfloat *yalign); void gtk_misc_set_padding (GtkMisc *misc, gint xpad, gint ypad); void gtk_misc_get_padding (GtkMisc *misc, gint *xpad, gint *ypad); alias _GtkContainer GtkContainer; alias _GtkContainerClass GtkContainerClass; struct _GtkContainer { GtkWidget widget; GtkWidget *focus_child; guint border_width; /* needs alignment work BVH guint need_resize; guint resize_mode; guint reallocate_redraws; guint has_focus_chain; */ } struct _GtkContainerClass { GtkWidgetClass parent_class; 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 callback_data); void (*set_focus_child) (GtkContainer *container, GtkWidget *widget); GType (*child_type) (GtkContainer *container); gchar* (*composite_name) (GtkContainer *container, GtkWidget *child); void (*set_child_property) (GtkContainer *container, GtkWidget *child, guint property_id, GValue *value, GParamSpec *pspec); void (*get_child_property) (GtkContainer *container, GtkWidget *child, guint property_id, GValue *value, GParamSpec *pspec); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_container_get_type () ; void gtk_container_set_border_width (GtkContainer *container, guint border_width); guint gtk_container_get_border_width (GtkContainer *container); 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); GtkResizeMode gtk_container_get_resize_mode (GtkContainer *container); 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_get_children (GtkContainer *container); void gtk_container_propagate_expose (GtkContainer *container, GtkWidget *child, GdkEventExpose *event); void gtk_container_set_focus_chain (GtkContainer *container, GList *focusable_widgets); gboolean gtk_container_get_focus_chain (GtkContainer *container, GList **focusable_widgets); void gtk_container_unset_focus_chain (GtkContainer *container); 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); GtkAdjustment *gtk_container_get_focus_vadjustment (GtkContainer *container); void gtk_container_set_focus_hadjustment (GtkContainer *container, GtkAdjustment *adjustment); GtkAdjustment *gtk_container_get_focus_hadjustment (GtkContainer *container); void gtk_container_resize_children (GtkContainer *container); GType gtk_container_child_type (GtkContainer *container); void gtk_container_class_install_child_property (GtkContainerClass *cclass, guint property_id, GParamSpec *pspec); GParamSpec* gtk_container_class_find_child_property (GObjectClass *cclass, gchar *property_name); GParamSpec** gtk_container_class_list_child_properties (GObjectClass *cclass, guint *n_properties); void gtk_container_add_with_properties (GtkContainer *container, GtkWidget *widget, gchar *first_prop_name, ...); void gtk_container_child_set (GtkContainer *container, GtkWidget *child, gchar *first_prop_name, ...); void gtk_container_child_get (GtkContainer *container, GtkWidget *child, gchar *first_prop_name, ...); void gtk_container_child_set_valist (GtkContainer *container, GtkWidget *child, gchar *first_property_name, va_list var_args); void gtk_container_child_get_valist (GtkContainer *container, GtkWidget *child, gchar *first_property_name, va_list var_args); void gtk_container_child_set_property (GtkContainer *container, GtkWidget *child, gchar *property_name, GValue *value); void gtk_container_child_get_property (GtkContainer *container, GtkWidget *child, gchar *property_name, GValue *value); void gtk_container_forall (GtkContainer *container, GtkCallback callback, gpointer callback_data); void _gtk_container_queue_resize (GtkContainer *container); void _gtk_container_clear_resize_widgets (GtkContainer *container); gchar* _gtk_container_child_composite_name (GtkContainer *container, GtkWidget *child); void _gtk_container_dequeue_resize_handler (GtkContainer *container); GList *_gtk_container_focus_sort (GtkContainer *container, GList *children, GtkDirectionType direction, GtkWidget *old_focus); alias _GtkBin GtkBin; alias _GtkBinClass GtkBinClass; struct _GtkBin { GtkContainer container; GtkWidget *child; } struct _GtkBinClass { GtkContainerClass parent_class; } GType gtk_bin_get_type () ; GtkWidget *gtk_bin_get_child (GtkBin *bin); alias _GtkWindow GtkWindow; alias _GtkWindowClass GtkWindowClass; alias _GtkWindowGeometryInfo GtkWindowGeometryInfo; alias void _GtkWindowGeometryInfo; alias _GtkWindowGroup GtkWindowGroup; alias _GtkWindowGroupClass GtkWindowGroupClass; struct _GtkWindow { GtkBin bin; gchar *title; gchar *wmclass_name; gchar *wmclass_class; gchar *wm_role; GtkWidget *focus_widget; GtkWidget *default_widget; GtkWindow *transient_parent; GtkWindowGeometryInfo *geometry_info; GdkWindow *frame; GtkWindowGroup *group; guint16 configure_request_count; guint allow_shrink; guint allow_grow; guint configure_notify_received; guint need_default_position; guint need_default_size; guint position; guint type; guint has_user_ref_count; guint has_focus; guint modal; guint destroy_with_parent; guint has_frame; guint iconify_initially; guint stick_initially; guint maximize_initially; guint decorated; guint type_hint; guint gravity; guint is_active; guint has_toplevel_focus; guint frame_left; guint frame_top; guint frame_right; guint frame_bottom; guint keys_changed_handler; GdkModifierType mnemonic_modifier; GdkScreen *screen; } struct _GtkWindowClass { GtkBinClass parent_class; void (* set_focus) (GtkWindow *window, GtkWidget *focus); gboolean (* frame_event) (GtkWindow *window, GdkEvent *event); void (* activate_focus) (GtkWindow *window); void (* activate_default) (GtkWindow *window); void (* move_focus) (GtkWindow *window, GtkDirectionType direction); void (*keys_changed) (GtkWindow *window); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkWindowGroup { GObject parent_instance; GSList *grabs; } struct _GtkWindowGroupClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_window_get_type () ; GtkWidget* gtk_window_new (GtkWindowType type); void gtk_window_set_title (GtkWindow *window, gchar *title); gchar *gtk_window_get_title (GtkWindow *window); void gtk_window_set_wmclass (GtkWindow *window, gchar *wmclass_name, gchar *wmclass_class); void gtk_window_set_role (GtkWindow *window, gchar *role); gchar *gtk_window_get_role (GtkWindow *window); 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); gboolean gtk_window_activate_focus (GtkWindow *window); void gtk_window_set_focus (GtkWindow *window, GtkWidget *focus); GtkWidget *gtk_window_get_focus (GtkWindow *window); void gtk_window_set_default (GtkWindow *window, GtkWidget *default_widget); gboolean gtk_window_activate_default (GtkWindow *window); void gtk_window_set_transient_for (GtkWindow *window, GtkWindow *parent); GtkWindow *gtk_window_get_transient_for (GtkWindow *window); void gtk_window_set_type_hint (GtkWindow *window, GdkWindowTypeHint hint); GdkWindowTypeHint gtk_window_get_type_hint (GtkWindow *window); void gtk_window_set_skip_taskbar_hint (GtkWindow *window, gboolean setting); gboolean gtk_window_get_skip_taskbar_hint (GtkWindow *window); void gtk_window_set_skip_pager_hint (GtkWindow *window, gboolean setting); gboolean gtk_window_get_skip_pager_hint (GtkWindow *window); void gtk_window_set_accept_focus (GtkWindow *window, gboolean setting); gboolean gtk_window_get_accept_focus (GtkWindow *window); void gtk_window_set_destroy_with_parent (GtkWindow *window, gboolean setting); gboolean gtk_window_get_destroy_with_parent (GtkWindow *window); void gtk_window_set_resizable (GtkWindow *window, gboolean resizable); gboolean gtk_window_get_resizable (GtkWindow *window); void gtk_window_set_gravity (GtkWindow *window, GdkGravity gravity); GdkGravity gtk_window_get_gravity (GtkWindow *window); void gtk_window_set_geometry_hints (GtkWindow *window, GtkWidget *geometry_widget, GdkGeometry *geometry, GdkWindowHints geom_mask); void gtk_window_set_screen (GtkWindow *window, GdkScreen *screen); GdkScreen* gtk_window_get_screen (GtkWindow *window); gboolean gtk_window_is_active (GtkWindow *window); gboolean gtk_window_has_toplevel_focus (GtkWindow *window); void gtk_window_set_has_frame (GtkWindow *window, gboolean setting); gboolean gtk_window_get_has_frame (GtkWindow *window); void gtk_window_set_frame_dimensions (GtkWindow *window, gint left, gint top, gint right, gint bottom); void gtk_window_get_frame_dimensions (GtkWindow *window, gint *left, gint *top, gint *right, gint *bottom); void gtk_window_set_decorated (GtkWindow *window, gboolean setting); gboolean gtk_window_get_decorated (GtkWindow *window); void gtk_window_set_icon_list (GtkWindow *window, GList *list); GList* gtk_window_get_icon_list (GtkWindow *window); void gtk_window_set_icon (GtkWindow *window, GdkPixbuf *icon); gboolean gtk_window_set_icon_from_file (GtkWindow *window, gchar *filename, GError **err); GdkPixbuf* gtk_window_get_icon (GtkWindow *window); void gtk_window_set_default_icon_list (GList *list); GList* gtk_window_get_default_icon_list (); void gtk_window_set_default_icon (GdkPixbuf *icon); gboolean gtk_window_set_default_icon_from_file ( gchar *filename, GError **err); void gtk_window_set_auto_startup_notification (gboolean setting); void gtk_window_set_modal (GtkWindow *window, gboolean modal); gboolean gtk_window_get_modal (GtkWindow *window); GList* gtk_window_list_toplevels (); void gtk_window_add_mnemonic (GtkWindow *window, guint keyval, GtkWidget *target); void gtk_window_remove_mnemonic (GtkWindow *window, guint keyval, GtkWidget *target); gboolean gtk_window_mnemonic_activate (GtkWindow *window, guint keyval, GdkModifierType modifier); void gtk_window_set_mnemonic_modifier (GtkWindow *window, GdkModifierType modifier); GdkModifierType gtk_window_get_mnemonic_modifier (GtkWindow *window); gboolean gtk_window_activate_key (GtkWindow *window, GdkEventKey *event); gboolean gtk_window_propagate_key_event (GtkWindow *window, GdkEventKey *event); void gtk_window_present (GtkWindow *window); void gtk_window_iconify (GtkWindow *window); void gtk_window_deiconify (GtkWindow *window); void gtk_window_stick (GtkWindow *window); void gtk_window_unstick (GtkWindow *window); void gtk_window_maximize (GtkWindow *window); void gtk_window_unmaximize (GtkWindow *window); void gtk_window_fullscreen (GtkWindow *window); void gtk_window_unfullscreen (GtkWindow *window); void gtk_window_set_keep_above (GtkWindow *window, gboolean setting); void gtk_window_set_keep_below (GtkWindow *window, gboolean setting); void gtk_window_begin_resize_drag (GtkWindow *window, GdkWindowEdge edge, gint button, gint root_x, gint root_y, guint32 timestamp); void gtk_window_begin_move_drag (GtkWindow *window, gint button, gint root_x, gint root_y, guint32 timestamp); void gtk_window_set_policy (GtkWindow *window, gint allow_shrink, gint allow_grow, gint auto_shrink); void gtk_window_set_default_size (GtkWindow *window, gint width, gint height); void gtk_window_get_default_size (GtkWindow *window, gint *width, gint *height); void gtk_window_resize (GtkWindow *window, gint width, gint height); void gtk_window_get_size (GtkWindow *window, gint *width, gint *height); void gtk_window_move (GtkWindow *window, gint x, gint y); void gtk_window_get_position (GtkWindow *window, gint *root_x, gint *root_y); gboolean gtk_window_parse_geometry (GtkWindow *window, gchar *geometry); void gtk_window_reshow_with_initial_size (GtkWindow *window); GType gtk_window_group_get_type () ; GtkWindowGroup * gtk_window_group_new (); void gtk_window_group_add_window (GtkWindowGroup *window_group, GtkWindow *window); void gtk_window_group_remove_window (GtkWindowGroup *window_group, GtkWindow *window); void _gtk_window_internal_set_focus (GtkWindow *window, GtkWidget *focus); 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); void _gtk_window_rain_size (GtkWindow *window, gint width, gint height, gint *new_width, gint *new_height); GtkWindowGroup *_gtk_window_get_group (GtkWindow *window); void _gtk_window_set_has_toplevel_focus (GtkWindow *window, gboolean has_toplevel_focus); void _gtk_window_unset_focus_and_default (GtkWindow *window, GtkWidget *widget); void _gtk_window_set_is_active (GtkWindow *window, gboolean is_active); alias void (*GtkWindowKeysForeachFunc) (GtkWindow *window, guint keyval, GdkModifierType modifiers, gboolean is_mnemonic, gpointer data); void _gtk_window_keys_foreach (GtkWindow *window, GtkWindowKeysForeachFunc func, gpointer func_data); gboolean _gtk_window_query_nonaccels (GtkWindow *window, guint accel_key, GdkModifierType accel_mods); alias _GtkMenuShell GtkMenuShell; alias _GtkMenuShellClass GtkMenuShellClass; struct _GtkMenuShell { GtkContainer container; GList *children; GtkWidget *active_menu_item; GtkWidget *parent_menu_shell; guint button; guint32 activate_time; guint active; guint have_grab; guint have_xgrab; guint ignore_leave; guint menu_flag; guint ignore_enter; } struct _GtkMenuShellClass { GtkContainerClass parent_class; guint submenu_placement; 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); void (*select_item) (GtkMenuShell *menu_shell, GtkWidget *menu_item); void (*insert) (GtkMenuShell *menu_shell, GtkWidget *child, gint position); gint (*get_popup_delay) (GtkMenuShell *menu_shell); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_menu_shell_get_type () ; 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); void gtk_menu_shell_select_first (GtkMenuShell *menu_shell, gboolean search_sensitive); void _gtk_menu_shell_select_last (GtkMenuShell *menu_shell, gboolean search_sensitive); void _gtk_menu_shell_activate (GtkMenuShell *menu_shell); gint _gtk_menu_shell_get_popup_delay (GtkMenuShell *menu_shell); void gtk_menu_shell_cancel (GtkMenuShell *menu_shell); alias _GtkMenu GtkMenu; alias _GtkMenuClass GtkMenuClass; alias void (*GtkMenuPositionFunc) (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data); alias void (*GtkMenuDetachFunc) (GtkWidget *attach_widget, GtkMenu *menu); struct _GtkMenu { GtkMenuShell menu_shell; GtkWidget *parent_menu_item; GtkWidget *old_active_menu_item; GtkAccelGroup *accel_group; gchar *accel_path; GtkMenuPositionFunc position_func; gpointer position_func_data; guint toggle_size; GtkWidget *toplevel; GtkWidget *tearoff_window; GtkWidget *tearoff_hbox; GtkWidget *tearoff_scrollbar; GtkAdjustment *tearoff_adjustment; GdkWindow *view_window; GdkWindow *bin_window; gint scroll_offset; gint saved_scroll_offset; gint scroll_step; guint timeout_id; GdkRegion *navigation_region; guint navigation_timeout; guint torn_off; guint tearoff_active; guint scroll_fast; guint upper_arrow_visible; guint lower_arrow_visible; guint upper_arrow_prelight; guint lower_arrow_prelight; } struct _GtkMenuClass { GtkMenuShellClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_menu_get_type () ; GtkWidget* gtk_menu_new (); 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); void gtk_menu_set_accel_path (GtkMenu *menu, gchar *accel_path); 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); gboolean gtk_menu_get_tearoff_state (GtkMenu *menu); void gtk_menu_set_title (GtkMenu *menu, gchar *title); gchar *gtk_menu_get_title (GtkMenu *menu); void gtk_menu_reorder_child (GtkMenu *menu, GtkWidget *child, gint position); void gtk_menu_set_screen (GtkMenu *menu, GdkScreen *screen); void gtk_menu_attach (GtkMenu *menu, GtkWidget *child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach); void gtk_menu_set_monitor (GtkMenu *menu, gint monitor_num); alias _GtkLabel GtkLabel; alias _GtkLabelClass GtkLabelClass; alias _GtkLabelSelectionInfo GtkLabelSelectionInfo; alias void _GtkLabelSelectionInfo; struct _GtkLabel { GtkMisc misc; gchar *label; guint jtype; guint wrap; guint use_underline; guint use_markup; guint mnemonic_keyval; gchar *text; PangoAttrList *attrs; PangoAttrList *effective_attrs; PangoLayout *layout; GtkWidget *mnemonic_widget; GtkWindow *mnemonic_window; GtkLabelSelectionInfo *select_info; } struct _GtkLabelClass { GtkMiscClass parent_class; void (* move_cursor) (GtkLabel *label, GtkMovementStep step, gint count, gboolean extend_selection); void (* copy_clipboard) (GtkLabel *label); void (* populate_popup) (GtkLabel *label, GtkMenu *menu); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_label_get_type () ; GtkWidget* gtk_label_new ( char *str); GtkWidget* gtk_label_new_with_mnemonic ( char *str); void gtk_label_set_text (GtkLabel *label, char *str); gchar* gtk_label_get_text (GtkLabel *label); void gtk_label_set_attributes (GtkLabel *label, PangoAttrList *attrs); PangoAttrList *gtk_label_get_attributes (GtkLabel *label); void gtk_label_set_label (GtkLabel *label, gchar *str); gchar *gtk_label_get_label (GtkLabel *label); void gtk_label_set_markup (GtkLabel *label, gchar *str); void gtk_label_set_use_markup (GtkLabel *label, gboolean setting); gboolean gtk_label_get_use_markup (GtkLabel *label); void gtk_label_set_use_underline (GtkLabel *label, gboolean setting); gboolean gtk_label_get_use_underline (GtkLabel *label); void gtk_label_set_markup_with_mnemonic (GtkLabel *label, gchar *str); guint gtk_label_get_mnemonic_keyval (GtkLabel *label); void gtk_label_set_mnemonic_widget (GtkLabel *label, GtkWidget *widget); GtkWidget *gtk_label_get_mnemonic_widget (GtkLabel *label); void gtk_label_set_text_with_mnemonic (GtkLabel *label, gchar *str); void gtk_label_set_justify (GtkLabel *label, GtkJustification jtype); GtkJustification gtk_label_get_justify (GtkLabel *label); void gtk_label_set_pattern (GtkLabel *label, gchar *pattern); void gtk_label_set_line_wrap (GtkLabel *label, gboolean wrap); gboolean gtk_label_get_line_wrap (GtkLabel *label); void gtk_label_set_selectable (GtkLabel *label, gboolean setting); gboolean gtk_label_get_selectable (GtkLabel *label); void gtk_label_select_region (GtkLabel *label, gint start_offset, gint end_offset); gboolean gtk_label_get_selection_bounds (GtkLabel *label, gint *start, gint *end); PangoLayout *gtk_label_get_layout (GtkLabel *label); void gtk_label_get_layout_offsets (GtkLabel *label, gint *x, gint *y); void gtk_label_get (GtkLabel *label, char **str); guint gtk_label_parse_uline (GtkLabel *label, gchar *string); alias _GtkAccelLabel GtkAccelLabel; alias _GtkAccelLabelClass GtkAccelLabelClass; struct _GtkAccelLabel { GtkLabel label; guint gtk_reserved; guint accel_padding; GtkWidget *accel_widget; GClosure *accel_closure; GtkAccelGroup *accel_group; 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; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_accel_label_get_type () ; GtkWidget* gtk_accel_label_new ( gchar *string); GtkWidget* gtk_accel_label_get_accel_widget (GtkAccelLabel *accel_label); guint gtk_accel_label_get_accel_width (GtkAccelLabel *accel_label); void gtk_accel_label_set_accel_widget (GtkAccelLabel *accel_label, GtkWidget *accel_widget); void gtk_accel_label_set_accel_closure (GtkAccelLabel *accel_label, GClosure *accel_closure); gboolean gtk_accel_label_refetch (GtkAccelLabel *accel_label); alias _GtkAccelMap GtkAccelMap; alias void _GtkAccelMap; alias _GtkAccelMapClass GtkAccelMapClass; alias void _GtkAccelMapClass; alias void (*GtkAccelMapForeach) (gpointer data, gchar *accel_path, guint accel_key, GdkModifierType accel_mods, gboolean changed); void gtk_accel_map_add_entry ( gchar *accel_path, guint accel_key, GdkModifierType accel_mods); gboolean gtk_accel_map_lookup_entry ( gchar *accel_path, GtkAccelKey *key); gboolean gtk_accel_map_change_entry ( gchar *accel_path, guint accel_key, GdkModifierType accel_mods, gboolean replace); void gtk_accel_map_load ( gchar *file_name); void gtk_accel_map_save ( gchar *file_name); void gtk_accel_map_foreach (gpointer data, GtkAccelMapForeach foreach_func); void gtk_accel_map_load_fd (gint fd); void gtk_accel_map_load_scanner (GScanner *scanner); void gtk_accel_map_save_fd (gint fd); void gtk_accel_map_lock_path ( gchar *accel_path); void gtk_accel_map_unlock_path ( gchar *accel_path); void gtk_accel_map_add_filter ( gchar *filter_pattern); void gtk_accel_map_foreach_unfiltered (gpointer data, GtkAccelMapForeach foreach_func); GType gtk_accel_map_get_type (); GtkAccelMap *gtk_accel_map_get (); void _gtk_accel_map_init (); void _gtk_accel_map_add_group ( gchar *accel_path, GtkAccelGroup *accel_group); void _gtk_accel_map_remove_group ( gchar *accel_path, GtkAccelGroup *accel_group); gboolean _gtk_accel_path_is_valid ( gchar *accel_path); alias _AtkAction AtkAction; alias void _AtkAction; alias _AtkActionIface AtkActionIface; struct _AtkActionIface { GTypeInterface parent; gboolean (*do_action) (AtkAction *action, gint i); gint (*get_n_actions) (AtkAction *action); gchar* (*get_description) (AtkAction *action, gint i); gchar* (*get_name) (AtkAction *action, gint i); gchar* (*get_keybinding) (AtkAction *action, gint i); gboolean (*set_description) (AtkAction *action, gint i, gchar *desc); gchar* (*get_localized_name)(AtkAction *action, gint i); AtkFunction pad2; } GType atk_action_get_type (); gboolean atk_action_do_action (AtkAction *action, gint i); gint atk_action_get_n_actions (AtkAction *action); gchar* atk_action_get_description (AtkAction *action, gint i); gchar* atk_action_get_name (AtkAction *action, gint i); gchar* atk_action_get_keybinding (AtkAction *action, gint i); gboolean atk_action_set_description (AtkAction *action, gint i, gchar *desc); gchar* atk_action_get_localized_name (AtkAction *action, gint i); alias _AtkUtil AtkUtil; alias _AtkUtilClass AtkUtilClass; alias _AtkKeyEventStruct AtkKeyEventStruct; alias void (*AtkEventListener) (AtkObject*); alias void (*AtkEventListenerInit) (); alias gint (*AtkKeySnoopFunc) (AtkKeyEventStruct *event, gpointer func_data); struct _AtkKeyEventStruct { gint type; guint state; guint keyval; gint length; gchar *string; guint16 keycode; guint32 timestamp; } enum AtkKeyEventType { ATK_KEY_EVENT_PRESS, ATK_KEY_EVENT_RELEASE, ATK_KEY_EVENT_LAST_DEFINED }; struct _AtkUtil { GObject parent; } struct _AtkUtilClass { GObjectClass parent; guint (* add_global_event_listener) (GSignalEmissionHook listener, gchar *event_type); void (* remove_global_event_listener) (guint listener_id); guint (* add_key_event_listener) (AtkKeySnoopFunc listener, gpointer data); void (* remove_key_event_listener) (guint listener_id); AtkObject* (* get_root) (); gchar* (* get_toolkit_name) (); gchar* (* get_toolkit_version) (); } GType atk_util_get_type (); enum AtkCoordType { ATK_XY_SCREEN, ATK_XY_WINDOW }; guint atk_add_focus_tracker (AtkEventListener focus_tracker); void atk_remove_focus_tracker (guint tracker_id); void atk_focus_tracker_init (AtkEventListenerInit add_function); void atk_focus_tracker_notify (AtkObject *object); guint atk_add_global_event_listener (GSignalEmissionHook listener, gchar *event_type); void atk_remove_global_event_listener (guint listener_id); guint atk_add_key_event_listener (AtkKeySnoopFunc listener, gpointer data); void atk_remove_key_event_listener (guint listener_id); AtkObject* atk_get_root(); AtkObject* atk_get_focus_object (); gchar *atk_get_toolkit_name (); gchar *atk_get_toolkit_version (); alias _AtkComponent AtkComponent; alias void _AtkComponent; alias _AtkComponentIface AtkComponentIface; alias void (*AtkFocusHandler) (AtkObject*, gboolean); struct _AtkComponentIface { GTypeInterface parent; guint (* add_focus_handler) (AtkComponent *component, AtkFocusHandler handler); gboolean (* contains) (AtkComponent *component, gint x, gint y, AtkCoordType coord_type); AtkObject* (* ref_accessible_at_point) (AtkComponent *component, gint x, gint y, AtkCoordType coord_type); void (* get_extents) (AtkComponent *component, gint *x, gint *y, gint *width, gint *height, AtkCoordType coord_type); void (* get_position) (AtkComponent *component, gint *x, gint *y, AtkCoordType coord_type); void (* get_size) (AtkComponent *component, gint *width, gint *height); gboolean (* grab_focus) (AtkComponent *component); void (* remove_focus_handler) (AtkComponent *component, guint handler_id); gboolean (* set_extents) (AtkComponent *component, gint x, gint y, gint width, gint height, AtkCoordType coord_type); gboolean (* set_position) (AtkComponent *component, gint x, gint y, AtkCoordType coord_type); gboolean (* set_size) (AtkComponent *component, gint width, gint height); AtkLayer (* get_layer) (AtkComponent *component); gint (* get_mdi_zorder) (AtkComponent *component); AtkFunction pad1; AtkFunction pad2; } GType atk_component_get_type (); guint atk_component_add_focus_handler (AtkComponent *component, AtkFocusHandler handler); gboolean atk_component_contains (AtkComponent *component, gint x, gint y, AtkCoordType coord_type); AtkObject* atk_component_ref_accessible_at_point(AtkComponent *component, gint x, gint y, AtkCoordType coord_type); void atk_component_get_extents (AtkComponent *component, gint *x, gint *y, gint *width, gint *height, AtkCoordType coord_type); void atk_component_get_position (AtkComponent *component, gint *x, gint *y, AtkCoordType coord_type); void atk_component_get_size (AtkComponent *component, gint *width, gint *height); AtkLayer atk_component_get_layer (AtkComponent *component); gint atk_component_get_mdi_zorder (AtkComponent *component); gboolean atk_component_grab_focus (AtkComponent *component); void atk_component_remove_focus_handler (AtkComponent *component, guint handler_id); gboolean atk_component_set_extents (AtkComponent *component, gint x, gint y, gint width, gint height, AtkCoordType coord_type); gboolean atk_component_set_position (AtkComponent *component, gint x, gint y, AtkCoordType coord_type); gboolean atk_component_set_size (AtkComponent *component, gint width, gint height); alias _AtkDocument AtkDocument; alias void _AtkDocument; alias _AtkDocumentIface AtkDocumentIface; struct _AtkDocumentIface { GTypeInterface parent; gchar* ( *get_document_type) (AtkDocument *document); gpointer ( *get_document) (AtkDocument *document); AtkFunction pad1; AtkFunction pad2; AtkFunction pad3; AtkFunction pad4; AtkFunction pad5; AtkFunction pad6; AtkFunction pad7; AtkFunction pad8; } GType atk_document_get_type (); gchar* atk_document_get_document_type (AtkDocument *document); gpointer atk_document_get_document (AtkDocument *document); alias GSList AtkAttributeSet; alias _AtkAttribute AtkAttribute; struct _AtkAttribute { gchar* name; gchar* value; } enum AtkTextAttribute { ATK_TEXT_ATTR_INVALID = 0, ATK_TEXT_ATTR_LEFT_MARGIN, ATK_TEXT_ATTR_RIGHT_MARGIN, ATK_TEXT_ATTR_INDENT, ATK_TEXT_ATTR_INVISIBLE, ATK_TEXT_ATTR_EDITABLE, ATK_TEXT_ATTR_PIXELS_ABOVE_LINES, ATK_TEXT_ATTR_PIXELS_BELOW_LINES, ATK_TEXT_ATTR_PIXELS_INSIDE_WRAP, ATK_TEXT_ATTR_BG_FULL_HEIGHT, ATK_TEXT_ATTR_RISE, ATK_TEXT_ATTR_UNDERLINE, ATK_TEXT_ATTR_STRIKETHROUGH, ATK_TEXT_ATTR_SIZE, ATK_TEXT_ATTR_SCALE, ATK_TEXT_ATTR_WEIGHT, ATK_TEXT_ATTR_LANGUAGE, ATK_TEXT_ATTR_FAMILY_NAME, ATK_TEXT_ATTR_BG_COLOR, ATK_TEXT_ATTR_FG_COLOR, ATK_TEXT_ATTR_BG_STIPPLE, ATK_TEXT_ATTR_FG_STIPPLE, ATK_TEXT_ATTR_WRAP_MODE, ATK_TEXT_ATTR_DIRECTION, ATK_TEXT_ATTR_JUSTIFICATION, ATK_TEXT_ATTR_STRETCH, ATK_TEXT_ATTR_VARIANT, ATK_TEXT_ATTR_STYLE, ATK_TEXT_ATTR_LAST_DEFINED }; AtkTextAttribute atk_text_attribute_register ( gchar *name); alias _AtkText AtkText; alias void _AtkText; alias _AtkTextIface AtkTextIface; enum AtkTextBoundary { ATK_TEXT_BOUNDARY_CHAR, ATK_TEXT_BOUNDARY_WORD_START, ATK_TEXT_BOUNDARY_WORD_END, ATK_TEXT_BOUNDARY_SENTENCE_START, ATK_TEXT_BOUNDARY_SENTENCE_END, ATK_TEXT_BOUNDARY_LINE_START, ATK_TEXT_BOUNDARY_LINE_END }; alias _AtkTextRectangle AtkTextRectangle; struct _AtkTextRectangle { gint x; gint y; gint width; gint height; } alias _AtkTextRange AtkTextRange; struct _AtkTextRange { AtkTextRectangle bounds; gint start_offset; gint end_offset; gchar* content; } enum AtkTextClipType { ATK_TEXT_CLIP_NONE, ATK_TEXT_CLIP_MIN, ATK_TEXT_CLIP_MAX, ATK_TEXT_CLIP_BOTH }; struct _AtkTextIface { GTypeInterface parent; gchar* (* get_text) (AtkText *text, gint start_offset, gint end_offset); gchar* (* get_text_after_offset) (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gchar* (* get_text_at_offset) (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gunichar (* get_character_at_offset) (AtkText *text, gint offset); gchar* (* get_text_before_offset) (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gint (* get_caret_offset) (AtkText *text); AtkAttributeSet* (* get_run_attributes) (AtkText *text, gint offset, gint *start_offset, gint *end_offset); AtkAttributeSet* (* get_default_attributes) (AtkText *text); void (* get_character_extents) (AtkText *text, gint offset, gint *x, gint *y, gint *width, gint *height, AtkCoordType coords); gint (* get_character_count) (AtkText *text); gint (* get_offset_at_point) (AtkText *text, gint x, gint y, AtkCoordType coords); gint (* get_n_selections) (AtkText *text); gchar* (* get_selection) (AtkText *text, gint selection_num, gint *start_offset, gint *end_offset); gboolean (* add_selection) (AtkText *text, gint start_offset, gint end_offset); gboolean (* remove_selection) (AtkText *text, gint selection_num); gboolean (* set_selection) (AtkText *text, gint selection_num, gint start_offset, gint end_offset); gboolean (* set_caret_offset) (AtkText *text, gint offset); void (* text_changed) (AtkText *text, gint position, gint length); void (* text_caret_moved) (AtkText *text, gint location); void (* text_selection_changed) (AtkText *text); void (* text_attributes_changed) (AtkText *text); void (* get_range_extents) (AtkText *text, gint start_offset, gint end_offset, AtkCoordType coord_type, AtkTextRectangle *rect); AtkTextRange** (* get_bounded_ranges) (AtkText *text, AtkTextRectangle *rect, AtkCoordType coord_type, AtkTextClipType x_clip_type, AtkTextClipType y_clip_type); AtkFunction pad4; } GType atk_text_get_type (); gchar* atk_text_get_text (AtkText *text, gint start_offset, gint end_offset); gunichar atk_text_get_character_at_offset (AtkText *text, gint offset); gchar* atk_text_get_text_after_offset (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gchar* atk_text_get_text_at_offset (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gchar* atk_text_get_text_before_offset (AtkText *text, gint offset, AtkTextBoundary boundary_type, gint *start_offset, gint *end_offset); gint atk_text_get_caret_offset (AtkText *text); void atk_text_get_character_extents (AtkText *text, gint offset, gint *x, gint *y, gint *width, gint *height, AtkCoordType coords); AtkAttributeSet* atk_text_get_run_attributes (AtkText *text, gint offset, gint *start_offset, gint *end_offset); AtkAttributeSet* atk_text_get_default_attributes (AtkText *text); gint atk_text_get_character_count (AtkText *text); gint atk_text_get_offset_at_point (AtkText *text, gint x, gint y, AtkCoordType coords); gint atk_text_get_n_selections (AtkText *text); gchar* atk_text_get_selection (AtkText *text, gint selection_num, gint *start_offset, gint *end_offset); gboolean atk_text_add_selection (AtkText *text, gint start_offset, gint end_offset); gboolean atk_text_remove_selection (AtkText *text, gint selection_num); gboolean atk_text_set_selection (AtkText *text, gint selection_num, gint start_offset, gint end_offset); gboolean atk_text_set_caret_offset (AtkText *text, gint offset); void atk_text_get_range_extents (AtkText *text, gint start_offset, gint end_offset, AtkCoordType coord_type, AtkTextRectangle *rect); AtkTextRange** atk_text_get_bounded_ranges (AtkText *text, AtkTextRectangle *rect, AtkCoordType coord_type, AtkTextClipType x_clip_type, AtkTextClipType y_clip_type); void atk_text_free_ranges (AtkTextRange **ranges); void atk_attribute_set_free (AtkAttributeSet *attrib_set); gchar* atk_text_attribute_get_name (AtkTextAttribute attr); AtkTextAttribute atk_text_attribute_for_name ( gchar *name); gchar* atk_text_attribute_get_value (AtkTextAttribute attr, gint index_); alias _AtkEditableText AtkEditableText; alias void _AtkEditableText; alias _AtkEditableTextIface AtkEditableTextIface; struct _AtkEditableTextIface { GTypeInterface parent_interface; gboolean (* set_run_attributes) (AtkEditableText *text, AtkAttributeSet *attrib_set, gint start_offset, gint end_offset); void (* set_text_contents) (AtkEditableText *text, gchar *string); void (* insert_text) (AtkEditableText *text, gchar *string, gint length, gint *position); void (* copy_text) (AtkEditableText *text, gint start_pos, gint end_pos); void (* cut_text) (AtkEditableText *text, gint start_pos, gint end_pos); void (* delete_text) (AtkEditableText *text, gint start_pos, gint end_pos); void (* paste_text) (AtkEditableText *text, gint position); AtkFunction pad1; AtkFunction pad2; } GType atk_editable_text_get_type (); gboolean atk_editable_text_set_run_attributes (AtkEditableText *text, AtkAttributeSet *attrib_set, gint start_offset, gint end_offset); void atk_editable_text_set_text_contents (AtkEditableText *text, gchar *string); void atk_editable_text_insert_text (AtkEditableText *text, gchar *string, gint length, gint *position); void atk_editable_text_copy_text (AtkEditableText *text, gint start_pos, gint end_pos); void atk_editable_text_cut_text (AtkEditableText *text, gint start_pos, gint end_pos); void atk_editable_text_delete_text (AtkEditableText *text, gint start_pos, gint end_pos); void atk_editable_text_paste_text (AtkEditableText *text, gint position); alias _AtkGObjectAccessible AtkGObjectAccessible; alias _AtkGObjectAccessibleClass AtkGObjectAccessibleClass; struct _AtkGObjectAccessible { AtkObject parent; } GType atk_gobject_accessible_get_type (); struct _AtkGObjectAccessibleClass { AtkObjectClass parent_class; AtkFunction pad1; AtkFunction pad2; } AtkObject *atk_gobject_accessible_for_object (GObject *obj); GObject *atk_gobject_accessible_get_object (AtkGObjectAccessible *obj); enum AtkHyperlinkStateFlags { ATK_HYPERLINK_IS_INLINE = 1 << 0 }; alias _AtkHyperlink AtkHyperlink; alias _AtkHyperlinkClass AtkHyperlinkClass; struct _AtkHyperlink { GObject parent; } struct _AtkHyperlinkClass { GObjectClass parent; gchar* (* get_uri) (AtkHyperlink *link_, gint i); AtkObject* (* get_object) (AtkHyperlink *link_, gint i); gint (* get_end_index) (AtkHyperlink *link_); gint (* get_start_index) (AtkHyperlink *link_); gboolean (* is_valid) (AtkHyperlink *link_); gint (* get_n_anchors) (AtkHyperlink *link_); guint (* link_state) (AtkHyperlink *link_); gboolean (* is_selected_link) (AtkHyperlink *link_); void ( *link_activated) (AtkHyperlink *link_); AtkFunction pad1; } GType atk_hyperlink_get_type (); gchar* atk_hyperlink_get_uri (AtkHyperlink *link_, gint i); AtkObject* atk_hyperlink_get_object (AtkHyperlink *link_, gint i); gint atk_hyperlink_get_end_index (AtkHyperlink *link_); gint atk_hyperlink_get_start_index (AtkHyperlink *link_); gboolean atk_hyperlink_is_valid (AtkHyperlink *link_); gboolean atk_hyperlink_is_inline (AtkHyperlink *link_); gint atk_hyperlink_get_n_anchors (AtkHyperlink *link_); gboolean atk_hyperlink_is_selected_link (AtkHyperlink *link_); alias _AtkHypertext AtkHypertext; alias void _AtkHypertext; alias _AtkHypertextIface AtkHypertextIface; struct _AtkHypertextIface { GTypeInterface parent; AtkHyperlink*(* get_link) (AtkHypertext *hypertext, gint link_index); gint (* get_n_links) (AtkHypertext *hypertext); gint (* get_link_index) (AtkHypertext *hypertext, gint char_index); void (* link_selected) (AtkHypertext *hypertext, gint link_index); AtkFunction pad1; AtkFunction pad2; AtkFunction pad3; } GType atk_hypertext_get_type (); AtkHyperlink* atk_hypertext_get_link (AtkHypertext *hypertext, gint link_index); gint atk_hypertext_get_n_links (AtkHypertext *hypertext); gint atk_hypertext_get_link_index (AtkHypertext *hypertext, gint char_index); alias _AtkImage AtkImage; alias void _AtkImage; alias _AtkImageIface AtkImageIface; struct _AtkImageIface { GTypeInterface parent; void ( *get_image_position) (AtkImage *image, gint *x, gint *y, AtkCoordType coord_type); gchar* ( *get_image_description) (AtkImage *image); void ( *get_image_size) (AtkImage *image, gint *width, gint *height); gboolean ( *set_image_description) (AtkImage *image, gchar *description); AtkFunction pad1; AtkFunction pad2; } GType atk_image_get_type (); gchar* atk_image_get_image_description (AtkImage *image); void atk_image_get_image_size (AtkImage *image, gint *width, gint *height); gboolean atk_image_set_image_description (AtkImage *image, gchar *description); void atk_image_get_image_position (AtkImage *image, gint *x, gint *y, AtkCoordType coord_type); alias _AtkNoOpObject AtkNoOpObject; alias _AtkNoOpObjectClass AtkNoOpObjectClass; struct _AtkNoOpObject { AtkObject parent; } GType atk_no_op_object_get_type (); struct _AtkNoOpObjectClass { AtkObjectClass parent_class; } AtkObject *atk_no_op_object_new (GObject *obj); alias _AtkObjectFactory AtkObjectFactory; alias _AtkObjectFactoryClass AtkObjectFactoryClass; struct _AtkObjectFactory { GObject parent; } struct _AtkObjectFactoryClass { GObjectClass parent_class; AtkObject* (* create_accessible) (GObject *obj); void (* invalidate) (AtkObjectFactory *factory); GType (* get_accessible_type) (); AtkFunction pad1; AtkFunction pad2; } GType atk_object_factory_get_type(); AtkObject* atk_object_factory_create_accessible (AtkObjectFactory *factory, GObject *obj); void atk_object_factory_invalidate (AtkObjectFactory *factory); GType atk_object_factory_get_accessible_type (AtkObjectFactory *factory); alias _AtkNoOpObjectFactory AtkNoOpObjectFactory; alias _AtkNoOpObjectFactoryClass AtkNoOpObjectFactoryClass; struct _AtkNoOpObjectFactory { AtkObjectFactory parent; } struct _AtkNoOpObjectFactoryClass { AtkObjectFactoryClass parent_class; } GType atk_no_op_object_factory_get_type(); AtkObjectFactory *atk_no_op_object_factory_new(); struct _AtkRegistry { GObject parent; GHashTable *factory_type_registry; GHashTable *factory_singleton_cache; } struct _AtkRegistryClass { GObjectClass parent_class; } alias _AtkRegistry AtkRegistry; alias _AtkRegistryClass AtkRegistryClass; GType atk_registry_get_type (); void atk_registry_set_factory_type (AtkRegistry *registry, GType type, GType factory_type); GType atk_registry_get_factory_type (AtkRegistry *registry, GType type); AtkObjectFactory* atk_registry_get_factory (AtkRegistry *registry, GType type); AtkRegistry* atk_get_default_registry (); alias _AtkRelation AtkRelation; alias _AtkRelationClass AtkRelationClass; struct _AtkRelation { GObject parent; GPtrArray *target; AtkRelationType relationship; } struct _AtkRelationClass { GObjectClass parent; } GType atk_relation_get_type (); AtkRelationType atk_relation_type_register ( gchar *name); gchar* atk_relation_type_get_name (AtkRelationType type); AtkRelationType atk_relation_type_for_name ( gchar *name); AtkRelation* atk_relation_new (AtkObject **targets, gint n_targets, AtkRelationType relationship); AtkRelationType atk_relation_get_relation_type (AtkRelation *relation); GPtrArray* atk_relation_get_target (AtkRelation *relation); alias _AtkRelationSetClass AtkRelationSetClass; struct _AtkRelationSet { GObject parent; GPtrArray *relations; } struct _AtkRelationSetClass { GObjectClass parent; AtkFunction pad1; AtkFunction pad2; } GType atk_relation_set_get_type (); AtkRelationSet* atk_relation_set_new (); gboolean atk_relation_set_contains (AtkRelationSet *set, AtkRelationType relationship); void atk_relation_set_remove (AtkRelationSet *set, AtkRelation *relation); void atk_relation_set_add (AtkRelationSet *set, AtkRelation *relation); gint atk_relation_set_get_n_relations (AtkRelationSet *set); AtkRelation* atk_relation_set_get_relation (AtkRelationSet *set, gint i); AtkRelation* atk_relation_set_get_relation_by_type (AtkRelationSet *set, AtkRelationType relationship); alias _AtkSelection AtkSelection; alias void _AtkSelection; alias _AtkSelectionIface AtkSelectionIface; struct _AtkSelectionIface { GTypeInterface parent; gboolean (* add_selection) (AtkSelection *selection, gint i); gboolean (* clear_selection) (AtkSelection *selection); AtkObject* (* ref_selection) (AtkSelection *selection, gint i); gint (* get_selection_count) (AtkSelection *selection); gboolean (* is_child_selected) (AtkSelection *selection, gint i); gboolean (* remove_selection) (AtkSelection *selection, gint i); gboolean (* select_all_selection) (AtkSelection *selection); void (*selection_changed) (AtkSelection *selection); AtkFunction pad1; AtkFunction pad2; } GType atk_selection_get_type (); gboolean atk_selection_add_selection (AtkSelection *selection, gint i); gboolean atk_selection_clear_selection (AtkSelection *selection); AtkObject* atk_selection_ref_selection (AtkSelection *selection, gint i); gint atk_selection_get_selection_count (AtkSelection *selection); gboolean atk_selection_is_child_selected (AtkSelection *selection, gint i); gboolean atk_selection_remove_selection (AtkSelection *selection, gint i); gboolean atk_selection_select_all_selection (AtkSelection *selection); alias _AtkStateSetClass AtkStateSetClass; struct _AtkStateSet { GObject parent; } struct _AtkStateSetClass { GObjectClass parent; } GType atk_state_set_get_type (); AtkStateSet* atk_state_set_new (); gboolean atk_state_set_is_empty (AtkStateSet *set); gboolean atk_state_set_add_state (AtkStateSet *set, AtkStateType type); void atk_state_set_add_states (AtkStateSet *set, AtkStateType *types, gint n_types); void atk_state_set_clear_states (AtkStateSet *set); gboolean atk_state_set_contains_state (AtkStateSet *set, AtkStateType type); gboolean atk_state_set_contains_states (AtkStateSet *set, AtkStateType *types, gint n_types); gboolean atk_state_set_remove_state (AtkStateSet *set, AtkStateType type); AtkStateSet* atk_state_set_and_sets (AtkStateSet *set, AtkStateSet *compare_set); AtkStateSet* atk_state_set_or_sets (AtkStateSet *set, AtkStateSet *compare_set); AtkStateSet* atk_state_set_xor_sets (AtkStateSet *set, AtkStateSet *compare_set); alias _AtkStreamableContent AtkStreamableContent; alias void _AtkStreamableContent; alias _AtkStreamableContentIface AtkStreamableContentIface; struct _AtkStreamableContentIface { GTypeInterface parent; gint (* get_n_mime_types) (AtkStreamableContent *streamable); gchar* (* get_mime_type) (AtkStreamableContent *streamable, gint i); GIOChannel* (* get_stream) (AtkStreamableContent *streamable, gchar *mime_type); AtkFunction pad1; AtkFunction pad2; AtkFunction pad3; AtkFunction pad4; } GType atk_streamable_content_get_type (); gint atk_streamable_content_get_n_mime_types (AtkStreamableContent *streamable); gchar* atk_streamable_content_get_mime_type (AtkStreamableContent *streamable, gint i); GIOChannel* atk_streamable_content_get_stream (AtkStreamableContent *streamable, gchar *mime_type); alias _AtkTable AtkTable; alias void _AtkTable; alias _AtkTableIface AtkTableIface; struct _AtkTableIface { GTypeInterface parent; AtkObject* (* ref_at) (AtkTable *table, gint row, gint column); gint (* get_index_at) (AtkTable *table, gint row, gint column); gint (* get_column_at_index) (AtkTable *table, gint index_); gint (* get_row_at_index) (AtkTable *table, gint index_); gint (* get_n_columns) (AtkTable *table); gint (* get_n_rows) (AtkTable *table); gint (* get_column_extent_at) (AtkTable *table, gint row, gint column); gint (* get_row_extent_at) (AtkTable *table, gint row, gint column); AtkObject* (* get_caption) (AtkTable *table); gchar* (* get_column_description) (AtkTable *table, gint column); AtkObject* (* get_column_header) (AtkTable *table, gint column); gchar* (* get_row_description) (AtkTable *table, gint row); AtkObject* (* get_row_header) (AtkTable *table, gint row); AtkObject* (* get_summary) (AtkTable *table); void (* set_caption) (AtkTable *table, AtkObject *caption); void (* set_column_description) (AtkTable *table, gint column, gchar *description); void (* set_column_header) (AtkTable *table, gint column, AtkObject *header); void (* set_row_description) (AtkTable *table, gint row, gchar *description); void (* set_row_header) (AtkTable *table, gint row, AtkObject *header); void (* set_summary) (AtkTable *table, AtkObject *accessible); gint (* get_selected_columns) (AtkTable *table, gint **selected); gint (* get_selected_rows) (AtkTable *table, gint **selected); gboolean (* is_column_selected) (AtkTable *table, gint column); gboolean (* is_row_selected) (AtkTable *table, gint row); gboolean (* is_selected) (AtkTable *table, gint row, gint column); gboolean (* add_row_selection) (AtkTable *table, gint row); gboolean (* remove_row_selection) (AtkTable *table, gint row); gboolean (* add_column_selection) (AtkTable *table, gint column); gboolean (* remove_column_selection) (AtkTable *table, gint column); void (* row_inserted) (AtkTable *table, gint row, gint num_inserted); void (* column_inserted) (AtkTable *table, gint column, gint num_inserted); void (* row_deleted) (AtkTable *table, gint row, gint num_deleted); void (* column_deleted) (AtkTable *table, gint column, gint num_deleted); void (* row_reordered) (AtkTable *table); void (* column_reordered) (AtkTable *table); void (* model_changed) (AtkTable *table); AtkFunction pad1; AtkFunction pad2; AtkFunction pad3; AtkFunction pad4; } GType atk_table_get_type (); AtkObject* atk_table_ref_at (AtkTable *table, gint row, gint column); gint atk_table_get_index_at (AtkTable *table, gint row, gint column); gint atk_table_get_column_at_index (AtkTable *table, gint index_); gint atk_table_get_row_at_index (AtkTable *table, gint index_); gint atk_table_get_n_columns (AtkTable *table); gint atk_table_get_n_rows (AtkTable *table); gint atk_table_get_column_extent_at (AtkTable *table, gint row, gint column); gint atk_table_get_row_extent_at (AtkTable *table, gint row, gint column); AtkObject* atk_table_get_caption (AtkTable *table); gchar* atk_table_get_column_description (AtkTable *table, gint column); AtkObject* atk_table_get_column_header (AtkTable *table, gint column); gchar* atk_table_get_row_description (AtkTable *table, gint row); AtkObject* atk_table_get_row_header (AtkTable *table, gint row); AtkObject* atk_table_get_summary (AtkTable *table); void atk_table_set_caption (AtkTable *table, AtkObject *caption); void atk_table_set_column_description (AtkTable *table, gint column, gchar *description); void atk_table_set_column_header (AtkTable *table, gint column, AtkObject *header); void atk_table_set_row_description (AtkTable *table, gint row, gchar *description); void atk_table_set_row_header (AtkTable *table, gint row, AtkObject *header); void atk_table_set_summary (AtkTable *table, AtkObject *accessible); gint atk_table_get_selected_columns (AtkTable *table, gint **selected); gint atk_table_get_selected_rows (AtkTable *table, gint **selected); gboolean atk_table_is_column_selected (AtkTable *table, gint column); gboolean atk_table_is_row_selected (AtkTable *table, gint row); gboolean atk_table_is_selected (AtkTable *table, gint row, gint column); gboolean atk_table_add_row_selection (AtkTable *table, gint row); gboolean atk_table_remove_row_selection (AtkTable *table, gint row); gboolean atk_table_add_column_selection (AtkTable *table, gint column); gboolean atk_table_remove_column_selection (AtkTable *table, gint column); alias _AtkValue AtkValue; alias void _AtkValue; alias _AtkValueIface AtkValueIface; struct _AtkValueIface { GTypeInterface parent; void (* get_current_value) (AtkValue *obj, GValue *value); void (* get_maximum_value) (AtkValue *obj, GValue *value); void (* get_minimum_value) (AtkValue *obj, GValue *value); gboolean (* set_current_value) (AtkValue *obj, GValue *value); AtkFunction pad1; AtkFunction pad2; } GType atk_value_get_type (); void atk_value_get_current_value (AtkValue *obj, GValue *value); void atk_value_get_maximum_value (AtkValue *obj, GValue *value); void atk_value_get_minimum_value (AtkValue *obj, GValue *value); gboolean atk_value_set_current_value (AtkValue *obj, GValue *value); alias _GtkAccessible GtkAccessible; alias _GtkAccessibleClass GtkAccessibleClass; struct _GtkAccessible { AtkObject parent; GtkWidget *widget; } struct _GtkAccessibleClass { AtkObjectClass parent_class; void (*connect_widget_destroyed) (GtkAccessible *accessible); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_accessible_get_type (); void gtk_accessible_connect_widget_destroyed (GtkAccessible *accessible); alias _GtkAction GtkAction; alias _GtkActionClass GtkActionClass; alias _GtkActionPrivate GtkActionPrivate; alias void _GtkActionPrivate; struct _GtkAction { GObject object; GtkActionPrivate *private_data; } struct _GtkActionClass { GObjectClass parent_class; void (* activate) (GtkAction *action); GType menu_item_type; GType toolbar_item_type; GtkWidget *(* create_menu_item) (GtkAction *action); GtkWidget *(* create_tool_item) (GtkAction *action); void (* connect_proxy) (GtkAction *action, GtkWidget *proxy); void (* disconnect_proxy) (GtkAction *action, GtkWidget *proxy); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_action_get_type (); GtkAction *gtk_action_new ( gchar *name, gchar *label, gchar *tooltip, gchar *stock_id); gchar* gtk_action_get_name (GtkAction *action); gboolean gtk_action_is_sensitive (GtkAction *action); gboolean gtk_action_get_sensitive (GtkAction *action); gboolean gtk_action_is_visible (GtkAction *action); gboolean gtk_action_get_visible (GtkAction *action); void gtk_action_activate (GtkAction *action); GtkWidget* gtk_action_create_icon (GtkAction *action, GtkIconSize icon_size); GtkWidget* gtk_action_create_menu_item (GtkAction *action); GtkWidget* gtk_action_create_tool_item (GtkAction *action); void gtk_action_connect_proxy (GtkAction *action, GtkWidget *proxy); void gtk_action_disconnect_proxy (GtkAction *action, GtkWidget *proxy); GSList* gtk_action_get_proxies (GtkAction *action); void gtk_action_connect_accelerator (GtkAction *action); void gtk_action_disconnect_accelerator (GtkAction *action); void gtk_action_block_activate_from (GtkAction *action, GtkWidget *proxy); void gtk_action_unblock_activate_from (GtkAction *action, GtkWidget *proxy); void _gtk_action_emit_activate (GtkAction *action); void gtk_action_set_accel_path (GtkAction *action, gchar *accel_path); void gtk_action_set_accel_group (GtkAction *action, GtkAccelGroup *accel_group); alias gchar * (*GtkTranslateFunc) ( gchar *path, gpointer func_data); alias void (*GtkPrintFunc) (gpointer func_data, gchar *str); alias void (*GtkItemFactoryCallback) (); alias void (*GtkItemFactoryCallback1) (gpointer callback_data, guint callback_action, GtkWidget *widget); alias _GtkItemFactory GtkItemFactory; alias _GtkItemFactoryClass GtkItemFactoryClass; alias _GtkItemFactoryEntry GtkItemFactoryEntry; alias _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; GHashTable *item_ht; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkItemFactoryEntry { gchar *path; gchar *accelerator; GtkItemFactoryCallback callback; guint callback_action; gchar *item_type; gpointer extra_data; } struct _GtkItemFactoryItem { gchar *path; GSList *widgets; } GType gtk_item_factory_get_type () ; GtkItemFactory* gtk_item_factory_new (GType container_type, gchar *path, GtkAccelGroup *accel_group); void gtk_item_factory_ruct (GtkItemFactory *ifactory, GType container_type, gchar *path, GtkAccelGroup *accel_group); void gtk_item_factory_add_foreign (GtkWidget *accel_widget, 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, gchar *path); GtkWidget* gtk_item_factory_get_widget (GtkItemFactory *ifactory, 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_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, 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); alias void (*GtkMenuCallback) (GtkWidget *widget, gpointer user_data); struct GtkMenuEntry { gchar *path; gchar *accelerator; GtkMenuCallback callback; gpointer callback_data; GtkWidget *widget; }; alias 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); GtkItemFactory* gtk_item_factory_from_path ( gchar *path); void gtk_item_factory_create_menu_entries (guint n_entries, GtkMenuEntry *entries); void gtk_item_factories_path_delete ( gchar *ifactory_path, gchar *path); alias _GtkActionGroup GtkActionGroup; alias _GtkActionGroupPrivate GtkActionGroupPrivate; alias void _GtkActionGroupPrivate; alias _GtkActionGroupClass GtkActionGroupClass; alias _GtkActionEntry GtkActionEntry; alias _GtkToggleActionEntry GtkToggleActionEntry; alias _GtkRadioActionEntry GtkRadioActionEntry; struct _GtkActionGroup { GObject parent; GtkActionGroupPrivate *private_data; } struct _GtkActionGroupClass { GObjectClass parent_class; GtkAction *(* get_action) (GtkActionGroup *action_group, gchar *action_name); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkActionEntry { gchar *name; gchar *stock_id; gchar *label; gchar *accelerator; gchar *tooltip; GCallback callback; } struct _GtkToggleActionEntry { gchar *name; gchar *stock_id; gchar *label; gchar *accelerator; gchar *tooltip; GCallback callback; gboolean is_active; } struct _GtkRadioActionEntry { gchar *name; gchar *stock_id; gchar *label; gchar *accelerator; gchar *tooltip; gint value; } GType gtk_action_group_get_type (); GtkActionGroup *gtk_action_group_new ( gchar *name); gchar *gtk_action_group_get_name (GtkActionGroup *action_group); gboolean gtk_action_group_get_sensitive (GtkActionGroup *action_group); void gtk_action_group_set_sensitive (GtkActionGroup *action_group, gboolean sensitive); gboolean gtk_action_group_get_visible (GtkActionGroup *action_group); void gtk_action_group_set_visible (GtkActionGroup *action_group, gboolean visible); GtkAction *gtk_action_group_get_action (GtkActionGroup *action_group, gchar *action_name); GList *gtk_action_group_list_actions (GtkActionGroup *action_group); void gtk_action_group_add_action (GtkActionGroup *action_group, GtkAction *action); void gtk_action_group_add_action_with_accel (GtkActionGroup *action_group, GtkAction *action, gchar *accelerator); void gtk_action_group_remove_action (GtkActionGroup *action_group, GtkAction *action); void gtk_action_group_add_actions (GtkActionGroup *action_group, GtkActionEntry *entries, guint n_entries, gpointer user_data); void gtk_action_group_add_toggle_actions (GtkActionGroup *action_group, GtkToggleActionEntry *entries, guint n_entries, gpointer user_data); void gtk_action_group_add_radio_actions (GtkActionGroup *action_group, GtkRadioActionEntry *entries, guint n_entries, gint value, GCallback on_change, gpointer user_data); void gtk_action_group_add_actions_full (GtkActionGroup *action_group, GtkActionEntry *entries, guint n_entries, gpointer user_data, GDestroyNotify destroy); void gtk_action_group_add_toggle_actions_full (GtkActionGroup *action_group, GtkToggleActionEntry *entries, guint n_entries, gpointer user_data, GDestroyNotify destroy); void gtk_action_group_add_radio_actions_full (GtkActionGroup *action_group, GtkRadioActionEntry *entries, guint n_entries, gint value, GCallback on_change, gpointer user_data, GDestroyNotify destroy); void gtk_action_group_set_translate_func (GtkActionGroup *action_group, GtkTranslateFunc func, gpointer data, GtkDestroyNotify notify); void gtk_action_group_set_translation_domain (GtkActionGroup *action_group, gchar *domain); void _gtk_action_group_emit_connect_proxy (GtkActionGroup *action_group, GtkAction *action, GtkWidget *proxy); void _gtk_action_group_emit_disconnect_proxy (GtkActionGroup *action_group, GtkAction *action, GtkWidget *proxy); void _gtk_action_group_emit_pre_activate (GtkActionGroup *action_group, GtkAction *action); void _gtk_action_group_emit_post_activate (GtkActionGroup *action_group, GtkAction *action); alias _GtkAlignment GtkAlignment; alias _GtkAlignmentClass GtkAlignmentClass; alias _GtkAlignmentPrivate GtkAlignmentPrivate; alias void _GtkAlignmentPrivate; struct _GtkAlignment { GtkBin bin; gfloat xalign; gfloat yalign; gfloat xscale; gfloat yscale; } struct _GtkAlignmentClass { GtkBinClass parent_class; } GType gtk_alignment_get_type () ; 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); void gtk_alignment_set_padding (GtkAlignment *alignment, guint padding_top, guint padding_bottom, guint padding_left, guint padding_right); void gtk_alignment_get_padding (GtkAlignment *alignment, guint *padding_top, guint *padding_bottom, guint *padding_left, guint *padding_right); alias _GtkArrow GtkArrow; alias _GtkArrowClass GtkArrowClass; struct _GtkArrow { GtkMisc misc; gint16 arrow_type; gint16 shadow_type; } struct _GtkArrowClass { GtkMiscClass parent_class; } GType gtk_arrow_get_type () ; GtkWidget* gtk_arrow_new (GtkArrowType arrow_type, GtkShadowType shadow_type); void gtk_arrow_set (GtkArrow *arrow, GtkArrowType arrow_type, GtkShadowType shadow_type); alias _GtkFrame GtkFrame; alias _GtkFrameClass GtkFrameClass; struct _GtkFrame { GtkBin bin; GtkWidget *label_widget; gint16 shadow_type; gfloat label_xalign; gfloat label_yalign; GtkAllocation child_allocation; } struct _GtkFrameClass { GtkBinClass parent_class; void (*compute_child_allocation) (GtkFrame *frame, GtkAllocation *allocation); } GType gtk_frame_get_type () ; GtkWidget* gtk_frame_new ( gchar *label); void gtk_frame_set_label (GtkFrame *frame, gchar *label); gchar *gtk_frame_get_label (GtkFrame *frame); void gtk_frame_set_label_widget (GtkFrame *frame, GtkWidget *label_widget); GtkWidget *gtk_frame_get_label_widget (GtkFrame *frame); void gtk_frame_set_label_align (GtkFrame *frame, gfloat xalign, gfloat yalign); void gtk_frame_get_label_align (GtkFrame *frame, gfloat *xalign, gfloat *yalign); void gtk_frame_set_shadow_type (GtkFrame *frame, GtkShadowType type); GtkShadowType gtk_frame_get_shadow_type (GtkFrame *frame); alias _GtkAspectFrame GtkAspectFrame; alias _GtkAspectFrameClass GtkAspectFrameClass; struct _GtkAspectFrame { GtkFrame frame; gfloat xalign; gfloat yalign; gfloat ratio; gboolean obey_child; GtkAllocation center_allocation; } struct _GtkAspectFrameClass { GtkFrameClass parent_class; } GType gtk_aspect_frame_get_type () ; GtkWidget* gtk_aspect_frame_new ( 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); alias _GtkBox GtkBox; alias _GtkBoxClass GtkBoxClass; alias _GtkBoxChild GtkBoxChild; struct _GtkBox { GtkContainer container; GList *children; gint16 spacing; guint homogeneous; } struct _GtkBoxClass { GtkContainerClass parent_class; } struct _GtkBoxChild { GtkWidget *widget; guint16 padding; guint expand; guint fill; guint pack; guint is_secondary; } GType gtk_box_get_type () ; 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); gboolean gtk_box_get_homogeneous (GtkBox *box); void gtk_box_set_spacing (GtkBox *box, gint spacing); gint gtk_box_get_spacing (GtkBox *box); 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); alias _GtkButtonBox GtkButtonBox; alias _GtkButtonBoxClass GtkButtonBoxClass; struct _GtkButtonBox { GtkBox box; gint child_min_width; gint child_min_height; gint child_ipad_x; gint child_ipad_y; GtkButtonBoxStyle layout_style; } struct _GtkButtonBoxClass { GtkBoxClass parent_class; } GType gtk_button_box_get_type () ; GtkButtonBoxStyle gtk_button_box_get_layout (GtkButtonBox *widget); void gtk_button_box_set_layout (GtkButtonBox *widget, GtkButtonBoxStyle layout_style); gboolean gtk_button_box_get_child_secondary (GtkButtonBox *widget, GtkWidget *child); void gtk_button_box_set_child_secondary (GtkButtonBox *widget, GtkWidget *child, gboolean is_secondary); 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_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_child_requisition (GtkWidget *widget, int *nvis_children, int *nvis_secondaries, int *width, int *height); alias _GtkBindingSet GtkBindingSet; alias _GtkBindingEntry GtkBindingEntry; alias _GtkBindingSignal GtkBindingSignal; alias _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; guint parsed; } struct _GtkBindingEntry { guint keyval; GdkModifierType modifiers; GtkBindingSet *binding_set; guint destroyed; guint in_emission; GtkBindingEntry *set_next; GtkBindingEntry *hash_next; GtkBindingSignal *signals; } struct _GtkBindingSignal { GtkBindingSignal *next; gchar *signal_name; guint n_args; GtkBindingArg *args; } struct _GtkBindingArg { GType arg_type; union d_union { glong int_data; gdouble double_data; gchar *string_data; } d_union d; } GtkBindingSet* gtk_binding_set_new ( gchar *set_name); GtkBindingSet* gtk_binding_set_by_class(gpointer object_class); GtkBindingSet* gtk_binding_set_find ( gchar *set_name); gboolean gtk_bindings_activate (GtkObject *object, guint keyval, GdkModifierType modifiers); gboolean gtk_bindings_activate_event (GtkObject *object, GdkEventKey *event); gboolean gtk_binding_set_activate (GtkBindingSet *binding_set, guint keyval, GdkModifierType modifiers, GtkObject *object); void gtk_binding_entry_clear (GtkBindingSet *binding_set, guint keyval, GdkModifierType modifiers); void gtk_binding_entry_add_signal (GtkBindingSet *binding_set, guint keyval, GdkModifierType modifiers, gchar *signal_name, guint n_args, ...); void gtk_binding_set_add_path (GtkBindingSet *binding_set, GtkPathType path_type, gchar *path_pattern, GtkPathPriorityType priority); void gtk_binding_entry_remove (GtkBindingSet *binding_set, guint keyval, GdkModifierType modifiers); void gtk_binding_entry_add_signall (GtkBindingSet *binding_set, guint keyval, GdkModifierType modifiers, gchar *signal_name, GSList *binding_args); guint gtk_binding_parse_binding (GScanner *scanner); void _gtk_binding_reset_parsed (); guint _gtk_binding_signal_new ( gchar *signal_name, GType itype, GSignalFlags signal_flags, GCallback handler, GSignalAccumulator accumulator, gpointer accu_data, GSignalCMarshaller c_marshaller, GType return_type, guint n_params, ...); alias _GtkButton GtkButton; alias _GtkButtonClass GtkButtonClass; struct _GtkButton { GtkBin bin; GdkWindow *event_window; gchar *label_text; guint activate_timeout; guint in_button; guint button_down; guint relief; guint use_underline; guint use_stock; guint depressed; guint depress_on_activate; guint focus_on_click; } 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); void (* activate) (GtkButton *button); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_button_get_type () ; GtkWidget* gtk_button_new (); GtkWidget* gtk_button_new_with_label ( gchar *label); GtkWidget* gtk_button_new_from_stock ( gchar *stock_id); GtkWidget* gtk_button_new_with_mnemonic ( 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); void gtk_button_set_label (GtkButton *button, gchar *label); gchar *gtk_button_get_label (GtkButton *button); void gtk_button_set_use_underline (GtkButton *button, gboolean use_underline); gboolean gtk_button_get_use_underline (GtkButton *button); void gtk_button_set_use_stock (GtkButton *button, gboolean use_stock); gboolean gtk_button_get_use_stock (GtkButton *button); void gtk_button_set_focus_on_click (GtkButton *button, gboolean focus_on_click); gboolean gtk_button_get_focus_on_click (GtkButton *button); void gtk_button_set_alignment (GtkButton *button, gfloat xalign, gfloat yalign); void gtk_button_get_alignment (GtkButton *button, gfloat *xalign, gfloat *yalign); void _gtk_button_set_depressed (GtkButton *button, gboolean depressed); void _gtk_button_paint (GtkButton *button, GdkRectangle *area, GtkStateType state_type, GtkShadowType shadow_type, gchar *main_detail, gchar *default_detail); void gtk_marshal_BOOLEAN__VOID (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_BOOLEAN__POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_BOOLEAN__POINTER_INT_INT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_ENUM__ENUM (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_INT__POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_INT__POINTER_CHAR_CHAR (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__ENUM_FLOAT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__INT_INT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__INT_INT_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_INT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_STRING_STRING (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_UINT_ENUM (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_POINTER_UINT_UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__POINTER_UINT_UINT (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__STRING_INT_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); void gtk_marshal_VOID__UINT_STRING (GClosure *closure, GValue *return_value, guint n_param_values, GValue *param_values, gpointer invocation_hint, gpointer marshal_data); guint gtk_signal_newv ( gchar *name, GtkSignalRunType signal_flags, GtkType object_type, guint function_offset, GtkSignalMarshaller marshaller, GtkType return_val, guint n_args, GtkType *args); guint gtk_signal_new ( gchar *name, GtkSignalRunType signal_flags, GtkType object_type, guint function_offset, GtkSignalMarshaller marshaller, GtkType return_val, guint n_args, ...); void gtk_signal_emit_stop_by_name (GtkObject *object, gchar *name); void gtk_signal_connect_object_while_alive (GtkObject *object, gchar *name, GtkSignalFunc func, GtkObject *alive_object); void gtk_signal_connect_while_alive (GtkObject *object, gchar *name, GtkSignalFunc func, gpointer func_data, GtkObject *alive_object); gulong gtk_signal_connect_full (GtkObject *object, gchar *name, GtkSignalFunc func, GtkCallbackMarshal unsupported, gpointer data, GtkDestroyNotify destroy_func, gint object_signal, gint after); void gtk_signal_emitv (GtkObject *object, guint signal_id, GtkArg *args); void gtk_signal_emit (GtkObject *object, guint signal_id, ...); void gtk_signal_emit_by_name (GtkObject *object, gchar *name, ...); void gtk_signal_emitv_by_name (GtkObject *object, gchar *name, GtkArg *args); void gtk_signal_compat_matched (GtkObject *object, GtkSignalFunc func, gpointer data, GSignalMatchType match, guint action); alias _GtkCalendar GtkCalendar; alias _GtkCalendarClass GtkCalendarClass; enum GtkCalendarDisplayOptions { 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 }; 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]; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } 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); } GType gtk_calendar_get_type () ; GtkWidget* gtk_calendar_new (); gboolean gtk_calendar_select_month (GtkCalendar *calendar, guint month, guint year); void gtk_calendar_select_day (GtkCalendar *calendar, guint day); gboolean gtk_calendar_mark_day (GtkCalendar *calendar, guint day); gboolean gtk_calendar_unmark_day (GtkCalendar *calendar, guint day); void gtk_calendar_clear_marks (GtkCalendar *calendar); void gtk_calendar_set_display_options (GtkCalendar *calendar, GtkCalendarDisplayOptions flags); GtkCalendarDisplayOptions gtk_calendar_get_display_options (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); alias _GtkCellEditable GtkCellEditable; alias void _GtkCellEditable; alias _GtkCellEditableIface GtkCellEditableIface; struct _GtkCellEditableIface { GTypeInterface g_iface; void (* editing_done) (GtkCellEditable *cell_editable); void (* remove_widget) (GtkCellEditable *cell_editable); void (* start_editing) (GtkCellEditable *cell_editable, GdkEvent *event); } GType gtk_cell_editable_get_type () ; void gtk_cell_editable_start_editing (GtkCellEditable *cell_editable, GdkEvent *event); void gtk_cell_editable_editing_done (GtkCellEditable *cell_editable); void gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable); enum GtkCellRendererState { GTK_CELL_RENDERER_SELECTED = 1 << 0, GTK_CELL_RENDERER_PRELIT = 1 << 1, GTK_CELL_RENDERER_INSENSITIVE = 1 << 2, GTK_CELL_RENDERER_SORTED = 1 << 3, GTK_CELL_RENDERER_FOCUSED = 1 << 4 }; enum GtkCellRendererMode { GTK_CELL_RENDERER_MODE_INERT, GTK_CELL_RENDERER_MODE_ACTIVATABLE, GTK_CELL_RENDERER_MODE_EDITABLE }; alias _GtkCellRenderer GtkCellRenderer; alias _GtkCellRendererClass GtkCellRendererClass; struct _GtkCellRenderer { GtkObject parent; gfloat xalign; gfloat yalign; gint width; gint height; guint16 xpad; guint16 ypad; guint mode; guint visible; guint is_expander; guint is_expanded; guint cell_background_set; } struct _GtkCellRendererClass { GtkObjectClass parent_class; void (* get_size) (GtkCellRenderer *cell, GtkWidget *widget, GdkRectangle *cell_area, gint *x_offset, gint *y_offset, gint *width, gint *height); void (* render) (GtkCellRenderer *cell, GdkDrawable *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags); gboolean (* activate) (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags); GtkCellEditable *(* start_editing) (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags); void (* editing_canceled) (GtkCellRenderer *cell); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_cell_renderer_get_type () ; void gtk_cell_renderer_get_size (GtkCellRenderer *cell, GtkWidget *widget, GdkRectangle *cell_area, gint *x_offset, gint *y_offset, gint *width, gint *height); void gtk_cell_renderer_render (GtkCellRenderer *cell, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags); gboolean gtk_cell_renderer_activate (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags); GtkCellEditable *gtk_cell_renderer_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags); void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell, gint width, gint height); void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell, gint *width, gint *height); void gtk_cell_renderer_editing_canceled (GtkCellRenderer *cell); alias _GtkTreeIter GtkTreeIter; alias _GtkTreePath GtkTreePath; alias void _GtkTreePath; alias _GtkTreeRowReference GtkTreeRowReference; alias void _GtkTreeRowReference; alias _GtkTreeModel GtkTreeModel; alias void _GtkTreeModel; alias _GtkTreeModelIface GtkTreeModelIface; alias gboolean (* GtkTreeModelForeachFunc) (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); enum GtkTreeModelFlags { GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0, GTK_TREE_MODEL_LIST_ONLY = 1 << 1 }; struct _GtkTreeIter { gint stamp; gpointer user_data; gpointer user_data2; gpointer user_data3; } struct _GtkTreeModelIface { GTypeInterface g_iface; void (* row_changed) (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void (* row_inserted) (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void (* row_has_child_toggled) (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void (* row_deleted) (GtkTreeModel *tree_model, GtkTreePath *path); void (* rows_reordered) (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter, gint *new_order); GtkTreeModelFlags (* get_flags) (GtkTreeModel *tree_model); gint (* get_n_columns) (GtkTreeModel *tree_model); GType (* get_column_type) (GtkTreeModel *tree_model, gint index_); gboolean (* get_iter) (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path); GtkTreePath *(* get_path) (GtkTreeModel *tree_model, GtkTreeIter *iter); void (* get_value) (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value); gboolean (* iter_next) (GtkTreeModel *tree_model, GtkTreeIter *iter); gboolean (* iter_children) (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent); gboolean (* iter_has_child) (GtkTreeModel *tree_model, GtkTreeIter *iter); gint (* iter_n_children) (GtkTreeModel *tree_model, GtkTreeIter *iter); gboolean (* iter_nth_child) (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n); gboolean (* iter_parent) (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child); void (* ref_node) (GtkTreeModel *tree_model, GtkTreeIter *iter); void (* unref_node) (GtkTreeModel *tree_model, GtkTreeIter *iter); } GtkTreePath *gtk_tree_path_new (); GtkTreePath *gtk_tree_path_new_from_string ( gchar *path); GtkTreePath *gtk_tree_path_new_from_indices (gint first_index, ...); gchar *gtk_tree_path_to_string (GtkTreePath *path); GtkTreePath *gtk_tree_path_new_first (); void gtk_tree_path_append_index (GtkTreePath *path, gint index_); void gtk_tree_path_prepend_index (GtkTreePath *path, gint index_); gint gtk_tree_path_get_depth (GtkTreePath *path); gint *gtk_tree_path_get_indices (GtkTreePath *path); void gtk_tree_path_free (GtkTreePath *path); GtkTreePath *gtk_tree_path_copy ( GtkTreePath *path); GType gtk_tree_path_get_type (); gint gtk_tree_path_compare ( GtkTreePath *a, GtkTreePath *b); void gtk_tree_path_next (GtkTreePath *path); gboolean gtk_tree_path_prev (GtkTreePath *path); gboolean gtk_tree_path_up (GtkTreePath *path); void gtk_tree_path_down (GtkTreePath *path); gboolean gtk_tree_path_is_ancestor (GtkTreePath *path, GtkTreePath *descendant); gboolean gtk_tree_path_is_descendant (GtkTreePath *path, GtkTreePath *ancestor); GType gtk_tree_row_reference_get_type (); GtkTreeRowReference *gtk_tree_row_reference_new (GtkTreeModel *model, GtkTreePath *path); GtkTreeRowReference *gtk_tree_row_reference_new_proxy (GObject *proxy, GtkTreeModel *model, GtkTreePath *path); GtkTreePath *gtk_tree_row_reference_get_path (GtkTreeRowReference *reference); gboolean gtk_tree_row_reference_valid (GtkTreeRowReference *reference); GtkTreeRowReference *gtk_tree_row_reference_copy (GtkTreeRowReference *reference); void gtk_tree_row_reference_free (GtkTreeRowReference *reference); void gtk_tree_row_reference_inserted (GObject *proxy, GtkTreePath *path); void gtk_tree_row_reference_deleted (GObject *proxy, GtkTreePath *path); void gtk_tree_row_reference_reordered (GObject *proxy, GtkTreePath *path, GtkTreeIter *iter, gint *new_order); GtkTreeIter * gtk_tree_iter_copy (GtkTreeIter *iter); void gtk_tree_iter_free (GtkTreeIter *iter); GType gtk_tree_iter_get_type (); GType gtk_tree_model_get_type () ; GtkTreeModelFlags gtk_tree_model_get_flags (GtkTreeModel *tree_model); gint gtk_tree_model_get_n_columns (GtkTreeModel *tree_model); GType gtk_tree_model_get_column_type (GtkTreeModel *tree_model, gint index_); gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path); gboolean gtk_tree_model_get_iter_from_string (GtkTreeModel *tree_model, GtkTreeIter *iter, gchar *path_string); gchar * gtk_tree_model_get_string_from_iter (GtkTreeModel *tree_model, GtkTreeIter *iter); gboolean gtk_tree_model_get_iter_first (GtkTreeModel *tree_model, GtkTreeIter *iter); GtkTreePath * gtk_tree_model_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter); void gtk_tree_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value); gboolean gtk_tree_model_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter); gboolean gtk_tree_model_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent); gboolean gtk_tree_model_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter); gint gtk_tree_model_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter); gboolean gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n); gboolean gtk_tree_model_iter_parent (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child); void gtk_tree_model_ref_node (GtkTreeModel *tree_model, GtkTreeIter *iter); void gtk_tree_model_unref_node (GtkTreeModel *tree_model, GtkTreeIter *iter); void gtk_tree_model_get (GtkTreeModel *tree_model, GtkTreeIter *iter, ...); void gtk_tree_model_get_valist (GtkTreeModel *tree_model, GtkTreeIter *iter, va_list var_args); void gtk_tree_model_foreach (GtkTreeModel *model, GtkTreeModelForeachFunc func, gpointer user_data); void gtk_tree_model_row_changed (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void gtk_tree_model_row_inserted (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void gtk_tree_model_row_has_child_toggled (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter); void gtk_tree_model_row_deleted (GtkTreeModel *tree_model, GtkTreePath *path); void gtk_tree_model_rows_reordered (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter, gint *new_order); enum { GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID = -1 }; alias _GtkTreeSortable GtkTreeSortable; alias void _GtkTreeSortable; alias _GtkTreeSortableIface GtkTreeSortableIface; alias gint (* GtkTreeIterCompareFunc) (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data); struct _GtkTreeSortableIface { GTypeInterface g_iface; void (* sort_column_changed) (GtkTreeSortable *sortable); gboolean (* get_sort_column_id) (GtkTreeSortable *sortable, gint *sort_column_id, GtkSortType *order); void (* set_sort_column_id) (GtkTreeSortable *sortable, gint sort_column_id, GtkSortType order); void (* set_sort_func) (GtkTreeSortable *sortable, gint sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy); void (* set_default_sort_func) (GtkTreeSortable *sortable, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy); gboolean (* has_default_sort_func) (GtkTreeSortable *sortable); } GType gtk_tree_sortable_get_type () ; void gtk_tree_sortable_sort_column_changed (GtkTreeSortable *sortable); gboolean gtk_tree_sortable_get_sort_column_id (GtkTreeSortable *sortable, gint *sort_column_id, GtkSortType *order); void gtk_tree_sortable_set_sort_column_id (GtkTreeSortable *sortable, gint sort_column_id, GtkSortType order); void gtk_tree_sortable_set_sort_func (GtkTreeSortable *sortable, gint sort_column_id, GtkTreeIterCompareFunc sort_func, gpointer user_data, GtkDestroyNotify destroy); void gtk_tree_sortable_set_default_sort_func (GtkTreeSortable *sortable, GtkTreeIterCompareFunc sort_func, gpointer user_data, GtkDestroyNotify destroy); gboolean gtk_tree_sortable_has_default_sort_func (GtkTreeSortable *sortable); enum GtkTreeViewColumnSizing { GTK_TREE_VIEW_COLUMN_GROW_ONLY, GTK_TREE_VIEW_COLUMN_AUTOSIZE, GTK_TREE_VIEW_COLUMN_FIXED }; alias _GtkTreeViewColumn GtkTreeViewColumn; alias _GtkTreeViewColumnClass GtkTreeViewColumnClass; alias void (* GtkTreeCellDataFunc) (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data); struct _GtkTreeViewColumn { GtkObject parent; GtkWidget *tree_view; GtkWidget *button; GtkWidget *child; GtkWidget *arrow; GtkWidget *alignment; GdkWindow *window; GtkCellEditable *editable_widget; gfloat xalign; guint property_changed_signal; gint spacing; GtkTreeViewColumnSizing column_type; gint requested_width; gint button_request; gint resized_width; gint width; gint fixed_width; gint min_width; gint max_width; gint drag_x; gint drag_y; gchar *title; GList *cell_list; guint sort_clicked_signal; guint sort_column_changed_signal; gint sort_column_id; GtkSortType sort_order; guint visible; guint resizable; guint clickable; guint dirty; guint show_sort_indicator; guint maybe_reordered; guint reorderable; guint use_resized_width; guint expand; } struct _GtkTreeViewColumnClass { GtkObjectClass parent_class; void (*clicked) (GtkTreeViewColumn *tree_column); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tree_view_column_get_type (); GtkTreeViewColumn *gtk_tree_view_column_new (); GtkTreeViewColumn *gtk_tree_view_column_new_with_attributes ( gchar *title, GtkCellRenderer *cell, ...); void gtk_tree_view_column_pack_start (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, gboolean expand); void gtk_tree_view_column_pack_end (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, gboolean expand); void gtk_tree_view_column_clear (GtkTreeViewColumn *tree_column); GList *gtk_tree_view_column_get_cell_renderers (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer, gchar *attribute, gint column); void gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer, ...); void gtk_tree_view_column_set_cell_data_func (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer, GtkTreeCellDataFunc func, gpointer func_data, GtkDestroyNotify destroy); void gtk_tree_view_column_clear_attributes (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer); void gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column, gint spacing); gint gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column, gboolean visible); gboolean gtk_tree_view_column_get_visible (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_resizable (GtkTreeViewColumn *tree_column, gboolean resizable); gboolean gtk_tree_view_column_get_resizable (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_sizing (GtkTreeViewColumn *tree_column, GtkTreeViewColumnSizing type); GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column); gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column); gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column, gint fixed_width); void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column, gint min_width); gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column, gint max_width); gint gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_title (GtkTreeViewColumn *tree_column, gchar *title); gchar *gtk_tree_view_column_get_title (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_expand (GtkTreeViewColumn *tree_column, gboolean expand); gboolean gtk_tree_view_column_get_expand (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_clickable (GtkTreeViewColumn *tree_column, gboolean clickable); gboolean gtk_tree_view_column_get_clickable (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_widget (GtkTreeViewColumn *tree_column, GtkWidget *widget); GtkWidget *gtk_tree_view_column_get_widget (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_alignment (GtkTreeViewColumn *tree_column, gfloat xalign); gfloat gtk_tree_view_column_get_alignment (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_reorderable (GtkTreeViewColumn *tree_column, gboolean reorderable); gboolean gtk_tree_view_column_get_reorderable (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column, gint sort_column_id); gint gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn *tree_column, gboolean setting); gboolean gtk_tree_view_column_get_sort_indicator (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_set_sort_order (GtkTreeViewColumn *tree_column, GtkSortType order); GtkSortType gtk_tree_view_column_get_sort_order (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_cell_set_cell_data (GtkTreeViewColumn *tree_column, GtkTreeModel *tree_model, GtkTreeIter *iter, gboolean is_expander, gboolean is_expanded); void gtk_tree_view_column_cell_get_size (GtkTreeViewColumn *tree_column, GdkRectangle *cell_area, gint *x_offset, gint *y_offset, gint *width, gint *height); gboolean gtk_tree_view_column_cell_is_visible (GtkTreeViewColumn *tree_column); void gtk_tree_view_column_focus_cell (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell); gboolean gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer, gint *start_pos, gint *width); alias _GtkCellLayout GtkCellLayout; alias void _GtkCellLayout; alias _GtkCellLayoutIface GtkCellLayoutIface; alias void (* GtkCellLayoutDataFunc) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data); struct _GtkCellLayoutIface { GTypeInterface g_iface; void (* pack_start) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gboolean expand); void (* pack_end) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gboolean expand); void (* clear) (GtkCellLayout *cell_layout); void (* add_attribute) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gchar *attribute, gint column); void (* set_cell_data_func) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy); void (* clear_attributes) (GtkCellLayout *cell_layout, GtkCellRenderer *cell); void (* reorder) (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gint position); } GType gtk_cell_layout_get_type (); void gtk_cell_layout_pack_start (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gboolean expand); void gtk_cell_layout_pack_end (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gboolean expand); void gtk_cell_layout_clear (GtkCellLayout *cell_layout); void gtk_cell_layout_set_attributes (GtkCellLayout *cell_layout, GtkCellRenderer *cell, ...); void gtk_cell_layout_add_attribute (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gchar *attribute, gint column); void gtk_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy); void gtk_cell_layout_clear_attributes (GtkCellLayout *cell_layout, GtkCellRenderer *cell); void gtk_cell_layout_reorder (GtkCellLayout *cell_layout, GtkCellRenderer *cell, gint position); alias _GtkCellRendererPixbuf GtkCellRendererPixbuf; alias _GtkCellRendererPixbufClass GtkCellRendererPixbufClass; struct _GtkCellRendererPixbuf { GtkCellRenderer parent; GdkPixbuf *pixbuf; GdkPixbuf *pixbuf_expander_open; GdkPixbuf *pixbuf_expander_closed; } struct _GtkCellRendererPixbufClass { GtkCellRendererClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_cell_renderer_pixbuf_get_type (); GtkCellRenderer *gtk_cell_renderer_pixbuf_new (); alias _GtkCellRendererText GtkCellRendererText; alias _GtkCellRendererTextClass GtkCellRendererTextClass; struct _GtkCellRendererText { GtkCellRenderer parent; gchar *text; PangoFontDescription *font; gdouble font_scale; PangoColor foreground; PangoColor background; PangoAttrList *extra_attrs; PangoUnderline underline_style; gint rise; gint fixed_height_rows; guint strikethrough; guint editable; guint scale_set; guint foreground_set; guint background_set; guint underline_set; guint rise_set; guint strikethrough_set; guint editable_set; guint calc_fixed_height; } struct _GtkCellRendererTextClass { GtkCellRendererClass parent_class; void (* edited) (GtkCellRendererText *cell_renderer_text, gchar *path, gchar *new_text); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_cell_renderer_text_get_type (); GtkCellRenderer *gtk_cell_renderer_text_new (); void gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer, gint number_of_rows); alias _GtkCellRendererToggle GtkCellRendererToggle; alias _GtkCellRendererToggleClass GtkCellRendererToggleClass; struct _GtkCellRendererToggle { GtkCellRenderer parent; guint active; guint activatable; guint radio; } struct _GtkCellRendererToggleClass { GtkCellRendererClass parent_class; void (* toggled) (GtkCellRendererToggle *cell_renderer_toggle, gchar *path); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_cell_renderer_toggle_get_type (); GtkCellRenderer *gtk_cell_renderer_toggle_new (); gboolean gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle); void gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle, gboolean radio); gboolean gtk_cell_renderer_toggle_get_active (GtkCellRendererToggle *toggle); void gtk_cell_renderer_toggle_set_active (GtkCellRendererToggle *toggle, gboolean setting); alias _GtkToggleButton GtkToggleButton; alias _GtkToggleButtonClass GtkToggleButtonClass; struct _GtkToggleButton { GtkButton button; guint active; guint draw_indicator; guint inconsistent; } struct _GtkToggleButtonClass { GtkButtonClass parent_class; void (* toggled) (GtkToggleButton *toggle_button); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_toggle_button_get_type () ; GtkWidget* gtk_toggle_button_new (); GtkWidget* gtk_toggle_button_new_with_label ( gchar *label); GtkWidget* gtk_toggle_button_new_with_mnemonic ( gchar *label); void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button, gboolean draw_indicator); gboolean gtk_toggle_button_get_mode (GtkToggleButton *toggle_button); 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); void gtk_toggle_button_set_inconsistent (GtkToggleButton *toggle_button, gboolean setting); gboolean gtk_toggle_button_get_inconsistent (GtkToggleButton *toggle_button); alias _GtkCheckButton GtkCheckButton; alias _GtkCheckButtonClass GtkCheckButtonClass; struct _GtkCheckButton { GtkToggleButton toggle_button; } struct _GtkCheckButtonClass { GtkToggleButtonClass parent_class; void (* draw_indicator) (GtkCheckButton *check_button, GdkRectangle *area); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_check_button_get_type () ; GtkWidget* gtk_check_button_new (); GtkWidget* gtk_check_button_new_with_label ( gchar *label); GtkWidget* gtk_check_button_new_with_mnemonic ( gchar *label); void _gtk_check_button_get_props (GtkCheckButton *check_button, gint *indicator_size, gint *indicator_spacing); alias _GtkItem GtkItem; alias _GtkItemClass GtkItemClass; struct _GtkItem { GtkBin bin; } struct _GtkItemClass { GtkBinClass parent_class; void (* select) (GtkItem *item); void (* deselect) (GtkItem *item); void (* toggle) (GtkItem *item); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_item_get_type () ; void gtk_item_select (GtkItem *item); void gtk_item_deselect (GtkItem *item); void gtk_item_toggle (GtkItem *item); alias _GtkMenuItem GtkMenuItem; alias _GtkMenuItemClass GtkMenuItemClass; struct _GtkMenuItem { GtkItem item; GtkWidget *submenu; GdkWindow *event_window; guint16 toggle_size; guint16 accelerator_width; gchar *accel_path; guint show_submenu_indicator; guint submenu_placement; guint submenu_direction; guint right_justify; guint timer_from_keypress; guint timer; } struct _GtkMenuItemClass { GtkItemClass parent_class; guint hide_on_activate; void (* activate) (GtkMenuItem *menu_item); void (* activate_item) (GtkMenuItem *menu_item); void (* toggle_size_request) (GtkMenuItem *menu_item, gint *requisition); void (* toggle_size_allocate) (GtkMenuItem *menu_item, gint allocation); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_menu_item_get_type () ; GtkWidget* gtk_menu_item_new (); GtkWidget* gtk_menu_item_new_with_label ( gchar *label); GtkWidget* gtk_menu_item_new_with_mnemonic ( gchar *label); void gtk_menu_item_set_submenu (GtkMenuItem *menu_item, GtkWidget *submenu); GtkWidget* gtk_menu_item_get_submenu (GtkMenuItem *menu_item); void gtk_menu_item_remove_submenu (GtkMenuItem *menu_item); 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_toggle_size_request (GtkMenuItem *menu_item, gint *requisition); void gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item, gint allocation); void gtk_menu_item_set_right_justified (GtkMenuItem *menu_item, gboolean right_justified); gboolean gtk_menu_item_get_right_justified (GtkMenuItem *menu_item); void gtk_menu_item_set_accel_path (GtkMenuItem *menu_item, gchar *accel_path); void _gtk_menu_item_refresh_accel_path (GtkMenuItem *menu_item, gchar *prefix, GtkAccelGroup *accel_group, gboolean group_changed); gboolean _gtk_menu_item_is_selectable (GtkWidget *menu_item); alias _GtkCheckMenuItem GtkCheckMenuItem; alias _GtkCheckMenuItemClass GtkCheckMenuItemClass; struct _GtkCheckMenuItem { GtkMenuItem menu_item; guint active; guint always_show_toggle; guint inconsistent; guint draw_as_radio; } struct _GtkCheckMenuItemClass { GtkMenuItemClass parent_class; void (* toggled) (GtkCheckMenuItem *check_menu_item); void (* draw_indicator) (GtkCheckMenuItem *check_menu_item, GdkRectangle *area); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_check_menu_item_get_type () ; GtkWidget* gtk_check_menu_item_new (); GtkWidget* gtk_check_menu_item_new_with_label ( gchar *label); GtkWidget* gtk_check_menu_item_new_with_mnemonic ( gchar *label); void gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item, gboolean is_active); gboolean gtk_check_menu_item_get_active (GtkCheckMenuItem *check_menu_item); void gtk_check_menu_item_toggled (GtkCheckMenuItem *check_menu_item); void gtk_check_menu_item_set_inconsistent (GtkCheckMenuItem *check_menu_item, gboolean setting); gboolean gtk_check_menu_item_get_inconsistent (GtkCheckMenuItem *check_menu_item); void gtk_check_menu_item_set_draw_as_radio (GtkCheckMenuItem *check_menu_item, gboolean draw_as_radio); gboolean gtk_check_menu_item_get_draw_as_radio (GtkCheckMenuItem *check_menu_item); void gtk_check_menu_item_set_show_toggle (GtkCheckMenuItem *menu_item, gboolean always); alias _GtkTargetList GtkTargetList; alias _GtkTargetEntry GtkTargetEntry; struct _GtkSelectionData { GdkAtom selection; GdkAtom target; GdkAtom type; gint format; guchar *data; gint length; GdkDisplay *display; } struct _GtkTargetEntry { gchar *target; guint flags; guint info; } alias _GtkTargetPair GtkTargetPair; struct _GtkTargetList { GList *list; guint ref_count; } struct _GtkTargetPair { GdkAtom target; guint flags; guint info; } GtkTargetList *gtk_target_list_new ( 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, GtkTargetEntry *targets, guint ntargets); void gtk_target_list_remove (GtkTargetList *list, GdkAtom target); gboolean gtk_target_list_find (GtkTargetList *list, GdkAtom target, guint *info); gboolean gtk_selection_owner_set (GtkWidget *widget, GdkAtom selection, guint32 time_); gboolean gtk_selection_owner_set_for_display (GdkDisplay *display, 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, GtkTargetEntry *targets, guint ntargets); void gtk_selection_clear_targets (GtkWidget *widget, GdkAtom selection); gboolean gtk_selection_convert (GtkWidget *widget, GdkAtom selection, GdkAtom target, guint32 time_); void gtk_selection_data_set (GtkSelectionData *selection_data, GdkAtom type, gint format, guchar *data, gint length); gboolean gtk_selection_data_set_text (GtkSelectionData *selection_data, gchar *str, gint len); guchar * gtk_selection_data_get_text (GtkSelectionData *selection_data); gboolean gtk_selection_data_get_targets (GtkSelectionData *selection_data, GdkAtom **targets, gint *n_atoms); gboolean gtk_selection_data_targets_include_text (GtkSelectionData *selection_data); void gtk_selection_remove_all (GtkWidget *widget); gboolean gtk_selection_clear (GtkWidget *widget, GdkEventSelection *event); gboolean _gtk_selection_request (GtkWidget *widget, GdkEventSelection *event); gboolean _gtk_selection_incr_event (GdkWindow *window, GdkEventProperty *event); gboolean _gtk_selection_notify (GtkWidget *widget, GdkEventSelection *event); gboolean _gtk_selection_property_notify (GtkWidget *widget, GdkEventProperty *event); GType gtk_selection_data_get_type (); GtkSelectionData *gtk_selection_data_copy (GtkSelectionData *data); void gtk_selection_data_free (GtkSelectionData *data); alias void (* GtkClipboardReceivedFunc) (GtkClipboard *clipboard, GtkSelectionData *selection_data, gpointer data); alias void (* GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard, gchar *text, gpointer data); alias void (* GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard, GdkAtom *atoms, gint n_atoms, gpointer data); alias void (* GtkClipboardGetFunc) (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer user_data_or_owner); alias void (* GtkClipboardClearFunc) (GtkClipboard *clipboard, gpointer user_data_or_owner); GType gtk_clipboard_get_type (); GtkClipboard *gtk_clipboard_get_for_display (GdkDisplay *display, GdkAtom selection); GtkClipboard *gtk_clipboard_get (GdkAtom selection); GdkDisplay *gtk_clipboard_get_display (GtkClipboard *clipboard); gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard, GtkTargetEntry *targets, guint n_targets, GtkClipboardGetFunc get_func, GtkClipboardClearFunc clear_func, gpointer user_data); gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard, GtkTargetEntry *targets, guint n_targets, GtkClipboardGetFunc get_func, GtkClipboardClearFunc clear_func, GObject *owner); GObject *gtk_clipboard_get_owner (GtkClipboard *clipboard); void gtk_clipboard_clear (GtkClipboard *clipboard); void gtk_clipboard_set_text (GtkClipboard *clipboard, gchar *text, gint len); void gtk_clipboard_request_contents (GtkClipboard *clipboard, GdkAtom target, GtkClipboardReceivedFunc callback, gpointer user_data); void gtk_clipboard_request_text (GtkClipboard *clipboard, GtkClipboardTextReceivedFunc callback, gpointer user_data); void gtk_clipboard_request_targets (GtkClipboard *clipboard, GtkClipboardTargetsReceivedFunc callback, gpointer user_data); GtkSelectionData *gtk_clipboard_wait_for_contents (GtkClipboard *clipboard, GdkAtom target); gchar * gtk_clipboard_wait_for_text (GtkClipboard *clipboard); gboolean gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard); gboolean gtk_clipboard_wait_for_targets (GtkClipboard *clipboard, GdkAtom **targets, gint *n_targets); alias _GtkRangeLayout GtkRangeLayout; alias void _GtkRangeLayout; alias _GtkRangeStepTimer GtkRangeStepTimer; alias void _GtkRangeStepTimer; alias _GtkRange GtkRange; alias _GtkRangeClass GtkRangeClass; struct _GtkRange { GtkWidget widget; GtkAdjustment *adjustment; GtkUpdateType update_policy; guint inverted; guint flippable; guint has_stepper_a; guint has_stepper_b; guint has_stepper_c; guint has_stepper_d; guint need_recalc; guint slider_size_fixed; gint min_slider_size; GtkOrientation orientation; GdkRectangle range_rect; gint slider_start, slider_end; gint round_digits; guint trough_click_forward; guint update_pending; GtkRangeLayout *layout; GtkRangeStepTimer *timer; gint slide_initial_slider_position; gint slide_initial_coordinate; guint update_timeout_id; GdkWindow *event_window; } struct _GtkRangeClass { GtkWidgetClass parent_class; gchar *slider_detail; gchar *stepper_detail; void (* value_changed) (GtkRange *range); void (* adjust_bounds) (GtkRange *range, gdouble new_value); void (* move_slider) (GtkRange *range, GtkScrollType scroll); void (* get_range_border) (GtkRange *range, GtkBorder *border_); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_range_get_type () ; void gtk_range_set_update_policy (GtkRange *range, GtkUpdateType policy); GtkUpdateType gtk_range_get_update_policy (GtkRange *range); void gtk_range_set_adjustment (GtkRange *range, GtkAdjustment *adjustment); GtkAdjustment* gtk_range_get_adjustment (GtkRange *range); void gtk_range_set_inverted (GtkRange *range, gboolean setting); gboolean gtk_range_get_inverted (GtkRange *range); void gtk_range_set_increments (GtkRange *range, gdouble step, gdouble page); void gtk_range_set_range (GtkRange *range, gdouble min, gdouble max); void gtk_range_set_value (GtkRange *range, gdouble value); gdouble gtk_range_get_value (GtkRange *range); alias _GtkScrollbar GtkScrollbar; alias _GtkScrollbarClass GtkScrollbarClass; struct _GtkScrollbar { GtkRange range; } struct _GtkScrollbarClass { GtkRangeClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_scrollbar_get_type () ; alias _GtkHScrollbar GtkHScrollbar; alias _GtkHScrollbarClass GtkHScrollbarClass; struct _GtkHScrollbar { GtkScrollbar scrollbar; } struct _GtkHScrollbarClass { GtkScrollbarClass parent_class; } GType gtk_hscrollbar_get_type () ; GtkWidget* gtk_hscrollbar_new (GtkAdjustment *adjustment); alias _GtkVScrollbar GtkVScrollbar; alias _GtkVScrollbarClass GtkVScrollbarClass; struct _GtkVScrollbar { GtkScrollbar scrollbar; } struct _GtkVScrollbarClass { GtkScrollbarClass parent_class; } GType gtk_vscrollbar_get_type () ; GtkWidget* gtk_vscrollbar_new (GtkAdjustment *adjustment); enum { GTK_CLIST_IN_DRAG = 1 << 0, GTK_CLIST_ROW_HEIGHT_SET = 1 << 1, GTK_CLIST_SHOW_TITLES = 1 << 2, 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 }; enum GtkCellType { GTK_CELL_EMPTY, GTK_CELL_TEXT, GTK_CELL_PIXMAP, GTK_CELL_PIXTEXT, GTK_CELL_WIDGET }; enum GtkCListDragPos { GTK_CLIST_DRAG_NONE, GTK_CLIST_DRAG_BEFORE, GTK_CLIST_DRAG_INTO, GTK_CLIST_DRAG_AFTER }; enum GtkButtonAction { GTK_BUTTON_IGNORED = 0, GTK_BUTTON_SELECTS = 1 << 0, GTK_BUTTON_DRAGS = 1 << 1, GTK_BUTTON_EXPANDS = 1 << 2 }; alias _GtkCList GtkCList; alias _GtkCListClass GtkCListClass; alias _GtkCListColumn GtkCListColumn; alias _GtkCListRow GtkCListRow; alias _GtkCell GtkCell; alias _GtkCellText GtkCellText; alias _GtkCellPixmap GtkCellPixmap; alias _GtkCellPixText GtkCellPixText; alias _GtkCellWidget GtkCellWidget; alias gint (*GtkCListCompareFunc) (GtkCList *clist, gpointer ptr1, gpointer ptr2); alias _GtkCListCellInfo GtkCListCellInfo; alias _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_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 focus_header_column; gint anchor; GtkStateType anchor_state; gint drag_pos; gint htimer; gint vtimer; GtkSortType sort_type; GtkCListCompareFunc compare; gint sort_column; gint drag_highlight_row; GtkCListDragPos drag_highlight_pos; } 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, 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; guint width_set; guint resizeable; guint auto_resize; guint button_passive; } struct _GtkCListRow { GtkCell *cell; GtkStateType state; GdkColor foreground; GdkColor background; GtkStyle *style; gpointer data; GtkDestroyNotify destroy; guint fg_set; guint bg_set; guint selectable; } 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 u_union { gchar *text; struct pm_struct { GdkPixmap *pixmap; GdkBitmap *mask; } struct pt_struct { gchar *text; guint8 spacing; GdkPixmap *pixmap; GdkBitmap *mask; } GtkWidget *widget; } u_union u; } GtkType gtk_clist_get_type () ; 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, 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, 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, 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); PangoLayout *_gtk_clist_create_cell_layout (GtkCList *clist, GtkCListRow *clist_row, gint column); alias _GtkColorButton GtkColorButton; alias _GtkColorButtonClass GtkColorButtonClass; alias _GtkColorButtonPrivate GtkColorButtonPrivate; alias void _GtkColorButtonPrivate; struct _GtkColorButton { GtkButton button; GtkColorButtonPrivate *priv; } struct _GtkColorButtonClass { GtkButtonClass parent_class; void (* color_set) (GtkColorButton *cp); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_color_button_get_type () ; GtkWidget *gtk_color_button_new (); GtkWidget *gtk_color_button_new_with_color ( GdkColor *color); void gtk_color_button_set_color (GtkColorButton *color_button, GdkColor *color); void gtk_color_button_set_alpha (GtkColorButton *color_button, guint16 alpha); void gtk_color_button_get_color (GtkColorButton *color_button, GdkColor *color); guint16 gtk_color_button_get_alpha (GtkColorButton *color_button); void gtk_color_button_set_use_alpha (GtkColorButton *color_button, gboolean use_alpha); gboolean gtk_color_button_get_use_alpha (GtkColorButton *color_button); void gtk_color_button_set_title (GtkColorButton *color_button, gchar *title); gchar *gtk_color_button_get_title (GtkColorButton *color_button); enum GtkDialogFlags { GTK_DIALOG_MODAL = 1 << 0, GTK_DIALOG_DESTROY_WITH_PARENT = 1 << 1, GTK_DIALOG_NO_SEPARATOR = 1 << 2 }; enum GtkResponseType { GTK_RESPONSE_NONE = -1, GTK_RESPONSE_REJECT = -2, GTK_RESPONSE_ACCEPT = -3, GTK_RESPONSE_DELETE_EVENT = -4, GTK_RESPONSE_OK = -5, GTK_RESPONSE_CANCEL = -6, GTK_RESPONSE_CLOSE = -7, GTK_RESPONSE_YES = -8, GTK_RESPONSE_NO = -9, GTK_RESPONSE_APPLY = -10, GTK_RESPONSE_HELP = -11 }; alias _GtkDialog GtkDialog; alias _GtkDialogClass GtkDialogClass; struct _GtkDialog { GtkWindow window; GtkWidget *vbox; GtkWidget *action_area; GtkWidget *separator; } struct _GtkDialogClass { GtkWindowClass parent_class; void (* response) (GtkDialog *dialog, gint response_id); void (* close) (GtkDialog *dialog); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_dialog_get_type () ; GtkWidget* gtk_dialog_new (); GtkWidget* gtk_dialog_new_with_buttons ( gchar *title, GtkWindow *parent, GtkDialogFlags flags, gchar *first_button_text, ...); void gtk_dialog_add_action_widget (GtkDialog *dialog, GtkWidget *child, gint response_id); GtkWidget* gtk_dialog_add_button (GtkDialog *dialog, gchar *button_text, gint response_id); void gtk_dialog_add_buttons (GtkDialog *dialog, gchar *first_button_text, ...); void gtk_dialog_set_response_sensitive (GtkDialog *dialog, gint response_id, gboolean setting); void gtk_dialog_set_default_response (GtkDialog *dialog, gint response_id); void gtk_dialog_set_has_separator (GtkDialog *dialog, gboolean setting); gboolean gtk_dialog_get_has_separator (GtkDialog *dialog); void gtk_dialog_response (GtkDialog *dialog, gint response_id); gint gtk_dialog_run (GtkDialog *dialog); void _gtk_dialog_set_ignore_separator (GtkDialog *dialog, gboolean ignore_separator); gint _gtk_dialog_get_response_for_widget (GtkDialog *dialog, GtkWidget *widget); alias _GtkVBox GtkVBox; alias _GtkVBoxClass GtkVBoxClass; struct _GtkVBox { GtkBox box; } struct _GtkVBoxClass { GtkBoxClass parent_class; } GType gtk_vbox_get_type () ; GtkWidget* gtk_vbox_new (gboolean homogeneous, gint spacing); alias _GtkColorSelection GtkColorSelection; alias _GtkColorSelectionClass GtkColorSelectionClass; alias void (* GtkColorSelectionChangePaletteFunc) ( GdkColor *colors, gint n_colors); alias void (* GtkColorSelectionChangePaletteWithScreenFunc) (GdkScreen *screen, GdkColor *colors, gint n_colors); struct _GtkColorSelection { GtkVBox parent_instance; gpointer private_data; } struct _GtkColorSelectionClass { GtkVBoxClass parent_class; void (*color_changed) (GtkColorSelection *color_selection); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_color_selection_get_type () ; GtkWidget *gtk_color_selection_new (); gboolean gtk_color_selection_get_has_opacity_control (GtkColorSelection *colorsel); void gtk_color_selection_set_has_opacity_control (GtkColorSelection *colorsel, gboolean has_opacity); gboolean gtk_color_selection_get_has_palette (GtkColorSelection *colorsel); void gtk_color_selection_set_has_palette (GtkColorSelection *colorsel, gboolean has_palette); void gtk_color_selection_set_current_color (GtkColorSelection *colorsel, GdkColor *color); void gtk_color_selection_set_current_alpha (GtkColorSelection *colorsel, guint16 alpha); void gtk_color_selection_get_current_color (GtkColorSelection *colorsel, GdkColor *color); guint16 gtk_color_selection_get_current_alpha (GtkColorSelection *colorsel); void gtk_color_selection_set_previous_color (GtkColorSelection *colorsel, GdkColor *color); void gtk_color_selection_set_previous_alpha (GtkColorSelection *colorsel, guint16 alpha); void gtk_color_selection_get_previous_color (GtkColorSelection *colorsel, GdkColor *color); guint16 gtk_color_selection_get_previous_alpha (GtkColorSelection *colorsel); gboolean gtk_color_selection_is_adjusting (GtkColorSelection *colorsel); gboolean gtk_color_selection_palette_from_string ( gchar *str, GdkColor **colors, gint *n_colors); gchar* gtk_color_selection_palette_to_string ( GdkColor *colors, gint n_colors); GtkColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook (GtkColorSelectionChangePaletteFunc func); GtkColorSelectionChangePaletteWithScreenFunc gtk_color_selection_set_change_palette_with_screen_hook (GtkColorSelectionChangePaletteWithScreenFunc func); void gtk_color_selection_set_color (GtkColorSelection *colorsel, gdouble *color); void gtk_color_selection_get_color (GtkColorSelection *colorsel, gdouble *color); void gtk_color_selection_set_update_policy (GtkColorSelection *colorsel, GtkUpdateType policy); alias _GtkColorSelectionDialog GtkColorSelectionDialog; alias _GtkColorSelectionDialogClass GtkColorSelectionDialogClass; struct _GtkColorSelectionDialog { GtkDialog parent_instance; GtkWidget *colorsel; GtkWidget *ok_button; GtkWidget *cancel_button; GtkWidget *help_button; } struct _GtkColorSelectionDialogClass { GtkDialogClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_color_selection_dialog_get_type () ; GtkWidget* gtk_color_selection_dialog_new ( gchar *title); alias _GtkHBox GtkHBox; alias _GtkHBoxClass GtkHBoxClass; struct _GtkHBox { GtkBox box; } struct _GtkHBoxClass { GtkBoxClass parent_class; } GType gtk_hbox_get_type () ; GtkWidget* gtk_hbox_new (gboolean homogeneous, gint spacing); alias _GtkCombo GtkCombo; alias _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; guint ok_if_empty; guint case_sensitive; guint use_arrows; guint use_arrows_always; guint16 current_button; guint activate_id; } struct _GtkComboClass { GtkHBoxClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_combo_get_type () ; GtkWidget* gtk_combo_new (); void gtk_combo_set_value_in_list (GtkCombo* combo, gboolean val, gboolean ok_if_empty); void gtk_combo_set_use_arrows (GtkCombo* combo, gboolean val); void gtk_combo_set_use_arrows_always (GtkCombo* combo, gboolean val); void gtk_combo_set_case_sensitive (GtkCombo* combo, gboolean val); void gtk_combo_set_item_string (GtkCombo* combo, GtkItem* item, gchar* item_value); void gtk_combo_set_popdown_strings (GtkCombo* combo, GList *strings); void gtk_combo_disable_activate (GtkCombo* combo); enum GtkDestDefaults { GTK_DEST_DEFAULT_MOTION = 1 << 0, GTK_DEST_DEFAULT_HIGHLIGHT = 1 << 1, GTK_DEST_DEFAULT_DROP = 1 << 2, GTK_DEST_DEFAULT_ALL = 0x07 }; enum GtkTargetFlags { GTK_TARGET_SAME_APP = 1 << 0, GTK_TARGET_SAME_WIDGET = 1 << 1 }; 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, 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); GdkAtom gtk_drag_dest_find_target (GtkWidget *widget, GdkDragContext *context, GtkTargetList *target_list); GtkTargetList* gtk_drag_dest_get_target_list (GtkWidget *widget); void gtk_drag_dest_set_target_list (GtkWidget *widget, GtkTargetList *target_list); void gtk_drag_source_set (GtkWidget *widget, GdkModifierType start_button_mask, GtkTargetEntry *targets, gint n_targets, GdkDragAction actions); void gtk_drag_source_unset (GtkWidget *widget); GtkTargetList* gtk_drag_source_get_target_list (GtkWidget *widget); void gtk_drag_source_set_target_list (GtkWidget *widget, GtkTargetList *target_list); void gtk_drag_source_set_icon (GtkWidget *widget, GdkColormap *colormap, GdkPixmap *pixmap, GdkBitmap *mask); void gtk_drag_source_set_icon_pixbuf (GtkWidget *widget, GdkPixbuf *pixbuf); void gtk_drag_source_set_icon_stock (GtkWidget *widget, gchar *stock_id); 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_pixbuf (GdkDragContext *context, GdkPixbuf *pixbuf, gint hot_x, gint hot_y); void gtk_drag_set_icon_stock (GdkDragContext *context, gchar *stock_id, gint hot_x, gint hot_y); void gtk_drag_set_icon_default (GdkDragContext *context); gboolean gtk_drag_check_threshold (GtkWidget *widget, gint start_x, gint start_y, gint current_x, gint current_y); void _gtk_drag_source_handle_event (GtkWidget *widget, GdkEvent *event); void _gtk_drag_dest_handle_event (GtkWidget *toplevel, GdkEvent *event); void gtk_drag_set_default_icon (GdkColormap *colormap, GdkPixmap *pixmap, GdkBitmap *mask, gint hot_x, gint hot_y); enum GtkTreeViewDropPosition { GTK_TREE_VIEW_DROP_BEFORE, GTK_TREE_VIEW_DROP_AFTER, GTK_TREE_VIEW_DROP_INTO_OR_BEFORE, GTK_TREE_VIEW_DROP_INTO_OR_AFTER }; alias _GtkTreeView GtkTreeView; alias _GtkTreeViewClass GtkTreeViewClass; alias _GtkTreeViewPrivate GtkTreeViewPrivate; alias void _GtkTreeViewPrivate; alias _GtkTreeSelection GtkTreeSelection; alias _GtkTreeSelectionClass GtkTreeSelectionClass; struct _GtkTreeView { GtkContainer parent; GtkTreeViewPrivate *priv; } struct _GtkTreeViewClass { GtkContainerClass parent_class; void (* set_scroll_adjustments) (GtkTreeView *tree_view, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment); void (* row_activated) (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column); gboolean (* test_expand_row) (GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path); gboolean (* test_collapse_row) (GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path); void (* row_expanded) (GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path); void (* row_collapsed) (GtkTreeView *tree_view, GtkTreeIter *iter, GtkTreePath *path); void (* columns_changed) (GtkTreeView *tree_view); void (* cursor_changed) (GtkTreeView *tree_view); gboolean (* move_cursor) (GtkTreeView *tree_view, GtkMovementStep step, gint count); gboolean (* select_all) (GtkTreeView *tree_view); gboolean (* unselect_all) (GtkTreeView *tree_view); gboolean (* select_cursor_row) (GtkTreeView *tree_view, gboolean start_editing); gboolean (* toggle_cursor_row) (GtkTreeView *tree_view); gboolean (* expand_collapse_cursor_row) (GtkTreeView *tree_view, gboolean logical, gboolean expand, gboolean open_all); gboolean (* select_cursor_parent) (GtkTreeView *tree_view); gboolean (* start_interactive_search) (GtkTreeView *tree_view); void (*_gtk_reserved0) (); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } alias gboolean (* GtkTreeViewColumnDropFunc) (GtkTreeView *tree_view, GtkTreeViewColumn *column, GtkTreeViewColumn *prev_column, GtkTreeViewColumn *next_column, gpointer data); alias void (* GtkTreeViewMappingFunc) (GtkTreeView *tree_view, GtkTreePath *path, gpointer user_data); alias gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel *model, gint column, gchar *key, GtkTreeIter *iter, gpointer search_data); GType gtk_tree_view_get_type (); GtkWidget *gtk_tree_view_new (); GtkWidget *gtk_tree_view_new_with_model (GtkTreeModel *model); GtkTreeModel *gtk_tree_view_get_model (GtkTreeView *tree_view); void gtk_tree_view_set_model (GtkTreeView *tree_view, GtkTreeModel *model); GtkTreeSelection *gtk_tree_view_get_selection (GtkTreeView *tree_view); GtkAdjustment *gtk_tree_view_get_hadjustment (GtkTreeView *tree_view); void gtk_tree_view_set_hadjustment (GtkTreeView *tree_view, GtkAdjustment *adjustment); GtkAdjustment *gtk_tree_view_get_vadjustment (GtkTreeView *tree_view); void gtk_tree_view_set_vadjustment (GtkTreeView *tree_view, GtkAdjustment *adjustment); gboolean gtk_tree_view_get_headers_visible (GtkTreeView *tree_view); void gtk_tree_view_set_headers_visible (GtkTreeView *tree_view, gboolean headers_visible); void gtk_tree_view_columns_autosize (GtkTreeView *tree_view); void gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view, gboolean setting); void gtk_tree_view_set_rules_hint (GtkTreeView *tree_view, gboolean setting); gboolean gtk_tree_view_get_rules_hint (GtkTreeView *tree_view); gint gtk_tree_view_append_column (GtkTreeView *tree_view, GtkTreeViewColumn *column); gint gtk_tree_view_remove_column (GtkTreeView *tree_view, GtkTreeViewColumn *column); gint gtk_tree_view_insert_column (GtkTreeView *tree_view, GtkTreeViewColumn *column, gint position); gint gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view, gint position, gchar *title, GtkCellRenderer *cell, ...); gint gtk_tree_view_insert_column_with_data_func (GtkTreeView *tree_view, gint position, gchar *title, GtkCellRenderer *cell, GtkTreeCellDataFunc func, gpointer data, GDestroyNotify dnotify); GtkTreeViewColumn *gtk_tree_view_get_column (GtkTreeView *tree_view, gint n); GList *gtk_tree_view_get_columns (GtkTreeView *tree_view); void gtk_tree_view_move_column_after (GtkTreeView *tree_view, GtkTreeViewColumn *column, GtkTreeViewColumn *base_column); void gtk_tree_view_set_expander_column (GtkTreeView *tree_view, GtkTreeViewColumn *column); GtkTreeViewColumn *gtk_tree_view_get_expander_column (GtkTreeView *tree_view); void gtk_tree_view_set_column_drag_function (GtkTreeView *tree_view, GtkTreeViewColumnDropFunc func, gpointer user_data, GtkDestroyNotify destroy); void gtk_tree_view_scroll_to_point (GtkTreeView *tree_view, gint tree_x, gint tree_y); void gtk_tree_view_scroll_to_cell (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gboolean use_align, gfloat row_align, gfloat col_align); void gtk_tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column); void gtk_tree_view_expand_all (GtkTreeView *tree_view); void gtk_tree_view_collapse_all (GtkTreeView *tree_view); void gtk_tree_view_expand_to_path (GtkTreeView *tree_view, GtkTreePath *path); gboolean gtk_tree_view_expand_row (GtkTreeView *tree_view, GtkTreePath *path, gboolean open_all); gboolean gtk_tree_view_collapse_row (GtkTreeView *tree_view, GtkTreePath *path); void gtk_tree_view_map_expanded_rows (GtkTreeView *tree_view, GtkTreeViewMappingFunc func, gpointer data); gboolean gtk_tree_view_row_expanded (GtkTreeView *tree_view, GtkTreePath *path); void gtk_tree_view_set_reorderable (GtkTreeView *tree_view, gboolean reorderable); gboolean gtk_tree_view_get_reorderable (GtkTreeView *tree_view); void gtk_tree_view_set_cursor (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *focus_column, gboolean start_editing); void gtk_tree_view_set_cursor_on_cell (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *focus_column, GtkCellRenderer *focus_cell, gboolean start_editing); void gtk_tree_view_get_cursor (GtkTreeView *tree_view, GtkTreePath **path, GtkTreeViewColumn **focus_column); GdkWindow *gtk_tree_view_get_bin_window (GtkTreeView *tree_view); gboolean gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view, gint x, gint y, GtkTreePath **path, GtkTreeViewColumn **column, gint *cell_x, gint *cell_y); void gtk_tree_view_get_cell_area (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, GdkRectangle *rect); void gtk_tree_view_get_background_area (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, GdkRectangle *rect); void gtk_tree_view_get_visible_rect (GtkTreeView *tree_view, GdkRectangle *visible_rect); void gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view, gint wx, gint wy, gint *tx, gint *ty); void gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view, gint tx, gint ty, gint *wx, gint *wy); void gtk_tree_view_enable_model_drag_source (GtkTreeView *tree_view, GdkModifierType start_button_mask, GtkTargetEntry *targets, gint n_targets, GdkDragAction actions); void gtk_tree_view_enable_model_drag_dest (GtkTreeView *tree_view, GtkTargetEntry *targets, gint n_targets, GdkDragAction actions); void gtk_tree_view_unset_rows_drag_source (GtkTreeView *tree_view); void gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view); void gtk_tree_view_set_drag_dest_row (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewDropPosition pos); void gtk_tree_view_get_drag_dest_row (GtkTreeView *tree_view, GtkTreePath **path, GtkTreeViewDropPosition *pos); gboolean gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view, gint drag_x, gint drag_y, GtkTreePath **path, GtkTreeViewDropPosition *pos); GdkPixmap *gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view, GtkTreePath *path); void gtk_tree_view_set_enable_search (GtkTreeView *tree_view, gboolean enable_search); gboolean gtk_tree_view_get_enable_search (GtkTreeView *tree_view); gint gtk_tree_view_get_search_column (GtkTreeView *tree_view); void gtk_tree_view_set_search_column (GtkTreeView *tree_view, gint column); GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view); void gtk_tree_view_set_search_equal_func (GtkTreeView *tree_view, GtkTreeViewSearchEqualFunc search_equal_func, gpointer search_user_data, GtkDestroyNotify search_destroy); alias void (* GtkTreeDestroyCountFunc) (GtkTreeView *tree_view, GtkTreePath *path, gint children, gpointer user_data); void gtk_tree_view_set_destroy_count_func (GtkTreeView *tree_view, GtkTreeDestroyCountFunc func, gpointer data, GtkDestroyNotify destroy); alias _GtkComboBox GtkComboBox; alias _GtkComboBoxClass GtkComboBoxClass; alias _GtkComboBoxPrivate GtkComboBoxPrivate; alias void _GtkComboBoxPrivate; struct _GtkComboBox { GtkBin parent_instance; GtkComboBoxPrivate *priv; } struct _GtkComboBoxClass { GtkBinClass parent_class; void (* changed) (GtkComboBox *combo_box); void (*_gtk_reserved0) (); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_combo_box_get_type (); GtkWidget *gtk_combo_box_new (); GtkWidget *gtk_combo_box_new_with_model (GtkTreeModel *model); void gtk_combo_box_set_wrap_width (GtkComboBox *combo_box, gint width); void gtk_combo_box_set_row_span_column (GtkComboBox *combo_box, gint row_span); void gtk_combo_box_set_column_span_column (GtkComboBox *combo_box, gint column_span); gint gtk_combo_box_get_active (GtkComboBox *combo_box); void gtk_combo_box_set_active (GtkComboBox *combo_box, gint index_); gboolean gtk_combo_box_get_active_iter (GtkComboBox *combo_box, GtkTreeIter *iter); void gtk_combo_box_set_active_iter (GtkComboBox *combo_box, GtkTreeIter *iter); void gtk_combo_box_set_model (GtkComboBox *combo_box, GtkTreeModel *model); GtkTreeModel *gtk_combo_box_get_model (GtkComboBox *combo_box); GtkWidget *gtk_combo_box_new_text (); void gtk_combo_box_append_text (GtkComboBox *combo_box, gchar *text); void gtk_combo_box_insert_text (GtkComboBox *combo_box, gint position, gchar *text); void gtk_combo_box_prepend_text (GtkComboBox *combo_box, gchar *text); void gtk_combo_box_remove_text (GtkComboBox *combo_box, gint position); void gtk_combo_box_popup (GtkComboBox *combo_box); void gtk_combo_box_popdown (GtkComboBox *combo_box); alias _GtkComboBoxEntry GtkComboBoxEntry; alias _GtkComboBoxEntryClass GtkComboBoxEntryClass; alias _GtkComboBoxEntryPrivate GtkComboBoxEntryPrivate; alias void _GtkComboBoxEntryPrivate; struct _GtkComboBoxEntry { GtkComboBox parent_instance; GtkComboBoxEntryPrivate *priv; } struct _GtkComboBoxEntryClass { GtkComboBoxClass parent_class; void (*_gtk_reserved0) (); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_combo_box_entry_get_type (); GtkWidget *gtk_combo_box_entry_new (); GtkWidget *gtk_combo_box_entry_new_with_model (GtkTreeModel *model, gint text_column); void gtk_combo_box_entry_set_text_column (GtkComboBoxEntry *entry_box, gint text_column); gint gtk_combo_box_entry_get_text_column (GtkComboBoxEntry *entry_box); GtkWidget *gtk_combo_box_entry_new_text (); enum GtkCTreePos { GTK_CTREE_POS_BEFORE, GTK_CTREE_POS_AS_CHILD, GTK_CTREE_POS_AFTER }; enum GtkCTreeLineStyle { GTK_CTREE_LINES_NONE, GTK_CTREE_LINES_SOLID, GTK_CTREE_LINES_DOTTED, GTK_CTREE_LINES_TABBED }; enum GtkCTreeExpanderStyle { GTK_CTREE_EXPANDER_NONE, GTK_CTREE_EXPANDER_SQUARE, GTK_CTREE_EXPANDER_TRIANGLE, GTK_CTREE_EXPANDER_CIRCULAR }; enum GtkCTreeExpansionType { 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 }; alias _GtkCTree GtkCTree; alias _GtkCTreeClass GtkCTreeClass; alias _GtkCTreeRow GtkCTreeRow; alias _GtkCTreeNode GtkCTreeNode; alias void (*GtkCTreeFunc) (GtkCTree *ctree, GtkCTreeNode *node, gpointer data); alias gboolean (*GtkCTreeGNodeFunc) (GtkCTree *ctree, guint depth, GNode *gnode, GtkCTreeNode *cnode, gpointer data); alias 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; guint expander_style; guint show_stub; 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; guint expanded; } struct _GtkCTreeNode { GList list; } GtkType gtk_ctree_get_type () ; 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, 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, gchar *text, guint8 spacing, GdkPixmap *pixmap, GdkBitmap *mask); void gtk_ctree_set_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_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); gboolean gtk_ctree_node_get_text (GtkCTree *ctree, GtkCTreeNode *node, gint column, gchar **text); gboolean gtk_ctree_node_get_pixmap (GtkCTree *ctree, GtkCTreeNode *node, gint column, GdkPixmap **pixmap, GdkBitmap **mask); gboolean gtk_ctree_node_get_pixtext (GtkCTree *ctree, GtkCTreeNode *node, gint column, gchar **text, guint8 *spacing, GdkPixmap **pixmap, GdkBitmap **mask); gboolean 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); GType gtk_ctree_node_get_type () ; alias _GtkDrawingArea GtkDrawingArea; alias _GtkDrawingAreaClass GtkDrawingAreaClass; struct _GtkDrawingArea { GtkWidget widget; gpointer draw_data; } struct _GtkDrawingAreaClass { GtkWidgetClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_drawing_area_get_type () ; GtkWidget* gtk_drawing_area_new (); void gtk_drawing_area_size (GtkDrawingArea *darea, gint width, gint height); alias _GtkCurve GtkCurve; alias _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); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_curve_get_type () ; GtkWidget* gtk_curve_new (); 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); alias _GtkEditable GtkEditable; alias void _GtkEditable; alias _GtkEditableClass GtkEditableClass; struct _GtkEditableClass { GTypeInterface base_iface; void (* insert_text) (GtkEditable *editable, gchar *text, gint length, gint *position); void (* delete_text) (GtkEditable *editable, gint start_pos, gint end_pos); void (* changed) (GtkEditable *editable); void (* do_insert_text) (GtkEditable *editable, gchar *text, gint length, gint *position); void (* do_delete_text) (GtkEditable *editable, gint start_pos, gint end_pos); gchar* (* get_chars) (GtkEditable *editable, gint start_pos, gint end_pos); void (* set_selection_bounds) (GtkEditable *editable, gint start_pos, gint end_pos); gboolean (* get_selection_bounds) (GtkEditable *editable, gint *start_pos, gint *end_pos); void (* set_position) (GtkEditable *editable, gint position); gint (* get_position) (GtkEditable *editable); } GType gtk_editable_get_type () ; void gtk_editable_select_region (GtkEditable *editable, gint start, gint end); gboolean gtk_editable_get_selection_bounds (GtkEditable *editable, gint *start, gint *end); void gtk_editable_insert_text (GtkEditable *editable, 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_delete_selection (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); gboolean gtk_editable_get_editable (GtkEditable *editable); alias _GtkIMContext GtkIMContext; alias _GtkIMContextClass GtkIMContextClass; struct _GtkIMContext { GObject parent_instance; } struct _GtkIMContextClass { GtkObjectClass parent_class; void (*preedit_start) (GtkIMContext *context); void (*preedit_end) (GtkIMContext *context); void (*preedit_changed) (GtkIMContext *context); void (*commit) (GtkIMContext *context, gchar *str); gboolean (*retrieve_surrounding) (GtkIMContext *context); gboolean (*delete_surrounding) (GtkIMContext *context, gint offset, gint n_chars); void (*set_client_window) (GtkIMContext *context, GdkWindow *window); void (*get_preedit_string) (GtkIMContext *context, gchar **str, PangoAttrList **attrs, gint *cursor_pos); gboolean (*filter_keypress) (GtkIMContext *context, GdkEventKey *event); void (*focus_in) (GtkIMContext *context); void (*focus_out) (GtkIMContext *context); void (*reset) (GtkIMContext *context); void (*set_cursor_location) (GtkIMContext *context, GdkRectangle *area); void (*set_use_preedit) (GtkIMContext *context, gboolean use_preedit); void (*set_surrounding) (GtkIMContext *context, gchar *text, gint len, gint cursor_index); gboolean (*get_surrounding) (GtkIMContext *context, gchar **text, gint *cursor_index); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); void (*_gtk_reserved5) (); void (*_gtk_reserved6) (); } GType gtk_im_context_get_type () ; void gtk_im_context_set_client_window (GtkIMContext *context, GdkWindow *window); void gtk_im_context_get_preedit_string (GtkIMContext *context, gchar **str, PangoAttrList **attrs, gint *cursor_pos); gboolean gtk_im_context_filter_keypress (GtkIMContext *context, GdkEventKey *event); void gtk_im_context_focus_in (GtkIMContext *context); void gtk_im_context_focus_out (GtkIMContext *context); void gtk_im_context_reset (GtkIMContext *context); void gtk_im_context_set_cursor_location (GtkIMContext *context, GdkRectangle *area); void gtk_im_context_set_use_preedit (GtkIMContext *context, gboolean use_preedit); void gtk_im_context_set_surrounding (GtkIMContext *context, gchar *text, gint len, gint cursor_index); gboolean gtk_im_context_get_surrounding (GtkIMContext *context, gchar **text, gint *cursor_index); gboolean gtk_im_context_delete_surrounding (GtkIMContext *context, gint offset, gint n_chars); alias _GtkListStore GtkListStore; alias _GtkListStoreClass GtkListStoreClass; struct _GtkListStore { GObject parent; gint stamp; gpointer root; gpointer tail; GList *sort_list; gint n_columns; gint sort_column_id; GtkSortType order; GType *column_headers; gint length; GtkTreeIterCompareFunc default_sort_func; gpointer default_sort_data; GtkDestroyNotify default_sort_destroy; guint columns_dirty; } struct _GtkListStoreClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_list_store_get_type (); GtkListStore *gtk_list_store_new (gint n_columns, ...); GtkListStore *gtk_list_store_newv (gint n_columns, GType *types); void gtk_list_store_set_column_types (GtkListStore *list_store, gint n_columns, GType *types); void gtk_list_store_set_value (GtkListStore *list_store, GtkTreeIter *iter, gint column, GValue *value); void gtk_list_store_set (GtkListStore *list_store, GtkTreeIter *iter, ...); void gtk_list_store_set_valist (GtkListStore *list_store, GtkTreeIter *iter, va_list var_args); gboolean gtk_list_store_remove (GtkListStore *list_store, GtkTreeIter *iter); void gtk_list_store_insert (GtkListStore *list_store, GtkTreeIter *iter, gint position); void gtk_list_store_insert_before (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling); void gtk_list_store_insert_after (GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling); void gtk_list_store_prepend (GtkListStore *list_store, GtkTreeIter *iter); void gtk_list_store_append (GtkListStore *list_store, GtkTreeIter *iter); void gtk_list_store_clear (GtkListStore *list_store); gboolean gtk_list_store_iter_is_valid (GtkListStore *list_store, GtkTreeIter *iter); void gtk_list_store_reorder (GtkListStore *store, gint *new_order); void gtk_list_store_swap (GtkListStore *store, GtkTreeIter *a, GtkTreeIter *b); void gtk_list_store_move_after (GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position); void gtk_list_store_move_before (GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position); alias gboolean (* GtkTreeModelFilterVisibleFunc) (GtkTreeModel *model, GtkTreeIter *iter, gpointer data); alias void (* GtkTreeModelFilterModifyFunc) (GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data); alias _GtkTreeModelFilter GtkTreeModelFilter; alias _GtkTreeModelFilterClass GtkTreeModelFilterClass; alias _GtkTreeModelFilterPrivate GtkTreeModelFilterPrivate; alias void _GtkTreeModelFilterPrivate; struct _GtkTreeModelFilter { GObject parent; GtkTreeModelFilterPrivate *priv; } struct _GtkTreeModelFilterClass { GObjectClass parent_class; void (*_gtk_reserved0) (); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_tree_model_filter_get_type (); GtkTreeModel *gtk_tree_model_filter_new (GtkTreeModel *child_model, GtkTreePath *root); void gtk_tree_model_filter_set_visible_func (GtkTreeModelFilter *filter, GtkTreeModelFilterVisibleFunc func, gpointer data, GtkDestroyNotify destroy); void gtk_tree_model_filter_set_modify_func (GtkTreeModelFilter *filter, gint n_columns, GType *types, GtkTreeModelFilterModifyFunc func, gpointer data, GtkDestroyNotify destroy); void gtk_tree_model_filter_set_visible_column (GtkTreeModelFilter *filter, gint column); GtkTreeModel *gtk_tree_model_filter_get_model (GtkTreeModelFilter *filter); void gtk_tree_model_filter_convert_child_iter_to_iter (GtkTreeModelFilter *filter, GtkTreeIter *filter_iter, GtkTreeIter *child_iter); void gtk_tree_model_filter_convert_iter_to_child_iter (GtkTreeModelFilter *filter, GtkTreeIter *child_iter, GtkTreeIter *filter_iter); GtkTreePath *gtk_tree_model_filter_convert_child_path_to_path (GtkTreeModelFilter *filter, GtkTreePath *child_path); GtkTreePath *gtk_tree_model_filter_convert_path_to_child_path (GtkTreeModelFilter *filter, GtkTreePath *filter_path); void gtk_tree_model_filter_refilter (GtkTreeModelFilter *filter); void gtk_tree_model_filter_clear_cache (GtkTreeModelFilter *filter); alias _GtkEntryCompletion GtkEntryCompletion; alias _GtkEntryCompletionClass GtkEntryCompletionClass; alias _GtkEntryCompletionPrivate GtkEntryCompletionPrivate; alias void _GtkEntryCompletionPrivate; alias gboolean (* GtkEntryCompletionMatchFunc) (GtkEntryCompletion *completion, gchar *key, GtkTreeIter *iter, gpointer user_data); struct _GtkEntryCompletion { GObject parent_instance; GtkEntryCompletionPrivate *priv; } struct _GtkEntryCompletionClass { GObjectClass parent_class; gboolean (* match_selected) (GtkEntryCompletion *completion, GtkTreeModel *model, GtkTreeIter *iter); void (* action_activated) (GtkEntryCompletion *completion, gint index_); void (*_gtk_reserved0) (); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_entry_completion_get_type (); GtkEntryCompletion *gtk_entry_completion_new (); GtkWidget *gtk_entry_completion_get_entry (GtkEntryCompletion *completion); void gtk_entry_completion_set_model (GtkEntryCompletion *completion, GtkTreeModel *model); GtkTreeModel *gtk_entry_completion_get_model (GtkEntryCompletion *completion); void gtk_entry_completion_set_match_func (GtkEntryCompletion *completion, GtkEntryCompletionMatchFunc func, gpointer func_data, GDestroyNotify func_notify); void gtk_entry_completion_set_minimum_key_length (GtkEntryCompletion *completion, gint length); gint gtk_entry_completion_get_minimum_key_length (GtkEntryCompletion *completion); void gtk_entry_completion_complete (GtkEntryCompletion *completion); void gtk_entry_completion_insert_action_text (GtkEntryCompletion *completion, gint index_, gchar *text); void gtk_entry_completion_insert_action_markup (GtkEntryCompletion *completion, gint index_, gchar *markup); void gtk_entry_completion_delete_action (GtkEntryCompletion *completion, gint index_); void gtk_entry_completion_set_text_column (GtkEntryCompletion *completion, gint column); alias _GtkEntry GtkEntry; alias _GtkEntryClass GtkEntryClass; struct _GtkEntry { GtkWidget widget; gchar *text; guint editable; guint visible; guint overwrite_mode; guint in_drag; guint16 text_length; guint16 text_max_length; GdkWindow *text_area; GtkIMContext *im_context; GtkWidget *popup_menu; gint current_pos; gint selection_bound; PangoLayout *cached_layout; guint cache_includes_preedit; guint need_im_reset; guint has_frame; guint activates_default; guint cursor_visible; guint in_click; guint is_cell_renderer; guint editing_canceled; guint mouse_cursor_obscured; guint select_words; guint select_lines; guint resolved_dir; guint button; guint blink_timeout; guint recompute_idle; gint scroll_offset; gint ascent; gint descent; guint16 text_size; guint16 n_bytes; guint16 preedit_length; guint16 preedit_cursor; gint dnd_position; gint drag_start_x; gint drag_start_y; gunichar invisible_char; gint width_chars; } struct _GtkEntryClass { GtkWidgetClass parent_class; void (* populate_popup) (GtkEntry *entry, GtkMenu *menu); void (* activate) (GtkEntry *entry); void (* move_cursor) (GtkEntry *entry, GtkMovementStep step, gint count, gboolean extend_selection); void (* insert_at_cursor) (GtkEntry *entry, gchar *str); void (* delete_from_cursor) (GtkEntry *entry, GtkDeleteType type, gint count); void (* cut_clipboard) (GtkEntry *entry); void (* copy_clipboard) (GtkEntry *entry); void (* paste_clipboard) (GtkEntry *entry); void (* toggle_overwrite) (GtkEntry *entry); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_entry_get_type () ; GtkWidget* gtk_entry_new (); void gtk_entry_set_visibility (GtkEntry *entry, gboolean visible); gboolean gtk_entry_get_visibility (GtkEntry *entry); void gtk_entry_set_invisible_char (GtkEntry *entry, gunichar ch); gunichar gtk_entry_get_invisible_char (GtkEntry *entry); void gtk_entry_set_has_frame (GtkEntry *entry, gboolean setting); gboolean gtk_entry_get_has_frame (GtkEntry *entry); void gtk_entry_set_max_length (GtkEntry *entry, gint max); gint gtk_entry_get_max_length (GtkEntry *entry); void gtk_entry_set_activates_default (GtkEntry *entry, gboolean setting); gboolean gtk_entry_get_activates_default (GtkEntry *entry); void gtk_entry_set_width_chars (GtkEntry *entry, gint n_chars); gint gtk_entry_get_width_chars (GtkEntry *entry); void gtk_entry_set_text (GtkEntry *entry, gchar *text); gchar* gtk_entry_get_text (GtkEntry *entry); PangoLayout* gtk_entry_get_layout (GtkEntry *entry); void gtk_entry_get_layout_offsets (GtkEntry *entry, gint *x, gint *y); void gtk_entry_set_alignment (GtkEntry *entry, gfloat xalign); gfloat gtk_entry_get_alignment (GtkEntry *entry); void gtk_entry_set_completion (GtkEntry *entry, GtkEntryCompletion *completion); GtkEntryCompletion *gtk_entry_get_completion (GtkEntry *entry); GtkWidget* gtk_entry_new_with_max_length (gint max); void gtk_entry_append_text (GtkEntry *entry, gchar *text); void gtk_entry_prepend_text (GtkEntry *entry, gchar *text); void gtk_entry_set_position (GtkEntry *entry, gint position); void gtk_entry_select_region (GtkEntry *entry, gint start, gint end); void gtk_entry_set_editable (GtkEntry *entry, gboolean editable); alias _GtkEventBox GtkEventBox; alias _GtkEventBoxClass GtkEventBoxClass; struct _GtkEventBox { GtkBin bin; } struct _GtkEventBoxClass { GtkBinClass parent_class; } GType gtk_event_box_get_type () ; GtkWidget* gtk_event_box_new (); gboolean gtk_event_box_get_visible_window (GtkEventBox *event_box); void gtk_event_box_set_visible_window (GtkEventBox *event_box, gboolean visible_window); gboolean gtk_event_box_get_above_child (GtkEventBox *event_box); void gtk_event_box_set_above_child (GtkEventBox *event_box, gboolean above_child); alias _GtkExpander GtkExpander; alias _GtkExpanderClass GtkExpanderClass; alias _GtkExpanderPrivate GtkExpanderPrivate; alias void _GtkExpanderPrivate; struct _GtkExpander { GtkBin bin; GtkExpanderPrivate *priv; } struct _GtkExpanderClass { GtkBinClass parent_class; void (* activate) (GtkExpander *expander); } GType gtk_expander_get_type (); GtkWidget *gtk_expander_new ( gchar *label); GtkWidget *gtk_expander_new_with_mnemonic ( gchar *label); void gtk_expander_set_expanded (GtkExpander *expander, gboolean expanded); gboolean gtk_expander_get_expanded (GtkExpander *expander); void gtk_expander_set_spacing (GtkExpander *expander, gint spacing); gint gtk_expander_get_spacing (GtkExpander *expander); void gtk_expander_set_label (GtkExpander *expander, gchar *label); gchar *gtk_expander_get_label (GtkExpander *expander); void gtk_expander_set_use_underline (GtkExpander *expander, gboolean use_underline); gboolean gtk_expander_get_use_underline (GtkExpander *expander); void gtk_expander_set_use_markup (GtkExpander *expander, gboolean use_markup); gboolean gtk_expander_get_use_markup (GtkExpander *expander); void gtk_expander_set_label_widget (GtkExpander *expander, GtkWidget *label_widget); GtkWidget *gtk_expander_get_label_widget (GtkExpander *expander); alias _GtkFileSelection GtkFileSelection; alias _GtkFileSelectionClass GtkFileSelectionClass; struct _GtkFileSelection { GtkDialog parent_instance; 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; GPtrArray *selected_names; gchar *last_selected; } struct _GtkFileSelectionClass { GtkDialogClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_file_selection_get_type () ; GtkWidget* gtk_file_selection_new ( gchar *title); void gtk_file_selection_set_filename (GtkFileSelection *filesel, gchar *filename); gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel); void gtk_file_selection_complete (GtkFileSelection *filesel, gchar *pattern); void gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel); void gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel); gchar** gtk_file_selection_get_selections (GtkFileSelection *filesel); void gtk_file_selection_set_select_multiple (GtkFileSelection *filesel, gboolean select_multiple); gboolean gtk_file_selection_get_select_multiple (GtkFileSelection *filesel); alias _GtkFixed GtkFixed; alias _GtkFixedClass GtkFixedClass; alias _GtkFixedChild GtkFixedChild; struct _GtkFixed { GtkContainer container; GList *children; } struct _GtkFixedClass { GtkContainerClass parent_class; } struct _GtkFixedChild { GtkWidget *widget; gint x; gint y; } GType gtk_fixed_get_type () ; GtkWidget* gtk_fixed_new (); void gtk_fixed_put (GtkFixed *fixed, GtkWidget *widget, gint x, gint y); void gtk_fixed_move (GtkFixed *fixed, GtkWidget *widget, gint x, gint y); void gtk_fixed_set_has_window (GtkFixed *fixed, gboolean has_window); gboolean gtk_fixed_get_has_window (GtkFixed *fixed); alias _GtkFileFilter GtkFileFilter; alias void _GtkFileFilter; alias _GtkFileFilterInfo GtkFileFilterInfo; enum GtkFileFilterFlags { GTK_FILE_FILTER_FILENAME = 1 << 0, GTK_FILE_FILTER_URI = 1 << 1, GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2, GTK_FILE_FILTER_MIME_TYPE = 1 << 3 }; alias gboolean (*GtkFileFilterFunc) ( GtkFileFilterInfo *filter_info, gpointer data); struct _GtkFileFilterInfo { GtkFileFilterFlags contains; gchar *filename; gchar *uri; gchar *display_name; gchar *mime_type; } GType gtk_file_filter_get_type (); GtkFileFilter * gtk_file_filter_new (); void gtk_file_filter_set_name (GtkFileFilter *filter, gchar *name); gchar *gtk_file_filter_get_name (GtkFileFilter *filter); void gtk_file_filter_add_mime_type (GtkFileFilter *filter, gchar *mime_type); void gtk_file_filter_add_pattern (GtkFileFilter *filter, gchar *pattern); void gtk_file_filter_add_custom (GtkFileFilter *filter, GtkFileFilterFlags needed, GtkFileFilterFunc func, gpointer data, GDestroyNotify notify); GtkFileFilterFlags gtk_file_filter_get_needed (GtkFileFilter *filter); gboolean gtk_file_filter_filter (GtkFileFilter *filter, GtkFileFilterInfo *filter_info); alias _GtkFileChooser GtkFileChooser; alias void _GtkFileChooser; enum GtkFileChooserAction { GTK_FILE_CHOOSER_ACTION_OPEN, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER }; GType gtk_file_chooser_get_type (); enum GtkFileChooserError { GTK_FILE_CHOOSER_ERROR_NONEXISTENT, GTK_FILE_CHOOSER_ERROR_BAD_FILENAME }; GQuark gtk_file_chooser_error_quark (); void gtk_file_chooser_set_action (GtkFileChooser *chooser, GtkFileChooserAction action); GtkFileChooserAction gtk_file_chooser_get_action (GtkFileChooser *chooser); void gtk_file_chooser_set_local_only (GtkFileChooser *chooser, gboolean local_only); gboolean gtk_file_chooser_get_local_only (GtkFileChooser *chooser); void gtk_file_chooser_set_select_multiple (GtkFileChooser *chooser, gboolean select_multiple); gboolean gtk_file_chooser_get_select_multiple (GtkFileChooser *chooser); void gtk_file_chooser_set_current_name (GtkFileChooser *chooser, gchar *name); gchar * gtk_file_chooser_get_filename (GtkFileChooser *chooser); gboolean gtk_file_chooser_set_filename (GtkFileChooser *chooser, char *filename); gboolean gtk_file_chooser_select_filename (GtkFileChooser *chooser, char *filename); void gtk_file_chooser_unselect_filename (GtkFileChooser *chooser, char *filename); void gtk_file_chooser_select_all (GtkFileChooser *chooser); void gtk_file_chooser_unselect_all (GtkFileChooser *chooser); GSList * gtk_file_chooser_get_filenames (GtkFileChooser *chooser); gboolean gtk_file_chooser_set_current_folder (GtkFileChooser *chooser, gchar *filename); gchar * gtk_file_chooser_get_current_folder (GtkFileChooser *chooser); gchar * gtk_file_chooser_get_uri (GtkFileChooser *chooser); gboolean gtk_file_chooser_set_uri (GtkFileChooser *chooser, char *uri); gboolean gtk_file_chooser_select_uri (GtkFileChooser *chooser, char *uri); void gtk_file_chooser_unselect_uri (GtkFileChooser *chooser, char *uri); GSList * gtk_file_chooser_get_uris (GtkFileChooser *chooser); gboolean gtk_file_chooser_set_current_folder_uri (GtkFileChooser *chooser, gchar *uri); gchar * gtk_file_chooser_get_current_folder_uri (GtkFileChooser *chooser); void gtk_file_chooser_set_preview_widget (GtkFileChooser *chooser, GtkWidget *preview_widget); GtkWidget *gtk_file_chooser_get_preview_widget (GtkFileChooser *chooser); void gtk_file_chooser_set_preview_widget_active (GtkFileChooser *chooser, gboolean active); gboolean gtk_file_chooser_get_preview_widget_active (GtkFileChooser *chooser); void gtk_file_chooser_set_use_preview_label (GtkFileChooser *chooser, gboolean use_label); gboolean gtk_file_chooser_get_use_preview_label (GtkFileChooser *chooser); char *gtk_file_chooser_get_preview_filename (GtkFileChooser *chooser); char *gtk_file_chooser_get_preview_uri (GtkFileChooser *chooser); void gtk_file_chooser_set_extra_widget (GtkFileChooser *chooser, GtkWidget *extra_widget); GtkWidget *gtk_file_chooser_get_extra_widget (GtkFileChooser *chooser); void gtk_file_chooser_add_filter (GtkFileChooser *chooser, GtkFileFilter *filter); void gtk_file_chooser_remove_filter (GtkFileChooser *chooser, GtkFileFilter *filter); GSList *gtk_file_chooser_list_filters (GtkFileChooser *chooser); void gtk_file_chooser_set_filter (GtkFileChooser *chooser, GtkFileFilter *filter); GtkFileFilter *gtk_file_chooser_get_filter (GtkFileChooser *chooser); gboolean gtk_file_chooser_add_shortcut_folder (GtkFileChooser *chooser, char *folder, GError **error); gboolean gtk_file_chooser_remove_shortcut_folder (GtkFileChooser *chooser, char *folder, GError **error); GSList *gtk_file_chooser_list_shortcut_folders (GtkFileChooser *chooser); gboolean gtk_file_chooser_add_shortcut_folder_uri (GtkFileChooser *chooser, char *uri, GError **error); gboolean gtk_file_chooser_remove_shortcut_folder_uri (GtkFileChooser *chooser, char *uri, GError **error); GSList *gtk_file_chooser_list_shortcut_folder_uris (GtkFileChooser *chooser); alias _GtkFileChooserDialog GtkFileChooserDialog; alias _GtkFileChooserDialogClass GtkFileChooserDialogClass; alias _GtkFileChooserDialogPrivate GtkFileChooserDialogPrivate; alias void _GtkFileChooserDialogPrivate; struct _GtkFileChooserDialogClass { GtkDialogClass parent_class; } struct _GtkFileChooserDialog { GtkDialog parent_instance; GtkFileChooserDialogPrivate *priv; } GType gtk_file_chooser_dialog_get_type (); GtkWidget *gtk_file_chooser_dialog_new ( gchar *title, GtkWindow *parent, GtkFileChooserAction action, gchar *first_button_text, ...); GtkWidget *gtk_file_chooser_dialog_new_with_backend ( gchar *title, GtkWindow *parent, GtkFileChooserAction action, gchar *backend, gchar *first_button_text, ...); alias _GtkFileChooserWidget GtkFileChooserWidget; alias _GtkFileChooserWidgetClass GtkFileChooserWidgetClass; alias _GtkFileChooserWidgetPrivate GtkFileChooserWidgetPrivate; alias void _GtkFileChooserWidgetPrivate; struct _GtkFileChooserWidgetClass { GtkVBoxClass parent_class; } struct _GtkFileChooserWidget { GtkVBox parent_instance; GtkFileChooserWidgetPrivate *priv; } GType gtk_file_chooser_widget_get_type (); GtkWidget *gtk_file_chooser_widget_new (GtkFileChooserAction action); GtkWidget *gtk_file_chooser_widget_new_with_backend (GtkFileChooserAction action, gchar *backend); alias _GtkFontButton GtkFontButton; alias _GtkFontButtonClass GtkFontButtonClass; alias _GtkFontButtonPrivate GtkFontButtonPrivate; alias void _GtkFontButtonPrivate; struct _GtkFontButton { GtkButton button; GtkFontButtonPrivate *priv; } struct _GtkFontButtonClass { GtkButtonClass parent_class; void (* font_set) (GtkFontButton *gfp); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_font_button_get_type () ; GtkWidget *gtk_font_button_new (); GtkWidget *gtk_font_button_new_with_font ( gchar *fontname); gchar *gtk_font_button_get_title (GtkFontButton *font_button); void gtk_font_button_set_title (GtkFontButton *font_button, gchar *title); gboolean gtk_font_button_get_use_font (GtkFontButton *font_button); void gtk_font_button_set_use_font (GtkFontButton *font_button, gboolean use_font); gboolean gtk_font_button_get_use_size (GtkFontButton *font_button); void gtk_font_button_set_use_size (GtkFontButton *font_button, gboolean use_size); gchar* gtk_font_button_get_font_name (GtkFontButton *font_button); gboolean gtk_font_button_set_font_name (GtkFontButton *font_button, gchar *fontname); gboolean gtk_font_button_get_show_style (GtkFontButton *font_button); void gtk_font_button_set_show_style (GtkFontButton *font_button, gboolean show_style); gboolean gtk_font_button_get_show_size (GtkFontButton *font_button); void gtk_font_button_set_show_size (GtkFontButton *font_button, gboolean show_size); alias _GtkFontSelection GtkFontSelection; alias _GtkFontSelectionClass GtkFontSelectionClass; alias _GtkFontSelectionDialog GtkFontSelectionDialog; alias _GtkFontSelectionDialogClass GtkFontSelectionDialogClass; struct _GtkFontSelection { GtkVBox parent_instance; GtkWidget *font_entry; GtkWidget *family_list; GtkWidget *font_style_entry; GtkWidget *face_list; GtkWidget *size_entry; GtkWidget *size_list; GtkWidget *pixels_button; GtkWidget *points_button; GtkWidget *filter_button; GtkWidget *preview_entry; PangoFontFamily *family; PangoFontFace *face; gint size; GdkFont *font; } struct _GtkFontSelectionClass { GtkVBoxClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkFontSelectionDialog { GtkDialog parent_instance; 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 { GtkDialogClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_font_selection_get_type () ; GtkWidget* gtk_font_selection_new (); 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, gchar *fontname); gchar* gtk_font_selection_get_preview_text (GtkFontSelection *fontsel); void gtk_font_selection_set_preview_text (GtkFontSelection *fontsel, gchar *text); GType gtk_font_selection_dialog_get_type () ; GtkWidget* gtk_font_selection_dialog_new ( 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, gchar *fontname); gchar* gtk_font_selection_dialog_get_preview_text (GtkFontSelectionDialog *fsd); void gtk_font_selection_dialog_set_preview_text (GtkFontSelectionDialog *fsd, gchar *text); alias _GtkGammaCurve GtkGammaCurve; alias _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; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_gamma_curve_get_type () ; GtkWidget* gtk_gamma_curve_new (); GdkGC* gtk_gc_get (gint depth, GdkColormap *colormap, GdkGCValues *values, GdkGCValuesMask values_mask); void gtk_gc_release (GdkGC *gc); alias _GtkHandleBox GtkHandleBox; alias _GtkHandleBoxClass GtkHandleBoxClass; struct _GtkHandleBox { GtkBin bin; GdkWindow *bin_window; GdkWindow *float_window; GtkShadowType shadow_type; guint handle_position; guint float_window_mapped; guint child_detached; guint in_drag; guint shrink_on_detach; int snap_edge; 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); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_handle_box_get_type () ; GtkWidget* gtk_handle_box_new (); void gtk_handle_box_set_shadow_type (GtkHandleBox *handle_box, GtkShadowType type); GtkShadowType gtk_handle_box_get_shadow_type (GtkHandleBox *handle_box); void gtk_handle_box_set_handle_position (GtkHandleBox *handle_box, GtkPositionType position); GtkPositionType gtk_handle_box_get_handle_position(GtkHandleBox *handle_box); void gtk_handle_box_set_snap_edge (GtkHandleBox *handle_box, GtkPositionType edge); GtkPositionType gtk_handle_box_get_snap_edge (GtkHandleBox *handle_box); alias _GtkHButtonBox GtkHButtonBox; alias _GtkHButtonBoxClass GtkHButtonBoxClass; struct _GtkHButtonBox { GtkButtonBox button_box; } struct _GtkHButtonBoxClass { GtkButtonBoxClass parent_class; } GType gtk_hbutton_box_get_type () ; GtkWidget* gtk_hbutton_box_new (); gint gtk_hbutton_box_get_spacing_default (); GtkButtonBoxStyle gtk_hbutton_box_get_layout_default (); void gtk_hbutton_box_set_spacing_default (gint spacing); void gtk_hbutton_box_set_layout_default (GtkButtonBoxStyle layout); alias _GtkPaned GtkPaned; alias _GtkPanedClass GtkPanedClass; alias _GtkPanedPrivate GtkPanedPrivate; alias void _GtkPanedPrivate; struct _GtkPaned { GtkContainer container; GtkWidget *child1; GtkWidget *child2; GdkWindow *handle; GdkGC *xor_gc; GdkCursorType cursor_type; GdkRectangle handle_pos; gint child1_size; gint last_allocation; gint min_position; gint max_position; guint position_set; guint in_drag; guint child1_shrink; guint child1_resize; guint child2_shrink; guint child2_resize; guint orientation; guint in_recursion; guint handle_prelit; GtkWidget *last_child1_focus; GtkWidget *last_child2_focus; GtkPanedPrivate *priv; gint drag_pos; gint original_position; } struct _GtkPanedClass { GtkContainerClass parent_class; gboolean (* cycle_child_focus) (GtkPaned *paned, gboolean reverse); gboolean (* toggle_handle_focus) (GtkPaned *paned); gboolean (* move_handle) (GtkPaned *paned, GtkScrollType scroll); gboolean (* cycle_handle_focus) (GtkPaned *paned, gboolean reverse); gboolean (* accept_position) (GtkPaned *paned); gboolean (* cancel_position) (GtkPaned *paned); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_paned_get_type () ; 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); gint gtk_paned_get_position (GtkPaned *paned); void gtk_paned_set_position (GtkPaned *paned, gint position); GtkWidget *gtk_paned_get_child1 (GtkPaned *paned); GtkWidget *gtk_paned_get_child2 (GtkPaned *paned); void gtk_paned_compute_position (GtkPaned *paned, gint allocation, gint child1_req, gint child2_req); alias _GtkHPaned GtkHPaned; alias _GtkHPanedClass GtkHPanedClass; struct _GtkHPaned { GtkPaned paned; } struct _GtkHPanedClass { GtkPanedClass parent_class; } GType gtk_hpaned_get_type () ; GtkWidget *gtk_hpaned_new (); alias _GtkRuler GtkRuler; alias _GtkRulerClass GtkRulerClass; alias _GtkRulerMetric GtkRulerMetric; struct _GtkRuler { GtkWidget widget; GdkPixmap *backing_store; GdkGC *non_gr_exp_gc; GtkRulerMetric *metric; gint xsrc, ysrc; gint slider_size; gdouble lower; gdouble upper; gdouble position; gdouble max_size; } struct _GtkRulerClass { GtkWidgetClass parent_class; void (* draw_ticks) (GtkRuler *ruler); void (* draw_pos) (GtkRuler *ruler); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } struct _GtkRulerMetric { gchar *metric_name; gchar *abbrev; gdouble pixels_per_unit; gdouble ruler_scale[10]; gint subdivide[5]; } GType gtk_ruler_get_type () ; void gtk_ruler_set_metric (GtkRuler *ruler, GtkMetricType metric); void gtk_ruler_set_range (GtkRuler *ruler, gdouble lower, gdouble upper, gdouble position, gdouble max_size); void gtk_ruler_draw_ticks (GtkRuler *ruler); void gtk_ruler_draw_pos (GtkRuler *ruler); GtkMetricType gtk_ruler_get_metric (GtkRuler *ruler); void gtk_ruler_get_range (GtkRuler *ruler, gdouble *lower, gdouble *upper, gdouble *position, gdouble *max_size); alias _GtkHRuler GtkHRuler; alias _GtkHRulerClass GtkHRulerClass; struct _GtkHRuler { GtkRuler ruler; } struct _GtkHRulerClass { GtkRulerClass parent_class; } GType gtk_hruler_get_type () ; GtkWidget* gtk_hruler_new (); alias _GtkScale GtkScale; alias _GtkScaleClass GtkScaleClass; struct _GtkScale { GtkRange range; gint digits; guint draw_value; guint value_pos; } struct _GtkScaleClass { GtkRangeClass parent_class; gchar* (* format_value) (GtkScale *scale, gdouble value); void (* draw_value) (GtkScale *scale); void (* get_layout_offsets) (GtkScale *scale, gint *x, gint *y); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_scale_get_type () ; void gtk_scale_set_digits (GtkScale *scale, gint digits); gint gtk_scale_get_digits (GtkScale *scale); void gtk_scale_set_draw_value (GtkScale *scale, gboolean draw_value); gboolean gtk_scale_get_draw_value (GtkScale *scale); void gtk_scale_set_value_pos (GtkScale *scale, GtkPositionType pos); GtkPositionType gtk_scale_get_value_pos (GtkScale *scale); PangoLayout *gtk_scale_get_layout (GtkScale *scale); void gtk_scale_get_layout_offsets (GtkScale *scale, gint *x, gint *y); void _gtk_scale_clear_layout (GtkScale *scale); void _gtk_scale_get_value_size (GtkScale *scale, gint *width, gint *height); gchar *_gtk_scale_format_value (GtkScale *scale, gdouble value); alias _GtkHScale GtkHScale; alias _GtkHScaleClass GtkHScaleClass; struct _GtkHScale { GtkScale scale; } struct _GtkHScaleClass { GtkScaleClass parent_class; } GType gtk_hscale_get_type () ; GtkWidget* gtk_hscale_new (GtkAdjustment *adjustment); GtkWidget* gtk_hscale_new_with_range (gdouble min, gdouble max, gdouble step); alias _GtkSeparator GtkSeparator; alias _GtkSeparatorClass GtkSeparatorClass; struct _GtkSeparator { GtkWidget widget; } struct _GtkSeparatorClass { GtkWidgetClass parent_class; } GType gtk_separator_get_type () ; alias _GtkHSeparator GtkHSeparator; alias _GtkHSeparatorClass GtkHSeparatorClass; struct _GtkHSeparator { GtkSeparator separator; } struct _GtkHSeparatorClass { GtkSeparatorClass parent_class; } GType gtk_hseparator_get_type () ; GtkWidget* gtk_hseparator_new (); alias _GtkIconFactoryClass GtkIconFactoryClass; struct _GtkIconFactory { GObject parent_instance; GHashTable *icons; } struct _GtkIconFactoryClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_icon_factory_get_type (); GtkIconFactory* gtk_icon_factory_new (); void gtk_icon_factory_add (GtkIconFactory *factory, gchar *stock_id, GtkIconSet *icon_set); GtkIconSet* gtk_icon_factory_lookup (GtkIconFactory *factory, gchar *stock_id); void gtk_icon_factory_add_default (GtkIconFactory *factory); void gtk_icon_factory_remove_default (GtkIconFactory *factory); GtkIconSet* gtk_icon_factory_lookup_default ( gchar *stock_id); gboolean gtk_icon_size_lookup (GtkIconSize size, gint *width, gint *height); gboolean gtk_icon_size_lookup_for_settings (GtkSettings *settings, GtkIconSize size, gint *width, gint *height); GtkIconSize gtk_icon_size_register ( gchar *name, gint width, gint height); void gtk_icon_size_register_alias ( gchar *Alias, GtkIconSize target); GtkIconSize gtk_icon_size_from_name ( gchar *name); gchar* gtk_icon_size_get_name (GtkIconSize size); GType gtk_icon_set_get_type (); GtkIconSet* gtk_icon_set_new (); GtkIconSet* gtk_icon_set_new_from_pixbuf (GdkPixbuf *pixbuf); GtkIconSet* gtk_icon_set_ref (GtkIconSet *icon_set); void gtk_icon_set_unref (GtkIconSet *icon_set); GtkIconSet* gtk_icon_set_copy (GtkIconSet *icon_set); GdkPixbuf* gtk_icon_set_render_icon (GtkIconSet *icon_set, GtkStyle *style, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget, char *detail); void gtk_icon_set_add_source (GtkIconSet *icon_set, GtkIconSource *source); void gtk_icon_set_get_sizes (GtkIconSet *icon_set, GtkIconSize **sizes, gint *n_sizes); GType gtk_icon_source_get_type (); GtkIconSource* gtk_icon_source_new (); GtkIconSource* gtk_icon_source_copy ( GtkIconSource *source); void gtk_icon_source_free (GtkIconSource *source); void gtk_icon_source_set_filename (GtkIconSource *source, gchar *filename); void gtk_icon_source_set_icon_name (GtkIconSource *source, gchar *icon_name); void gtk_icon_source_set_pixbuf (GtkIconSource *source, GdkPixbuf *pixbuf); gchar* gtk_icon_source_get_filename ( GtkIconSource *source); gchar* gtk_icon_source_get_icon_name ( GtkIconSource *source); GdkPixbuf* gtk_icon_source_get_pixbuf ( GtkIconSource *source); void gtk_icon_source_set_direction_wildcarded (GtkIconSource *source, gboolean setting); void gtk_icon_source_set_state_wildcarded (GtkIconSource *source, gboolean setting); void gtk_icon_source_set_size_wildcarded (GtkIconSource *source, gboolean setting); gboolean gtk_icon_source_get_size_wildcarded ( GtkIconSource *source); gboolean gtk_icon_source_get_state_wildcarded ( GtkIconSource *source); gboolean gtk_icon_source_get_direction_wildcarded ( GtkIconSource *source); void gtk_icon_source_set_direction (GtkIconSource *source, GtkTextDirection direction); void gtk_icon_source_set_state (GtkIconSource *source, GtkStateType state); void gtk_icon_source_set_size (GtkIconSource *source, GtkIconSize size); GtkTextDirection gtk_icon_source_get_direction ( GtkIconSource *source); GtkStateType gtk_icon_source_get_state ( GtkIconSource *source); GtkIconSize gtk_icon_source_get_size ( GtkIconSource *source); void _gtk_icon_set_invalidate_caches (); GSList* _gtk_icon_factory_list_ids (); alias _GtkIconInfo GtkIconInfo; alias void _GtkIconInfo; alias _GtkIconTheme GtkIconTheme; alias _GtkIconThemeClass GtkIconThemeClass; alias _GtkIconThemePrivate GtkIconThemePrivate; alias void _GtkIconThemePrivate; struct _GtkIconTheme { GObject parent_instance; GtkIconThemePrivate *priv; } struct _GtkIconThemeClass { GObjectClass parent_class; void (* changed) (GtkIconTheme *icon_theme); } enum GtkIconLookupFlags { GTK_ICON_LOOKUP_NO_SVG = 1 << 0, GTK_ICON_LOOKUP_FORCE_SVG = 1 << 1, GTK_ICON_LOOKUP_USE_BUILTIN = 1 << 2 }; enum GtkIconThemeError { GTK_ICON_THEME_NOT_FOUND, GTK_ICON_THEME_FAILED }; GQuark gtk_icon_theme_error_quark () ; GType gtk_icon_theme_get_type () ; GtkIconTheme *gtk_icon_theme_new (); GtkIconTheme *gtk_icon_theme_get_default (); GtkIconTheme *gtk_icon_theme_get_for_screen (GdkScreen *screen); void gtk_icon_theme_set_screen (GtkIconTheme *icon_theme, GdkScreen *screen); void gtk_icon_theme_set_search_path (GtkIconTheme *icon_theme, gchar *path[], gint n_elements); void gtk_icon_theme_get_search_path (GtkIconTheme *icon_theme, gchar **path[], gint *n_elements); void gtk_icon_theme_append_search_path (GtkIconTheme *icon_theme, gchar *path); void gtk_icon_theme_prepend_search_path (GtkIconTheme *icon_theme, gchar *path); void gtk_icon_theme_set_custom_theme (GtkIconTheme *icon_theme, gchar *theme_name); gboolean gtk_icon_theme_has_icon (GtkIconTheme *icon_theme, gchar *icon_name); GtkIconInfo * gtk_icon_theme_lookup_icon (GtkIconTheme *icon_theme, gchar *icon_name, gint size, GtkIconLookupFlags flags); GdkPixbuf * gtk_icon_theme_load_icon (GtkIconTheme *icon_theme, gchar *icon_name, gint size, GtkIconLookupFlags flags, GError **error); GList * gtk_icon_theme_list_icons (GtkIconTheme *icon_theme, gchar *context); char * gtk_icon_theme_get_example_icon_name (GtkIconTheme *icon_theme); gboolean gtk_icon_theme_rescan_if_needed (GtkIconTheme *icon_theme); void gtk_icon_theme_add_builtin_icon ( gchar *icon_name, gint size, GdkPixbuf *pixbuf); GType gtk_icon_info_get_type (); GtkIconInfo *gtk_icon_info_copy (GtkIconInfo *icon_info); void gtk_icon_info_free (GtkIconInfo *icon_info); gint gtk_icon_info_get_base_size (GtkIconInfo *icon_info); gchar *gtk_icon_info_get_filename (GtkIconInfo *icon_info); GdkPixbuf * gtk_icon_info_get_builtin_pixbuf (GtkIconInfo *icon_info); GdkPixbuf * gtk_icon_info_load_icon (GtkIconInfo *icon_info, GError **error); void gtk_icon_info_set_raw_coordinates (GtkIconInfo *icon_info, gboolean raw_coordinates); gboolean gtk_icon_info_get_embedded_rect (GtkIconInfo *icon_info, GdkRectangle *rectangle); gboolean gtk_icon_info_get_attach_points (GtkIconInfo *icon_info, GdkPoint **points, gint *n_points); gchar *gtk_icon_info_get_display_name (GtkIconInfo *icon_info); alias _GtkImage GtkImage; alias _GtkImageClass GtkImageClass; alias _GtkImagePixmapData GtkImagePixmapData; alias _GtkImageImageData GtkImageImageData; alias _GtkImagePixbufData GtkImagePixbufData; alias _GtkImageStockData GtkImageStockData; alias _GtkImageIconSetData GtkImageIconSetData; alias _GtkImageAnimationData GtkImageAnimationData; struct _GtkImagePixmapData { GdkPixmap *pixmap; } struct _GtkImageImageData { GdkImage *image; } struct _GtkImagePixbufData { GdkPixbuf *pixbuf; } struct _GtkImageStockData { gchar *stock_id; } struct _GtkImageIconSetData { GtkIconSet *icon_set; } struct _GtkImageAnimationData { GdkPixbufAnimation *anim; GdkPixbufAnimationIter *iter; guint frame_timeout; } enum GtkImageType { GTK_IMAGE_EMPTY, GTK_IMAGE_PIXMAP, GTK_IMAGE_IMAGE, GTK_IMAGE_PIXBUF, GTK_IMAGE_STOCK, GTK_IMAGE_ICON_SET, GTK_IMAGE_ANIMATION }; struct _GtkImage { GtkMisc misc; GtkImageType storage_type; union data_union { GtkImagePixmapData pixmap; GtkImageImageData image; GtkImagePixbufData pixbuf; GtkImageStockData stock; GtkImageIconSetData icon_set; GtkImageAnimationData anim; } data_union data; GdkBitmap *mask; GtkIconSize icon_size; } struct _GtkImageClass { GtkMiscClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_image_get_type () ; GtkWidget* gtk_image_new (); GtkWidget* gtk_image_new_from_pixmap (GdkPixmap *pixmap, GdkBitmap *mask); GtkWidget* gtk_image_new_from_image (GdkImage *image, GdkBitmap *mask); GtkWidget* gtk_image_new_from_file ( gchar *filename); GtkWidget* gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf); GtkWidget* gtk_image_new_from_stock ( gchar *stock_id, GtkIconSize size); GtkWidget* gtk_image_new_from_icon_set (GtkIconSet *icon_set, GtkIconSize size); GtkWidget* gtk_image_new_from_animation (GdkPixbufAnimation *animation); void gtk_image_set_from_pixmap (GtkImage *image, GdkPixmap *pixmap, GdkBitmap *mask); void gtk_image_set_from_image (GtkImage *image, GdkImage *gdk_image, GdkBitmap *mask); void gtk_image_set_from_file (GtkImage *image, gchar *filename); void gtk_image_set_from_pixbuf (GtkImage *image, GdkPixbuf *pixbuf); void gtk_image_set_from_stock (GtkImage *image, gchar *stock_id, GtkIconSize size); void gtk_image_set_from_icon_set (GtkImage *image, GtkIconSet *icon_set, GtkIconSize size); void gtk_image_set_from_animation (GtkImage *image, GdkPixbufAnimation *animation); GtkImageType gtk_image_get_storage_type (GtkImage *image); void gtk_image_get_pixmap (GtkImage *image, GdkPixmap **pixmap, GdkBitmap **mask); void gtk_image_get_image (GtkImage *image, GdkImage **gdk_image, GdkBitmap **mask); GdkPixbuf* gtk_image_get_pixbuf (GtkImage *image); void gtk_image_get_stock (GtkImage *image, gchar **stock_id, GtkIconSize *size); void gtk_image_get_icon_set (GtkImage *image, GtkIconSet **icon_set, GtkIconSize *size); GdkPixbufAnimation* gtk_image_get_animation (GtkImage *image); void gtk_image_set (GtkImage *image, GdkImage *val, GdkBitmap *mask); void gtk_image_get (GtkImage *image, GdkImage **val, GdkBitmap **mask); alias _GtkImageMenuItem GtkImageMenuItem; alias _GtkImageMenuItemClass GtkImageMenuItemClass; struct _GtkImageMenuItem { GtkMenuItem menu_item; GtkWidget *image; } struct _GtkImageMenuItemClass { GtkMenuItemClass parent_class; } GType gtk_image_menu_item_get_type () ; GtkWidget* gtk_image_menu_item_new (); GtkWidget* gtk_image_menu_item_new_with_label ( gchar *label); GtkWidget* gtk_image_menu_item_new_with_mnemonic ( gchar *label); GtkWidget* gtk_image_menu_item_new_from_stock ( gchar *stock_id, GtkAccelGroup *accel_group); void gtk_image_menu_item_set_image (GtkImageMenuItem *image_menu_item, GtkWidget *image); GtkWidget* gtk_image_menu_item_get_image (GtkImageMenuItem *image_menu_item); alias _GtkIMContextSimple GtkIMContextSimple; alias _GtkIMContextSimpleClass GtkIMContextSimpleClass; struct _GtkIMContextSimple { GtkIMContext object; GSList *tables; guint compose_buffer[7 + 1]; gunichar tentative_match; gint tentative_match_len; guint in_hex_sequence; } struct _GtkIMContextSimpleClass { GtkIMContextClass parent_class; } GType gtk_im_context_simple_get_type () ; GtkIMContext *gtk_im_context_simple_new (); void gtk_im_context_simple_add_table (GtkIMContextSimple *context_simple, guint16 *data, gint max_seq_len, gint n_seqs); alias _GtkIMMulticontext GtkIMMulticontext; alias _GtkIMMulticontextClass GtkIMMulticontextClass; alias _GtkIMMulticontextPrivate GtkIMMulticontextPrivate; alias void _GtkIMMulticontextPrivate; struct _GtkIMMulticontext { GtkIMContext object; GtkIMContext *slave; GtkIMMulticontextPrivate *priv; gchar *context_id; } struct _GtkIMMulticontextClass { GtkIMContextClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_im_multicontext_get_type () ; GtkIMContext *gtk_im_multicontext_new (); void gtk_im_multicontext_append_menuitems (GtkIMMulticontext *context, GtkMenuShell *menushell); alias _GtkInputDialog GtkInputDialog; alias _GtkInputDialogClass GtkInputDialogClass; struct _GtkInputDialog { GtkDialog dialog; GtkWidget *axis_list; GtkWidget *axis_listbox; GtkWidget *mode_optionmenu; GtkWidget *close_button; GtkWidget *save_button; GtkWidget *axis_items[GdkAxisUse.GDK_AXIS_LAST]; GdkDevice *current_device; GtkWidget *keys_list; GtkWidget *keys_listbox; } struct _GtkInputDialogClass { GtkDialogClass parent_class; void (* enable_device) (GtkInputDialog *inputd, GdkDevice *device); void (* disable_device) (GtkInputDialog *inputd, GdkDevice *device); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_input_dialog_get_type () ; GtkWidget* gtk_input_dialog_new (); alias _GtkInvisible GtkInvisible; alias _GtkInvisibleClass GtkInvisibleClass; struct _GtkInvisible { GtkWidget widget; gboolean has_user_ref_count; GdkScreen *screen; } struct _GtkInvisibleClass { GtkWidgetClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_invisible_get_type () ; GtkWidget* gtk_invisible_new (); GtkWidget* gtk_invisible_new_for_screen (GdkScreen *screen); void gtk_invisible_set_screen (GtkInvisible *invisible, GdkScreen *screen); GdkScreen* gtk_invisible_get_screen (GtkInvisible *invisible); alias _GtkLayout GtkLayout; alias _GtkLayoutClass GtkLayoutClass; struct _GtkLayout { GtkContainer container; GList *children; guint width; guint height; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; GdkWindow *bin_window; GdkVisibilityState visibility; gint scroll_x; gint scroll_y; guint freeze_count; } struct _GtkLayoutClass { GtkContainerClass parent_class; void (*set_scroll_adjustments) (GtkLayout *layout, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_layout_get_type () ; GtkWidget* gtk_layout_new (GtkAdjustment *hadjustment, GtkAdjustment *vadjustment); void gtk_layout_put (GtkLayout *layout, GtkWidget *child_widget, gint x, gint y); void gtk_layout_move (GtkLayout *layout, GtkWidget *child_widget, gint x, gint y); void gtk_layout_set_size (GtkLayout *layout, guint width, guint height); void gtk_layout_get_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); void gtk_layout_freeze (GtkLayout *layout); void gtk_layout_thaw (GtkLayout *layout); alias _GtkListItem GtkListItem; alias _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 () ; GtkWidget* gtk_list_item_new (); GtkWidget* gtk_list_item_new_with_label ( gchar *label); void gtk_list_item_select (GtkListItem *list_item); void gtk_list_item_deselect (GtkListItem *list_item); alias _GtkList GtkList; alias _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; guint drag_selection; guint add_mode; } 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 () ; GtkWidget* gtk_list_new (); 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); alias void (*GtkModuleInitFunc) (gint *argc, gchar ***argv); alias void (*GtkModuleDisplayInitFunc) (GdkDisplay *display); alias gint (*GtkKeySnoopFunc) (GtkWidget *grab_widget, GdkEventKey *event, gpointer func_data); guint gtk_major_version; guint gtk_minor_version; guint gtk_micro_version; guint gtk_binary_age; guint gtk_interface_age; gchar* gtk_check_version (guint required_major, guint required_minor, guint required_micro); gboolean gtk_parse_args (int *argc, char ***argv); void gtk_init (int *argc, char ***argv); gboolean gtk_init_check (int *argc, char ***argv); void gtk_exit (gint error_code); void gtk_disable_setlocale (); gchar * gtk_set_locale (); PangoLanguage *gtk_get_default_language (); gboolean gtk_events_pending (); void gtk_main_do_event (GdkEvent *event); void gtk_main (); guint gtk_main_level (); void gtk_main_quit (); gboolean gtk_main_iteration (); gboolean gtk_main_iteration_do (gboolean blocking); gboolean gtk_true () ; gboolean gtk_false () ; void gtk_grab_add (GtkWidget *widget); GtkWidget* gtk_grab_get_current (); 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 (); guint32 gtk_get_current_event_time (); gboolean gtk_get_current_event_state (GdkModifierType *state); GtkWidget* gtk_get_event_widget (GdkEvent *event); void gtk_propagate_event (GtkWidget *widget, GdkEvent *event); gboolean _gtk_boolean_handled_accumulator (GSignalInvocationHint *ihint, GValue *return_accu, GValue *handler_return, gpointer dummy); gchar * _gtk_find_module ( gchar *name, gchar *type); gchar **_gtk_get_module_path ( gchar *type); gchar *_gtk_get_lc_ctype (); alias _GtkMenuBar GtkMenuBar; alias _GtkMenuBarClass GtkMenuBarClass; struct _GtkMenuBar { GtkMenuShell menu_shell; } struct _GtkMenuBarClass { GtkMenuShellClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_menu_bar_get_type () ; GtkWidget* gtk_menu_bar_new (); void _gtk_menu_bar_cycle_focus (GtkMenuBar *menubar, GtkDirectionType dir); enum GtkMessageType { GTK_MESSAGE_INFO, GTK_MESSAGE_WARNING, GTK_MESSAGE_QUESTION, GTK_MESSAGE_ERROR }; enum GtkButtonsType { GTK_BUTTONS_NONE, GTK_BUTTONS_OK, GTK_BUTTONS_CLOSE, GTK_BUTTONS_CANCEL, GTK_BUTTONS_YES_NO, GTK_BUTTONS_OK_CANCEL }; alias _GtkMessageDialog GtkMessageDialog; alias _GtkMessageDialogClass GtkMessageDialogClass; struct _GtkMessageDialog { GtkDialog parent_instance; GtkWidget *image; GtkWidget *label; } struct _GtkMessageDialogClass { GtkDialogClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_message_dialog_get_type (); GtkWidget* gtk_message_dialog_new (GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, gchar *message_format, ...) ; GtkWidget* gtk_message_dialog_new_with_markup (GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, gchar *message_format, ...) ; void gtk_message_dialog_set_markup (GtkMessageDialog *message_dialog, gchar *str); enum GtkNotebookTab { GTK_NOTEBOOK_TAB_FIRST, GTK_NOTEBOOK_TAB_LAST }; alias _GtkNotebook GtkNotebook; alias _GtkNotebookClass GtkNotebookClass; alias _GtkNotebookPage GtkNotebookPage; alias void _GtkNotebookPage; struct _GtkNotebook { GtkContainer container; GtkNotebookPage *cur_page; GList *children; GList *first_tab; GList *focus_tab; GtkWidget *menu; GdkWindow *event_window; guint32 timer; guint16 tab_hborder; guint16 tab_vborder; guint show_tabs; guint homogeneous; guint show_border; guint tab_pos; guint scrollable; guint in_child; guint click_child; guint button; guint need_timer; guint child_has_focus; guint have_visible_child; guint focus_out; guint has_before_previous; guint has_before_next; guint has_after_previous; guint has_after_next; } struct _GtkNotebookClass { GtkContainerClass parent_class; void (* switch_page) (GtkNotebook *notebook, GtkNotebookPage *page, guint page_num); gboolean (* select_page) (GtkNotebook *notebook, gboolean move_focus); gboolean (* focus_tab) (GtkNotebook *notebook, GtkNotebookTab type); void (* change_current_page) (GtkNotebook *notebook, gint offset); void (* move_focus_out) (GtkNotebook *notebook, GtkDirectionType direction); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_notebook_get_type () ; GtkWidget * gtk_notebook_new (); gint gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label); gint gtk_notebook_append_page_menu (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label); gint gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label); gint gtk_notebook_prepend_page_menu (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label); gint gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, gint position); gint 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_get_n_pages (GtkNotebook *notebook); gint gtk_notebook_page_num (GtkNotebook *notebook, GtkWidget *child); void gtk_notebook_set_current_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); gboolean gtk_notebook_get_show_border (GtkNotebook *notebook); void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gboolean show_tabs); gboolean gtk_notebook_get_show_tabs (GtkNotebook *notebook); void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos); GtkPositionType gtk_notebook_get_tab_pos (GtkNotebook *notebook); 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); gboolean gtk_notebook_get_scrollable (GtkNotebook *notebook); 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, gchar *tab_text); gchar *gtk_notebook_get_tab_label_text (GtkNotebook *notebook, GtkWidget *child); 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, gchar *menu_text); gchar *gtk_notebook_get_menu_label_text (GtkNotebook *notebook, GtkWidget *child); 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); alias _GtkOldEditable GtkOldEditable; alias _GtkOldEditableClass GtkOldEditableClass; alias void (*GtkTextFunction) (GtkOldEditable *editable, guint32 time_); struct _GtkOldEditable { GtkWidget widget; guint current_pos; guint selection_start_pos; guint selection_end_pos; guint has_selection; guint editable; guint visible; gchar *clipboard_text; } struct _GtkOldEditableClass { GtkWidgetClass parent_class; void (* activate) (GtkOldEditable *editable); void (* set_editable) (GtkOldEditable *editable, gboolean is_editable); void (* move_cursor) (GtkOldEditable *editable, gint x, gint y); void (* move_word) (GtkOldEditable *editable, gint n); void (* move_page) (GtkOldEditable *editable, gint x, gint y); void (* move_to_row) (GtkOldEditable *editable, gint row); void (* move_to_column) (GtkOldEditable *editable, gint row); void (* kill_char) (GtkOldEditable *editable, gint direction); void (* kill_word) (GtkOldEditable *editable, gint direction); void (* kill_line) (GtkOldEditable *editable, gint direction); void (* cut_clipboard) (GtkOldEditable *editable); void (* copy_clipboard) (GtkOldEditable *editable); void (* paste_clipboard) (GtkOldEditable *editable); void (* update_text) (GtkOldEditable *editable, gint start_pos, gint end_pos); gchar* (* get_chars) (GtkOldEditable *editable, gint start_pos, gint end_pos); void (* set_selection)(GtkOldEditable *editable, gint start_pos, gint end_pos); void (* set_position) (GtkOldEditable *editable, gint position); } GtkType gtk_old_editable_get_type () ; void gtk_old_editable_claim_selection (GtkOldEditable *old_editable, gboolean claim, guint32 time_); void gtk_old_editable_changed (GtkOldEditable *old_editable); alias _GtkOptionMenu GtkOptionMenu; alias _GtkOptionMenuClass GtkOptionMenuClass; struct _GtkOptionMenu { GtkButton button; GtkWidget *menu; GtkWidget *menu_item; guint16 width; guint16 height; } struct _GtkOptionMenuClass { GtkButtonClass parent_class; void (*changed) (GtkOptionMenu *option_menu); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_option_menu_get_type () ; GtkWidget* gtk_option_menu_new (); 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); gint gtk_option_menu_get_history (GtkOptionMenu *option_menu); void gtk_option_menu_set_history (GtkOptionMenu *option_menu, guint index_); alias _GtkPixmap GtkPixmap; alias _GtkPixmapClass GtkPixmapClass; struct _GtkPixmap { GtkMisc misc; GdkPixmap *pixmap; GdkBitmap *mask; GdkPixmap *pixmap_insensitive; guint build_insensitive; } struct _GtkPixmapClass { GtkMiscClass parent_class; } GtkType gtk_pixmap_get_type () ; 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, gboolean build); alias _GtkSocket GtkSocket; alias _GtkSocketClass GtkSocketClass; struct _GtkSocket { GtkContainer container; guint16 request_width; guint16 request_height; guint16 current_width; guint16 current_height; GdkWindow *plug_window; GtkWidget *plug_widget; gshort xembed_version; guint same_app; guint focus_in; guint have_size; guint need_map; guint is_mapped; guint active; GtkAccelGroup *accel_group; GtkWidget *toplevel; } struct _GtkSocketClass { GtkContainerClass parent_class; void (*plug_added) (GtkSocket *socket_); gboolean (*plug_removed) (GtkSocket *socket_); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_socket_get_type () ; GtkWidget* gtk_socket_new (); void gtk_socket_add_id (GtkSocket *socket_, GdkNativeWindow window_id); GdkNativeWindow gtk_socket_get_id (GtkSocket *socket_); void gtk_socket_steal (GtkSocket *socket_, GdkNativeWindow wid); alias _GtkPlug GtkPlug; alias _GtkPlugClass GtkPlugClass; struct _GtkPlug { GtkWindow window; GdkWindow *socket_window; GtkWidget *modality_window; GtkWindowGroup *modality_group; GHashTable *grabbed_keys; guint same_app; } struct _GtkPlugClass { GtkWindowClass parent_class; void (*embedded) (GtkPlug *plug); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_plug_get_type () ; void gtk_plug_ruct (GtkPlug *plug, GdkNativeWindow socket_id); GtkWidget* gtk_plug_new (GdkNativeWindow socket_id); void gtk_plug_ruct_for_display (GtkPlug *plug, GdkDisplay *display, GdkNativeWindow socket_id); GtkWidget* gtk_plug_new_for_display (GdkDisplay *display, GdkNativeWindow socket_id); GdkNativeWindow gtk_plug_get_id (GtkPlug *plug); void _gtk_plug_add_to_socket (GtkPlug *plug, GtkSocket *socket_); void _gtk_plug_remove_from_socket (GtkPlug *plug, GtkSocket *socket_); alias _GtkPreview GtkPreview; alias _GtkPreviewInfo GtkPreviewInfo; alias _GtkDitherInfo GtkDitherInfo; alias _GtkPreviewClass GtkPreviewClass; struct _GtkPreview { GtkWidget widget; guchar *buffer; guint16 buffer_width; guint16 buffer_height; guint16 bpp; guint16 rowstride; GdkRgbDither dither; guint type; guint expand; } struct _GtkPreviewInfo { 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 gtk_preview_uninit (); 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 (); GdkColormap* gtk_preview_get_cmap (); GtkPreviewInfo* gtk_preview_get_info (); void gtk_preview_reset (); alias _GtkProgress GtkProgress; alias _GtkProgressClass GtkProgressClass; struct _GtkProgress { GtkWidget widget; GtkAdjustment *adjustment; GdkPixmap *offscreen_pixmap; gchar *format; gfloat x_align; gfloat y_align; guint show_text; guint activity_mode; guint use_text_format; } struct _GtkProgressClass { GtkWidgetClass parent_class; void (* paint) (GtkProgress *progress); void (* update) (GtkProgress *progress); void (* act_mode_enter) (GtkProgress *progress); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_progress_get_type () ; void gtk_progress_set_show_text (GtkProgress *progress, gboolean show_text); void gtk_progress_set_text_alignment (GtkProgress *progress, gfloat x_align, gfloat y_align); void gtk_progress_set_format_string (GtkProgress *progress, gchar *format); void gtk_progress_set_adjustment (GtkProgress *progress, GtkAdjustment *adjustment); void gtk_progress_configure (GtkProgress *progress, gdouble value, gdouble min, gdouble max); void gtk_progress_set_percentage (GtkProgress *progress, gdouble percentage); void gtk_progress_set_value (GtkProgress *progress, gdouble value); gdouble gtk_progress_get_value (GtkProgress *progress); void gtk_progress_set_activity_mode (GtkProgress *progress, gboolean activity_mode); gchar* gtk_progress_get_current_text (GtkProgress *progress); gchar* gtk_progress_get_text_from_value (GtkProgress *progress, gdouble value); gdouble gtk_progress_get_current_percentage (GtkProgress *progress); gdouble gtk_progress_get_percentage_from_value (GtkProgress *progress, gdouble value); alias _GtkProgressBar GtkProgressBar; alias _GtkProgressBarClass GtkProgressBarClass; enum GtkProgressBarStyle { GTK_PROGRESS_CONTINUOUS, GTK_PROGRESS_DISCRETE }; enum GtkProgressBarOrientation { GTK_PROGRESS_LEFT_TO_RIGHT, GTK_PROGRESS_RIGHT_TO_LEFT, GTK_PROGRESS_BOTTOM_TO_TOP, GTK_PROGRESS_TOP_TO_BOTTOM }; struct _GtkProgressBar { GtkProgress progress; GtkProgressBarStyle bar_style; GtkProgressBarOrientation orientation; guint blocks; gint in_block; gint activity_pos; guint activity_step; guint activity_blocks; gdouble pulse_fraction; guint activity_dir; } struct _GtkProgressBarClass { GtkProgressClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_progress_bar_get_type () ; GtkWidget* gtk_progress_bar_new (); void gtk_progress_bar_pulse (GtkProgressBar *pbar); void gtk_progress_bar_set_text (GtkProgressBar *pbar, gchar *text); void gtk_progress_bar_set_fraction (GtkProgressBar *pbar, gdouble fraction); void gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar, gdouble fraction); void gtk_progress_bar_set_orientation (GtkProgressBar *pbar, GtkProgressBarOrientation orientation); gchar* gtk_progress_bar_get_text (GtkProgressBar *pbar); gdouble gtk_progress_bar_get_fraction (GtkProgressBar *pbar); gdouble gtk_progress_bar_get_pulse_step (GtkProgressBar *pbar); GtkProgressBarOrientation gtk_progress_bar_get_orientation (GtkProgressBar *pbar); 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_update (GtkProgressBar *pbar, gdouble percentage); alias _GtkToggleAction GtkToggleAction; alias _GtkToggleActionPrivate GtkToggleActionPrivate; alias void _GtkToggleActionPrivate; alias _GtkToggleActionClass GtkToggleActionClass; struct _GtkToggleAction { GtkAction parent; GtkToggleActionPrivate *private_data; } struct _GtkToggleActionClass { GtkActionClass parent_class; void (* toggled) (GtkToggleAction *action); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_toggle_action_get_type (); GtkToggleAction *gtk_toggle_action_new ( gchar *name, gchar *label, gchar *tooltip, gchar *stock_id); void gtk_toggle_action_toggled (GtkToggleAction *action); void gtk_toggle_action_set_active (GtkToggleAction *action, gboolean is_active); gboolean gtk_toggle_action_get_active (GtkToggleAction *action); void gtk_toggle_action_set_draw_as_radio (GtkToggleAction *action, gboolean draw_as_radio); gboolean gtk_toggle_action_get_draw_as_radio (GtkToggleAction *action); alias _GtkRadioAction GtkRadioAction; alias _GtkRadioActionPrivate GtkRadioActionPrivate; alias void _GtkRadioActionPrivate; alias _GtkRadioActionClass GtkRadioActionClass; struct _GtkRadioAction { GtkToggleAction parent; GtkRadioActionPrivate *private_data; } struct _GtkRadioActionClass { GtkToggleActionClass parent_class; void (* changed) (GtkRadioAction *action, GtkRadioAction *current); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_radio_action_get_type (); GtkRadioAction *gtk_radio_action_new ( gchar *name, gchar *label, gchar *tooltip, gchar *stock_id, gint value); GSList *gtk_radio_action_get_group (GtkRadioAction *action); void gtk_radio_action_set_group (GtkRadioAction *action, GSList *group); gint gtk_radio_action_get_current_value (GtkRadioAction *action); alias _GtkRadioButton GtkRadioButton; alias _GtkRadioButtonClass GtkRadioButtonClass; struct _GtkRadioButton { GtkCheckButton check_button; GSList *group; } struct _GtkRadioButtonClass { GtkCheckButtonClass parent_class; void (*group_changed) (GtkRadioButton *radio_button); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_radio_button_get_type () ; 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, gchar *label); GtkWidget* gtk_radio_button_new_with_label_from_widget (GtkRadioButton *group, gchar *label); GtkWidget* gtk_radio_button_new_with_mnemonic (GSList *group, gchar *label); GtkWidget* gtk_radio_button_new_with_mnemonic_from_widget (GtkRadioButton *group, gchar *label); GSList* gtk_radio_button_get_group (GtkRadioButton *radio_button); void gtk_radio_button_set_group (GtkRadioButton *radio_button, GSList *group); alias _GtkRadioMenuItem GtkRadioMenuItem; alias _GtkRadioMenuItemClass GtkRadioMenuItemClass; struct _GtkRadioMenuItem { GtkCheckMenuItem check_menu_item; GSList *group; } struct _GtkRadioMenuItemClass { GtkCheckMenuItemClass parent_class; void (*group_changed) (GtkRadioMenuItem *radio_menu_item); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_radio_menu_item_get_type () ; GtkWidget* gtk_radio_menu_item_new (GSList *group); GtkWidget* gtk_radio_menu_item_new_with_label (GSList *group, gchar *label); GtkWidget* gtk_radio_menu_item_new_with_mnemonic (GSList *group, gchar *label); GtkWidget* gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group); GtkWidget *gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group, gchar *label); GtkWidget *gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group, gchar *label); GSList* gtk_radio_menu_item_get_group (GtkRadioMenuItem *radio_menu_item); void gtk_radio_menu_item_set_group (GtkRadioMenuItem *radio_menu_item, GSList *group); alias _GtkTooltips GtkTooltips; alias _GtkTooltipsClass GtkTooltipsClass; alias _GtkTooltipsData GtkTooltipsData; struct _GtkTooltipsData { GtkTooltips *tooltips; GtkWidget *widget; gchar *tip_text; gchar *tip_private; } struct _GtkTooltips { GtkObject parent_instance; GtkWidget *tip_window; GtkWidget *tip_label; GtkTooltipsData *active_tips_data; GList *tips_data_list; guint delay; guint enabled; guint have_grab; guint use_sticky_delay; gint timer_tag; GTimeVal last_popdown; } struct _GtkTooltipsClass { GtkObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tooltips_get_type () ; GtkTooltips* gtk_tooltips_new (); 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, gchar *tip_text, gchar *tip_private); GtkTooltipsData* gtk_tooltips_data_get (GtkWidget *widget); void gtk_tooltips_force_window (GtkTooltips *tooltips); void _gtk_tooltips_toggle_keyboard_mode (GtkWidget *widget); gboolean gtk_tooltips_get_info_from_tip_window (GtkWindow *tip_window, GtkTooltips **tooltips, GtkWidget **current_widget); alias _GtkToolItem GtkToolItem; alias _GtkToolItemClass GtkToolItemClass; alias _GtkToolItemPrivate GtkToolItemPrivate; alias void _GtkToolItemPrivate; struct _GtkToolItem { GtkBin parent; GtkToolItemPrivate *priv; } struct _GtkToolItemClass { GtkBinClass parent_class; gboolean (* create_menu_proxy) (GtkToolItem *tool_item); void (* toolbar_reconfigured) (GtkToolItem *tool_item); gboolean (* set_tooltip) (GtkToolItem *tool_item, GtkTooltips *tooltips, gchar *tip_text, gchar *tip_private); void (* _gtk_reserved1) (); void (* _gtk_reserved2) (); void (* _gtk_reserved3) (); void (* _gtk_reserved4) (); } GType gtk_tool_item_get_type (); GtkToolItem *gtk_tool_item_new (); void gtk_tool_item_set_homogeneous (GtkToolItem *tool_item, gboolean homogeneous); gboolean gtk_tool_item_get_homogeneous (GtkToolItem *tool_item); void gtk_tool_item_set_expand (GtkToolItem *tool_item, gboolean expand); gboolean gtk_tool_item_get_expand (GtkToolItem *tool_item); void gtk_tool_item_set_tooltip (GtkToolItem *tool_item, GtkTooltips *tooltips, gchar *tip_text, gchar *tip_private); void gtk_tool_item_set_use_drag_window (GtkToolItem *toolitem, gboolean use_drag_window); gboolean gtk_tool_item_get_use_drag_window (GtkToolItem *toolitem); void gtk_tool_item_set_visible_horizontal (GtkToolItem *toolitem, gboolean visible_horizontal); gboolean gtk_tool_item_get_visible_horizontal (GtkToolItem *toolitem); void gtk_tool_item_set_visible_vertical (GtkToolItem *toolitem, gboolean visible_vertical); gboolean gtk_tool_item_get_visible_vertical (GtkToolItem *toolitem); gboolean gtk_tool_item_get_is_important (GtkToolItem *tool_item); void gtk_tool_item_set_is_important (GtkToolItem *tool_item, gboolean is_important); GtkIconSize gtk_tool_item_get_icon_size (GtkToolItem *tool_item); GtkOrientation gtk_tool_item_get_orientation (GtkToolItem *tool_item); GtkToolbarStyle gtk_tool_item_get_toolbar_style (GtkToolItem *tool_item); GtkReliefStyle gtk_tool_item_get_relief_style (GtkToolItem *tool_item); GtkWidget * gtk_tool_item_retrieve_proxy_menu_item (GtkToolItem *tool_item); GtkWidget * gtk_tool_item_get_proxy_menu_item (GtkToolItem *tool_item, gchar *menu_item_id); void gtk_tool_item_set_proxy_menu_item (GtkToolItem *tool_item, gchar *menu_item_id, GtkWidget *menu_item); void _gtk_tool_item_toolbar_reconfigured (GtkToolItem *tool_item); alias _GtkToolButton GtkToolButton; alias _GtkToolButtonClass GtkToolButtonClass; alias _GtkToolButtonPrivate GtkToolButtonPrivate; alias void _GtkToolButtonPrivate; struct _GtkToolButton { GtkToolItem parent; GtkToolButtonPrivate *priv; } struct _GtkToolButtonClass { GtkToolItemClass parent_class; GType button_type; void (* clicked) (GtkToolButton *tool_item); void (* _gtk_reserved1) (); void (* _gtk_reserved2) (); void (* _gtk_reserved3) (); void (* _gtk_reserved4) (); } GType gtk_tool_button_get_type (); GtkToolItem *gtk_tool_button_new (GtkWidget *icon_widget, gchar *label); GtkToolItem *gtk_tool_button_new_from_stock ( gchar *stock_id); void gtk_tool_button_set_label (GtkToolButton *button, gchar *label); gchar *gtk_tool_button_get_label (GtkToolButton *button); void gtk_tool_button_set_use_underline (GtkToolButton *button, gboolean use_underline); gboolean gtk_tool_button_get_use_underline (GtkToolButton *button); void gtk_tool_button_set_stock_id (GtkToolButton *button, gchar *stock_id); gchar *gtk_tool_button_get_stock_id (GtkToolButton *button); void gtk_tool_button_set_icon_widget (GtkToolButton *button, GtkWidget *icon_widget); GtkWidget * gtk_tool_button_get_icon_widget (GtkToolButton *button); void gtk_tool_button_set_label_widget (GtkToolButton *button, GtkWidget *label_widget); GtkWidget * gtk_tool_button_get_label_widget (GtkToolButton *button); GtkWidget *_gtk_tool_button_get_button (GtkToolButton *button); alias _GtkToggleToolButton GtkToggleToolButton; alias _GtkToggleToolButtonClass GtkToggleToolButtonClass; alias _GtkToggleToolButtonPrivate GtkToggleToolButtonPrivate; alias void _GtkToggleToolButtonPrivate; struct _GtkToggleToolButton { GtkToolButton parent; GtkToggleToolButtonPrivate *priv; } struct _GtkToggleToolButtonClass { GtkToolButtonClass parent_class; void (* toggled) (GtkToggleToolButton *button); void (* _gtk_reserved1) (); void (* _gtk_reserved2) (); void (* _gtk_reserved3) (); void (* _gtk_reserved4) (); } GType gtk_toggle_tool_button_get_type () ; GtkToolItem *gtk_toggle_tool_button_new (); GtkToolItem *gtk_toggle_tool_button_new_from_stock ( gchar *stock_id); void gtk_toggle_tool_button_set_active (GtkToggleToolButton *button, gboolean is_active); gboolean gtk_toggle_tool_button_get_active (GtkToggleToolButton *button); alias _GtkRadioToolButton GtkRadioToolButton; alias _GtkRadioToolButtonClass GtkRadioToolButtonClass; struct _GtkRadioToolButton { GtkToggleToolButton parent; } struct _GtkRadioToolButtonClass { GtkToggleToolButtonClass parent_class; void (* _gtk_reserved1) (); void (* _gtk_reserved2) (); void (* _gtk_reserved3) (); void (* _gtk_reserved4) (); } GType gtk_radio_tool_button_get_type () ; GtkToolItem *gtk_radio_tool_button_new (GSList *group); GtkToolItem *gtk_radio_tool_button_new_from_stock (GSList *group, gchar *stock_id); GtkToolItem *gtk_radio_tool_button_new_from_widget (GtkRadioToolButton *group); GtkToolItem *gtk_radio_tool_button_new_with_stock_from_widget (GtkRadioToolButton *group, gchar *stock_id); GSList * gtk_radio_tool_button_get_group (GtkRadioToolButton *button); void gtk_radio_tool_button_set_group (GtkRadioToolButton *button, GSList *group); alias _GtkViewport GtkViewport; alias _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); } GType gtk_viewport_get_type () ; 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); GtkShadowType gtk_viewport_get_shadow_type (GtkViewport *viewport); alias _GtkScrolledWindow GtkScrolledWindow; alias _GtkScrolledWindowClass GtkScrolledWindowClass; struct _GtkScrolledWindow { GtkBin container; GtkWidget *hscrollbar; GtkWidget *vscrollbar; guint hscrollbar_policy; guint vscrollbar_policy; guint hscrollbar_visible; guint vscrollbar_visible; guint window_placement; guint focus_out; guint16 shadow_type; } struct _GtkScrolledWindowClass { GtkBinClass parent_class; gint scrollbar_spacing; void (*scroll_child) (GtkScrolledWindow *scrolled_window, GtkScrollType scroll, gboolean horizontal); void (* move_focus_out) (GtkScrolledWindow *scrolled_window, GtkDirectionType direction); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_scrolled_window_get_type () ; 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_get_policy (GtkScrolledWindow *scrolled_window, GtkPolicyType *hscrollbar_policy, GtkPolicyType *vscrollbar_policy); void gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window, GtkCornerType window_placement); GtkCornerType gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window); void gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window, GtkShadowType type); GtkShadowType gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window); void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window, GtkWidget *child); gint _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window); // since 2.8 GtkWidget* gtk_scrolled_window_get_hscrollbar(GtkScrolledWindow *scrolled_window); GtkWidget* gtk_scrolled_window_get_vscrollbar(GtkScrolledWindow *scrolled_window); alias _GtkSeparatorMenuItem GtkSeparatorMenuItem; alias _GtkSeparatorMenuItemClass GtkSeparatorMenuItemClass; struct _GtkSeparatorMenuItem { GtkMenuItem menu_item; } struct _GtkSeparatorMenuItemClass { GtkMenuItemClass parent_class; } GType gtk_separator_menu_item_get_type () ; GtkWidget* gtk_separator_menu_item_new (); alias _GtkSeparatorToolItem GtkSeparatorToolItem; alias _GtkSeparatorToolItemClass GtkSeparatorToolItemClass; alias _GtkSeparatorToolItemPrivate GtkSeparatorToolItemPrivate; alias void _GtkSeparatorToolItemPrivate; struct _GtkSeparatorToolItem { GtkToolItem parent; GtkSeparatorToolItemPrivate *priv; } struct _GtkSeparatorToolItemClass { GtkToolItemClass parent_class; void (* _gtk_reserved1) (); void (* _gtk_reserved2) (); void (* _gtk_reserved3) (); void (* _gtk_reserved4) (); } GType gtk_separator_tool_item_get_type () ; GtkToolItem *gtk_separator_tool_item_new (); gboolean gtk_separator_tool_item_get_draw (GtkSeparatorToolItem *item); void gtk_separator_tool_item_set_draw (GtkSeparatorToolItem *item, gboolean draw); alias _GtkSizeGroup GtkSizeGroup; alias _GtkSizeGroupClass GtkSizeGroupClass; struct _GtkSizeGroup { GObject parent_instance; GSList *widgets; guint8 mode; guint have_width; guint have_height; GtkRequisition requisition; } struct _GtkSizeGroupClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } enum GtkSizeGroupMode { GTK_SIZE_GROUP_NONE, GTK_SIZE_GROUP_HORIZONTAL, GTK_SIZE_GROUP_VERTICAL, GTK_SIZE_GROUP_BOTH }; GType gtk_size_group_get_type () ; GtkSizeGroup * gtk_size_group_new (GtkSizeGroupMode mode); void gtk_size_group_set_mode (GtkSizeGroup *size_group, GtkSizeGroupMode mode); GtkSizeGroupMode gtk_size_group_get_mode (GtkSizeGroup *size_group); void gtk_size_group_add_widget (GtkSizeGroup *size_group, GtkWidget *widget); void gtk_size_group_remove_widget (GtkSizeGroup *size_group, GtkWidget *widget); void _gtk_size_group_get_child_requisition (GtkWidget *widget, GtkRequisition *requisition); void _gtk_size_group_compute_requisition (GtkWidget *widget, GtkRequisition *requisition); void _gtk_size_group_queue_resize (GtkWidget *widget); enum GtkSpinButtonUpdatePolicy { GTK_UPDATE_ALWAYS, GTK_UPDATE_IF_VALID }; enum GtkSpinType { 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 }; alias _GtkSpinButton GtkSpinButton; alias _GtkSpinButtonClass GtkSpinButtonClass; struct _GtkSpinButton { GtkEntry entry; GtkAdjustment *adjustment; GdkWindow *panel; guint32 timer; gdouble climb_rate; gdouble timer_step; GtkSpinButtonUpdatePolicy update_policy; guint in_child; guint click_child; guint button; guint need_timer; guint timer_calls; guint digits; guint numeric; guint wrap; guint snap_to_ticks; } struct _GtkSpinButtonClass { GtkEntryClass parent_class; gint (*input) (GtkSpinButton *spin_button, gdouble *new_value); gint (*output) (GtkSpinButton *spin_button); void (*value_changed) (GtkSpinButton *spin_button); void (*change_value) (GtkSpinButton *spin_button, GtkScrollType scroll); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_spin_button_get_type () ; void gtk_spin_button_configure (GtkSpinButton *spin_button, GtkAdjustment *adjustment, gdouble climb_rate, guint digits); GtkWidget* gtk_spin_button_new (GtkAdjustment *adjustment, gdouble climb_rate, guint digits); GtkWidget* gtk_spin_button_new_with_range (gdouble min, gdouble max, gdouble step); 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); guint gtk_spin_button_get_digits (GtkSpinButton *spin_button); void gtk_spin_button_set_increments (GtkSpinButton *spin_button, gdouble step, gdouble page); void gtk_spin_button_get_increments (GtkSpinButton *spin_button, gdouble *step, gdouble *page); void gtk_spin_button_set_range (GtkSpinButton *spin_button, gdouble min, gdouble max); void gtk_spin_button_get_range (GtkSpinButton *spin_button, gdouble *min, gdouble *max); gdouble gtk_spin_button_get_value (GtkSpinButton *spin_button); gint gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button); void gtk_spin_button_set_value (GtkSpinButton *spin_button, gdouble value); void gtk_spin_button_set_update_policy (GtkSpinButton *spin_button, GtkSpinButtonUpdatePolicy policy); GtkSpinButtonUpdatePolicy gtk_spin_button_get_update_policy (GtkSpinButton *spin_button); void gtk_spin_button_set_numeric (GtkSpinButton *spin_button, gboolean numeric); gboolean gtk_spin_button_get_numeric (GtkSpinButton *spin_button); void gtk_spin_button_spin (GtkSpinButton *spin_button, GtkSpinType direction, gdouble increment); void gtk_spin_button_set_wrap (GtkSpinButton *spin_button, gboolean wrap); gboolean gtk_spin_button_get_wrap (GtkSpinButton *spin_button); void gtk_spin_button_set_snap_to_ticks (GtkSpinButton *spin_button, gboolean snap_to_ticks); gboolean gtk_spin_button_get_snap_to_ticks (GtkSpinButton *spin_button); void gtk_spin_button_update (GtkSpinButton *spin_button); alias _GtkStatusbar GtkStatusbar; alias _GtkStatusbarClass GtkStatusbarClass; struct _GtkStatusbar { GtkHBox parent_widget; GtkWidget *frame; GtkWidget *label; GSList *messages; GSList *keys; guint seq_context_id; guint seq_message_id; GdkWindow *grip_window; guint has_resize_grip; } struct _GtkStatusbarClass { GtkHBoxClass parent_class; GMemChunk *messages_mem_chunk; void (*text_pushed) (GtkStatusbar *statusbar, guint context_id, gchar *text); void (*text_popped) (GtkStatusbar *statusbar, guint context_id, gchar *text); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_statusbar_get_type () ; GtkWidget* gtk_statusbar_new (); guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar, gchar *context_description); guint gtk_statusbar_push (GtkStatusbar *statusbar, guint context_id, gchar *text); void gtk_statusbar_pop (GtkStatusbar *statusbar, guint context_id); void gtk_statusbar_remove (GtkStatusbar *statusbar, guint context_id, guint message_id); void gtk_statusbar_set_has_resize_grip (GtkStatusbar *statusbar, gboolean setting); gboolean gtk_statusbar_get_has_resize_grip (GtkStatusbar *statusbar); alias _GtkStockItem GtkStockItem; struct _GtkStockItem { gchar *stock_id; gchar *label; GdkModifierType modifier; guint keyval; gchar *translation_domain; } void gtk_stock_add ( GtkStockItem *items, guint n_items); void gtk_stock_add_static ( GtkStockItem *items, guint n_items); gboolean gtk_stock_lookup ( gchar *stock_id, GtkStockItem *item); GSList* gtk_stock_list_ids (); GtkStockItem *gtk_stock_item_copy ( GtkStockItem *item); void gtk_stock_item_free (GtkStockItem *item); alias _GtkTable GtkTable; alias _GtkTableClass GtkTableClass; alias _GtkTableChild GtkTableChild; alias _GtkTableRowCol GtkTableRowCol; struct _GtkTable { GtkContainer container; GList *children; GtkTableRowCol *rows; GtkTableRowCol *cols; guint16 nrows; guint16 ncols; guint16 column_spacing; guint16 row_spacing; guint homogeneous; } 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; guint yexpand; guint xshrink; guint yshrink; guint xfill; guint yfill; } struct _GtkTableRowCol { guint16 requisition; guint16 allocation; guint16 spacing; guint need_expand; guint need_shrink; guint expand; guint shrink; guint empty; } GType gtk_table_get_type () ; 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); guint gtk_table_get_row_spacing (GtkTable *table, guint row); void gtk_table_set_col_spacing (GtkTable *table, guint column, guint spacing); guint gtk_table_get_col_spacing (GtkTable *table, guint column); void gtk_table_set_row_spacings (GtkTable *table, guint spacing); guint gtk_table_get_default_row_spacing (GtkTable *table); void gtk_table_set_col_spacings (GtkTable *table, guint spacing); guint gtk_table_get_default_col_spacing (GtkTable *table); void gtk_table_set_homogeneous (GtkTable *table, gboolean homogeneous); gboolean gtk_table_get_homogeneous (GtkTable *table); alias _GtkTearoffMenuItem GtkTearoffMenuItem; alias _GtkTearoffMenuItemClass GtkTearoffMenuItemClass; struct _GtkTearoffMenuItem { GtkMenuItem menu_item; guint torn_off; } struct _GtkTearoffMenuItemClass { GtkMenuItemClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tearoff_menu_item_get_type () ; GtkWidget* gtk_tearoff_menu_item_new (); alias _GtkTextIter GtkTextIter; alias _GtkTextTagTable GtkTextTagTable; alias _GtkTextAttributes GtkTextAttributes; alias _GtkTextTag GtkTextTag; alias _GtkTextTagClass GtkTextTagClass; struct _GtkTextTag { GObject parent_instance; GtkTextTagTable *table; char *name; int priority; GtkTextAttributes *values; guint bg_color_set; guint bg_stipple_set; guint fg_color_set; guint scale_set; guint fg_stipple_set; guint justification_set; guint left_margin_set; guint indent_set; guint rise_set; guint strikethrough_set; guint right_margin_set; guint pixels_above_lines_set; guint pixels_below_lines_set; guint pixels_inside_wrap_set; guint tabs_set; guint underline_set; guint wrap_mode_set; guint bg_full_height_set; guint invisible_set; guint editable_set; guint language_set; guint pad1; guint pad2; guint pad3; } struct _GtkTextTagClass { GObjectClass parent_class; gboolean (* event) (GtkTextTag *tag, GObject *event_object, GdkEvent *event, GtkTextIter *iter); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_text_tag_get_type () ; GtkTextTag *gtk_text_tag_new ( gchar *name); gint gtk_text_tag_get_priority (GtkTextTag *tag); void gtk_text_tag_set_priority (GtkTextTag *tag, gint priority); gboolean gtk_text_tag_event (GtkTextTag *tag, GObject *event_object, GdkEvent *event, GtkTextIter *iter); alias _GtkTextAppearance GtkTextAppearance; struct _GtkTextAppearance { GdkColor bg_color; GdkColor fg_color; GdkBitmap *bg_stipple; GdkBitmap *fg_stipple; gint rise; gpointer padding1; guint underline; guint strikethrough; guint draw_bg; guint inside_selection; guint is_text; guint pad1; guint pad2; guint pad3; guint pad4; } struct _GtkTextAttributes { guint refcount; GtkTextAppearance appearance; GtkJustification justification; GtkTextDirection direction; PangoFontDescription *font; gdouble font_scale; gint left_margin; gint indent; gint right_margin; gint pixels_above_lines; gint pixels_below_lines; gint pixels_inside_wrap; PangoTabArray *tabs; GtkWrapMode wrap_mode; PangoLanguage *language; gpointer padding1; guint invisible; guint bg_full_height; guint editable; guint realized; guint pad1; guint pad2; guint pad3; guint pad4; } GtkTextAttributes* gtk_text_attributes_new (); GtkTextAttributes* gtk_text_attributes_copy (GtkTextAttributes *src); void gtk_text_attributes_copy_values (GtkTextAttributes *src, GtkTextAttributes *dest); void gtk_text_attributes_unref (GtkTextAttributes *values); void gtk_text_attributes_ref (GtkTextAttributes *values); GType gtk_text_attributes_get_type (); alias void (* GtkTextTagTableForeach) (GtkTextTag *tag, gpointer data); alias _GtkTextTagTableClass GtkTextTagTableClass; struct _GtkTextTagTable { GObject parent_instance; GHashTable *hash; GSList *anonymous; gint anon_count; GSList *buffers; } struct _GtkTextTagTableClass { GObjectClass parent_class; void (* tag_changed) (GtkTextTagTable *table, GtkTextTag *tag, gboolean size_changed); void (* tag_added) (GtkTextTagTable *table, GtkTextTag *tag); void (* tag_removed) (GtkTextTagTable *table, GtkTextTag *tag); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_text_tag_table_get_type () ; GtkTextTagTable *gtk_text_tag_table_new (); void gtk_text_tag_table_add (GtkTextTagTable *table, GtkTextTag *tag); void gtk_text_tag_table_remove (GtkTextTagTable *table, GtkTextTag *tag); GtkTextTag *gtk_text_tag_table_lookup (GtkTextTagTable *table, gchar *name); void gtk_text_tag_table_foreach (GtkTextTagTable *table, GtkTextTagTableForeach func, gpointer data); gint gtk_text_tag_table_get_size (GtkTextTagTable *table); void _gtk_text_tag_table_add_buffer (GtkTextTagTable *table, gpointer buffer); void _gtk_text_tag_table_remove_buffer (GtkTextTagTable *table, gpointer buffer); alias _GtkTextChildAnchor GtkTextChildAnchor; alias _GtkTextChildAnchorClass GtkTextChildAnchorClass; struct _GtkTextChildAnchor { GObject parent_instance; gpointer segment; } struct _GtkTextChildAnchorClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_text_child_anchor_get_type () ; GtkTextChildAnchor* gtk_text_child_anchor_new (); GList* gtk_text_child_anchor_get_widgets (GtkTextChildAnchor *anchor); gboolean gtk_text_child_anchor_get_deleted (GtkTextChildAnchor *anchor); enum GtkTextSearchFlags { GTK_TEXT_SEARCH_VISIBLE_ONLY = 1 << 0, GTK_TEXT_SEARCH_TEXT_ONLY = 1 << 1 }; alias _GtkTextBuffer GtkTextBuffer; struct _GtkTextIter { gpointer dummy1; gpointer dummy2; gint dummy3; gint dummy4; gint dummy5; gint dummy6; gint dummy7; gint dummy8; gpointer dummy9; gpointer dummy10; gint dummy11; gint dummy12; gint dummy13; gpointer dummy14; } GtkTextBuffer *gtk_text_iter_get_buffer ( GtkTextIter *iter); GtkTextIter *gtk_text_iter_copy ( GtkTextIter *iter); void gtk_text_iter_free (GtkTextIter *iter); GType gtk_text_iter_get_type (); gint gtk_text_iter_get_offset ( GtkTextIter *iter); gint gtk_text_iter_get_line ( GtkTextIter *iter); gint gtk_text_iter_get_line_offset ( GtkTextIter *iter); gint gtk_text_iter_get_line_index ( GtkTextIter *iter); gint gtk_text_iter_get_visible_line_offset ( GtkTextIter *iter); gint gtk_text_iter_get_visible_line_index ( GtkTextIter *iter); gunichar gtk_text_iter_get_char ( GtkTextIter *iter); gchar *gtk_text_iter_get_slice ( GtkTextIter *start, GtkTextIter *end); gchar *gtk_text_iter_get_text ( GtkTextIter *start, GtkTextIter *end); gchar *gtk_text_iter_get_visible_slice ( GtkTextIter *start, GtkTextIter *end); gchar *gtk_text_iter_get_visible_text ( GtkTextIter *start, GtkTextIter *end); GdkPixbuf* gtk_text_iter_get_pixbuf ( GtkTextIter *iter); GSList * gtk_text_iter_get_marks ( GtkTextIter *iter); GtkTextChildAnchor* gtk_text_iter_get_child_anchor ( GtkTextIter *iter); GSList *gtk_text_iter_get_toggled_tags ( GtkTextIter *iter, gboolean toggled_on); gboolean gtk_text_iter_begins_tag ( GtkTextIter *iter, GtkTextTag *tag); gboolean gtk_text_iter_ends_tag ( GtkTextIter *iter, GtkTextTag *tag); gboolean gtk_text_iter_toggles_tag ( GtkTextIter *iter, GtkTextTag *tag); gboolean gtk_text_iter_has_tag ( GtkTextIter *iter, GtkTextTag *tag); GSList *gtk_text_iter_get_tags ( GtkTextIter *iter); gboolean gtk_text_iter_editable ( GtkTextIter *iter, gboolean default_setting); gboolean gtk_text_iter_can_insert ( GtkTextIter *iter, gboolean default_editability); gboolean gtk_text_iter_starts_word ( GtkTextIter *iter); gboolean gtk_text_iter_ends_word ( GtkTextIter *iter); gboolean gtk_text_iter_inside_word ( GtkTextIter *iter); gboolean gtk_text_iter_starts_sentence ( GtkTextIter *iter); gboolean gtk_text_iter_ends_sentence ( GtkTextIter *iter); gboolean gtk_text_iter_inside_sentence ( GtkTextIter *iter); gboolean gtk_text_iter_starts_line ( GtkTextIter *iter); gboolean gtk_text_iter_ends_line ( GtkTextIter *iter); gboolean gtk_text_iter_is_cursor_position ( GtkTextIter *iter); gint gtk_text_iter_get_chars_in_line ( GtkTextIter *iter); gint gtk_text_iter_get_bytes_in_line ( GtkTextIter *iter); gboolean gtk_text_iter_get_attributes ( GtkTextIter *iter, GtkTextAttributes *values); PangoLanguage* gtk_text_iter_get_language ( GtkTextIter *iter); gboolean gtk_text_iter_is_end ( GtkTextIter *iter); gboolean gtk_text_iter_is_start ( GtkTextIter *iter); gboolean gtk_text_iter_forward_char (GtkTextIter *iter); gboolean gtk_text_iter_backward_char (GtkTextIter *iter); gboolean gtk_text_iter_forward_chars (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_chars (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_line (GtkTextIter *iter); gboolean gtk_text_iter_backward_line (GtkTextIter *iter); gboolean gtk_text_iter_forward_lines (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_lines (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_word_end (GtkTextIter *iter); gboolean gtk_text_iter_backward_word_start (GtkTextIter *iter); gboolean gtk_text_iter_forward_word_ends (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_word_starts (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_visible_word_end (GtkTextIter *iter); gboolean gtk_text_iter_backward_visible_word_start (GtkTextIter *iter); gboolean gtk_text_iter_forward_visible_word_ends (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_visible_word_starts (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_sentence_end (GtkTextIter *iter); gboolean gtk_text_iter_backward_sentence_start (GtkTextIter *iter); gboolean gtk_text_iter_forward_sentence_ends (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_sentence_starts (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_cursor_position (GtkTextIter *iter); gboolean gtk_text_iter_backward_cursor_position (GtkTextIter *iter); gboolean gtk_text_iter_forward_cursor_positions (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_cursor_positions (GtkTextIter *iter, gint count); gboolean gtk_text_iter_forward_visible_cursor_position (GtkTextIter *iter); gboolean gtk_text_iter_backward_visible_cursor_position (GtkTextIter *iter); gboolean gtk_text_iter_forward_visible_cursor_positions (GtkTextIter *iter, gint count); gboolean gtk_text_iter_backward_visible_cursor_positions (GtkTextIter *iter, gint count); void gtk_text_iter_set_offset (GtkTextIter *iter, gint char_offset); void gtk_text_iter_set_line (GtkTextIter *iter, gint line_number); void gtk_text_iter_set_line_offset (GtkTextIter *iter, gint char_on_line); void gtk_text_iter_set_line_index (GtkTextIter *iter, gint byte_on_line); void gtk_text_iter_forward_to_end (GtkTextIter *iter); gboolean gtk_text_iter_forward_to_line_end (GtkTextIter *iter); void gtk_text_iter_set_visible_line_offset (GtkTextIter *iter, gint char_on_line); void gtk_text_iter_set_visible_line_index (GtkTextIter *iter, gint byte_on_line); gboolean gtk_text_iter_forward_to_tag_toggle (GtkTextIter *iter, GtkTextTag *tag); gboolean gtk_text_iter_backward_to_tag_toggle (GtkTextIter *iter, GtkTextTag *tag); alias gboolean (* GtkTextCharPredicate) (gunichar ch, gpointer user_data); gboolean gtk_text_iter_forward_find_char (GtkTextIter *iter, GtkTextCharPredicate pred, gpointer user_data, GtkTextIter *limit); gboolean gtk_text_iter_backward_find_char (GtkTextIter *iter, GtkTextCharPredicate pred, gpointer user_data, GtkTextIter *limit); gboolean gtk_text_iter_forward_search ( GtkTextIter *iter, gchar *str, GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end, GtkTextIter *limit); gboolean gtk_text_iter_backward_search ( GtkTextIter *iter, gchar *str, GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end, GtkTextIter *limit); gboolean gtk_text_iter_equal ( GtkTextIter *lhs, GtkTextIter *rhs); gint gtk_text_iter_compare ( GtkTextIter *lhs, GtkTextIter *rhs); gboolean gtk_text_iter_in_range ( GtkTextIter *iter, GtkTextIter *start, GtkTextIter *end); void gtk_text_iter_order (GtkTextIter *first, GtkTextIter *second); alias _GtkTextMark GtkTextMark; alias _GtkTextMarkClass GtkTextMarkClass; struct _GtkTextMark { GObject parent_instance; gpointer segment; } struct _GtkTextMarkClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_text_mark_get_type () ; void gtk_text_mark_set_visible (GtkTextMark *mark, gboolean setting); gboolean gtk_text_mark_get_visible (GtkTextMark *mark); gchar* gtk_text_mark_get_name (GtkTextMark *mark); gboolean gtk_text_mark_get_deleted (GtkTextMark *mark); GtkTextBuffer* gtk_text_mark_get_buffer (GtkTextMark *mark); gboolean gtk_text_mark_get_left_gravity (GtkTextMark *mark); alias _GtkTextBTree GtkTextBTree; alias void _GtkTextBTree; alias _GtkTextLogAttrCache GtkTextLogAttrCache; alias void _GtkTextLogAttrCache; alias _GtkTextBufferClass GtkTextBufferClass; struct _GtkTextBuffer { GObject parent_instance; GtkTextTagTable *tag_table; GtkTextBTree *btree; GSList *clipboard_contents_buffers; GSList *selection_clipboards; GtkTextLogAttrCache *log_attr_cache; guint user_action_count; guint modified; } struct _GtkTextBufferClass { GObjectClass parent_class; void (* insert_text) (GtkTextBuffer *buffer, GtkTextIter *pos, gchar *text, gint length); void (* insert_pixbuf) (GtkTextBuffer *buffer, GtkTextIter *pos, GdkPixbuf *pixbuf); void (* insert_child_anchor) (GtkTextBuffer *buffer, GtkTextIter *pos, GtkTextChildAnchor *anchor); void (* delete_range) (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); void (* changed) (GtkTextBuffer *buffer); void (* modified_changed) (GtkTextBuffer *buffer); void (* mark_set) (GtkTextBuffer *buffer, GtkTextIter *location, GtkTextMark *mark); void (* mark_deleted) (GtkTextBuffer *buffer, GtkTextMark *mark); void (* apply_tag) (GtkTextBuffer *buffer, GtkTextTag *tag, GtkTextIter *start_char, GtkTextIter *end_char); void (* remove_tag) (GtkTextBuffer *buffer, GtkTextTag *tag, GtkTextIter *start_char, GtkTextIter *end_char); void (* begin_user_action) (GtkTextBuffer *buffer); void (* end_user_action) (GtkTextBuffer *buffer); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); void (*_gtk_reserved5) (); void (*_gtk_reserved6) (); } GType gtk_text_buffer_get_type () ; GtkTextBuffer *gtk_text_buffer_new (GtkTextTagTable *table); gint gtk_text_buffer_get_line_count (GtkTextBuffer *buffer); gint gtk_text_buffer_get_char_count (GtkTextBuffer *buffer); GtkTextTagTable* gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer); void gtk_text_buffer_set_text (GtkTextBuffer *buffer, gchar *text, gint len); void gtk_text_buffer_insert (GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len); void gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer, gchar *text, gint len); gboolean gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, gboolean default_editable); gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer, gchar *text, gint len, gboolean default_editable); void gtk_text_buffer_insert_range (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextIter *start, GtkTextIter *end); gboolean gtk_text_buffer_insert_range_interactive (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextIter *start, GtkTextIter *end, gboolean default_editable); void gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, GtkTextTag *first_tag, ...); void gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, gchar *first_tag_name, ...); void gtk_text_buffer_delete (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); gboolean gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer, GtkTextIter *start_iter, GtkTextIter *end_iter, gboolean default_editable); gchar *gtk_text_buffer_get_text (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end, gboolean include_hidden_chars); gchar *gtk_text_buffer_get_slice (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end, gboolean include_hidden_chars); void gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer, GtkTextIter *iter, GdkPixbuf *pixbuf); void gtk_text_buffer_insert_child_anchor (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextChildAnchor *anchor); GtkTextChildAnchor *gtk_text_buffer_create_child_anchor (GtkTextBuffer *buffer, GtkTextIter *iter); GtkTextMark *gtk_text_buffer_create_mark (GtkTextBuffer *buffer, gchar *mark_name, GtkTextIter *where, gboolean left_gravity); void gtk_text_buffer_move_mark (GtkTextBuffer *buffer, GtkTextMark *mark, GtkTextIter *where); void gtk_text_buffer_delete_mark (GtkTextBuffer *buffer, GtkTextMark *mark); GtkTextMark* gtk_text_buffer_get_mark (GtkTextBuffer *buffer, gchar *name); void gtk_text_buffer_move_mark_by_name (GtkTextBuffer *buffer, gchar *name, GtkTextIter *where); void gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer, gchar *name); GtkTextMark* gtk_text_buffer_get_insert (GtkTextBuffer *buffer); GtkTextMark* gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer); void gtk_text_buffer_place_cursor (GtkTextBuffer *buffer, GtkTextIter *where); void gtk_text_buffer_select_range (GtkTextBuffer *buffer, GtkTextIter *ins, GtkTextIter *bound); void gtk_text_buffer_apply_tag (GtkTextBuffer *buffer, GtkTextTag *tag, GtkTextIter *start, GtkTextIter *end); void gtk_text_buffer_remove_tag (GtkTextBuffer *buffer, GtkTextTag *tag, GtkTextIter *start, GtkTextIter *end); void gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer, gchar *name, GtkTextIter *start, GtkTextIter *end); void gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer, gchar *name, GtkTextIter *start, GtkTextIter *end); void gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); GtkTextTag *gtk_text_buffer_create_tag (GtkTextBuffer *buffer, gchar *tag_name, gchar *first_property_name, ...); void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer, GtkTextIter *iter, gint line_number, gint char_offset); void gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer, GtkTextIter *iter, gint line_number, gint byte_index); void gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer, GtkTextIter *iter, gint char_offset); void gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer, GtkTextIter *iter, gint line_number); void gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer, GtkTextIter *iter); void gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer, GtkTextIter *iter); void gtk_text_buffer_get_bounds (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); void gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextMark *mark); void gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextChildAnchor *anchor); gboolean gtk_text_buffer_get_modified (GtkTextBuffer *buffer); void gtk_text_buffer_set_modified (GtkTextBuffer *buffer, gboolean setting); void gtk_text_buffer_add_selection_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard); void gtk_text_buffer_remove_selection_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard); void gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard, gboolean default_editable); void gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard); void gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer, GtkClipboard *clipboard, GtkTextIter *override_location, gboolean default_editable); gboolean gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end); gboolean gtk_text_buffer_delete_selection (GtkTextBuffer *buffer, gboolean interactive, gboolean default_editable); void gtk_text_buffer_begin_user_action (GtkTextBuffer *buffer); void gtk_text_buffer_end_user_action (GtkTextBuffer *buffer); void _gtk_text_buffer_spew (GtkTextBuffer *buffer); GtkTextBTree* _gtk_text_buffer_get_btree (GtkTextBuffer *buffer); PangoLogAttr* _gtk_text_buffer_get_line_log_attrs (GtkTextBuffer *buffer, GtkTextIter *anywhere_in_line, gint *char_len); void _gtk_text_buffer_notify_will_remove_tag (GtkTextBuffer *buffer, GtkTextTag *tag); enum GtkTextWindowType { GTK_TEXT_WINDOW_PRIVATE, GTK_TEXT_WINDOW_WIDGET, GTK_TEXT_WINDOW_TEXT, GTK_TEXT_WINDOW_LEFT, GTK_TEXT_WINDOW_RIGHT, GTK_TEXT_WINDOW_TOP, GTK_TEXT_WINDOW_BOTTOM }; alias _GtkTextView GtkTextView; alias _GtkTextViewClass GtkTextViewClass; alias _GtkTextWindow GtkTextWindow; alias void _GtkTextWindow; alias _GtkTextPendingScroll GtkTextPendingScroll; alias void _GtkTextPendingScroll; struct _GtkTextView { GtkContainer parent_instance; void *layout; GtkTextBuffer *buffer; guint selection_drag_handler; guint scroll_timeout; gint pixels_above_lines; gint pixels_below_lines; gint pixels_inside_wrap; GtkWrapMode wrap_mode; GtkJustification justify; gint left_margin; gint right_margin; gint indent; PangoTabArray *tabs; guint editable; guint overwrite_mode; guint cursor_visible; guint need_im_reset; guint accepts_tab; guint reserved; guint onscreen_validated; guint mouse_cursor_obscured; GtkTextWindow *text_window; GtkTextWindow *left_window; GtkTextWindow *right_window; GtkTextWindow *top_window; GtkTextWindow *bottom_window; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; gint xoffset; gint yoffset; gint width; gint height; gint virtual_cursor_x; gint virtual_cursor_y; GtkTextMark *first_para_mark; gint first_para_pixels; GtkTextMark *dnd_mark; guint blink_timeout; guint first_validate_idle; guint incremental_validate_idle; GtkIMContext *im_context; GtkWidget *popup_menu; gint drag_start_x; gint drag_start_y; GSList *children; GtkTextPendingScroll *pending_scroll; gint pending_place_cursor_button; } struct _GtkTextViewClass { GtkContainerClass parent_class; void (* set_scroll_adjustments) (GtkTextView *text_view, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment); void (* populate_popup) (GtkTextView *text_view, GtkMenu *menu); void (* move_cursor) (GtkTextView *text_view, GtkMovementStep step, gint count, gboolean extend_selection); void (* page_horizontally) (GtkTextView *text_view, gint count, gboolean extend_selection); void (* set_anchor) (GtkTextView *text_view); void (* insert_at_cursor) (GtkTextView *text_view, gchar *str); void (* delete_from_cursor) (GtkTextView *text_view, GtkDeleteType type, gint count); void (* cut_clipboard) (GtkTextView *text_view); void (* copy_clipboard) (GtkTextView *text_view); void (* paste_clipboard) (GtkTextView *text_view); void (* toggle_overwrite) (GtkTextView *text_view); void (* move_focus) (GtkTextView *text_view, GtkDirectionType direction); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); void (*_gtk_reserved5) (); void (*_gtk_reserved6) (); void (*_gtk_reserved7) (); void (*_gtk_reserved8) (); } GType gtk_text_view_get_type () ; GtkWidget * gtk_text_view_new (); GtkWidget * gtk_text_view_new_with_buffer (GtkTextBuffer *buffer); void gtk_text_view_set_buffer (GtkTextView *text_view, GtkTextBuffer *buffer); GtkTextBuffer *gtk_text_view_get_buffer (GtkTextView *text_view); gboolean gtk_text_view_scroll_to_iter (GtkTextView *text_view, GtkTextIter *iter, gdouble within_margin, gboolean use_align, gdouble xalign, gdouble yalign); void gtk_text_view_scroll_to_mark (GtkTextView *text_view, GtkTextMark *mark, gdouble within_margin, gboolean use_align, gdouble xalign, gdouble yalign); void gtk_text_view_scroll_mark_onscreen (GtkTextView *text_view, GtkTextMark *mark); gboolean gtk_text_view_move_mark_onscreen (GtkTextView *text_view, GtkTextMark *mark); gboolean gtk_text_view_place_cursor_onscreen (GtkTextView *text_view); void gtk_text_view_get_visible_rect (GtkTextView *text_view, GdkRectangle *visible_rect); void gtk_text_view_set_cursor_visible (GtkTextView *text_view, gboolean setting); gboolean gtk_text_view_get_cursor_visible (GtkTextView *text_view); void gtk_text_view_get_iter_location (GtkTextView *text_view, GtkTextIter *iter, GdkRectangle *location); void gtk_text_view_get_iter_at_location (GtkTextView *text_view, GtkTextIter *iter, gint x, gint y); void gtk_text_view_get_line_yrange (GtkTextView *text_view, GtkTextIter *iter, gint *y, gint *height); void gtk_text_view_get_line_at_y (GtkTextView *text_view, GtkTextIter *target_iter, gint y, gint *line_top); void gtk_text_view_buffer_to_window_coords (GtkTextView *text_view, GtkTextWindowType win, gint buffer_x, gint buffer_y, gint *window_x, gint *window_y); void gtk_text_view_window_to_buffer_coords (GtkTextView *text_view, GtkTextWindowType win, gint window_x, gint window_y, gint *buffer_x, gint *buffer_y); GdkWindow* gtk_text_view_get_window (GtkTextView *text_view, GtkTextWindowType win); GtkTextWindowType gtk_text_view_get_window_type (GtkTextView *text_view, GdkWindow *window); void gtk_text_view_set_border_window_size (GtkTextView *text_view, GtkTextWindowType type, gint size); gint gtk_text_view_get_border_window_size (GtkTextView *text_view, GtkTextWindowType type); gboolean gtk_text_view_forward_display_line (GtkTextView *text_view, GtkTextIter *iter); gboolean gtk_text_view_backward_display_line (GtkTextView *text_view, GtkTextIter *iter); gboolean gtk_text_view_forward_display_line_end (GtkTextView *text_view, GtkTextIter *iter); gboolean gtk_text_view_backward_display_line_start (GtkTextView *text_view, GtkTextIter *iter); gboolean gtk_text_view_starts_display_line (GtkTextView *text_view, GtkTextIter *iter); gboolean gtk_text_view_move_visually (GtkTextView *text_view, GtkTextIter *iter, gint count); void gtk_text_view_add_child_at_anchor (GtkTextView *text_view, GtkWidget *child, GtkTextChildAnchor *anchor); void gtk_text_view_add_child_in_window (GtkTextView *text_view, GtkWidget *child, GtkTextWindowType which_window, gint xpos, gint ypos); void gtk_text_view_move_child (GtkTextView *text_view, GtkWidget *child, gint xpos, gint ypos); void gtk_text_view_set_wrap_mode (GtkTextView *text_view, GtkWrapMode wrap_mode); GtkWrapMode gtk_text_view_get_wrap_mode (GtkTextView *text_view); void gtk_text_view_set_editable (GtkTextView *text_view, gboolean setting); gboolean gtk_text_view_get_editable (GtkTextView *text_view); void gtk_text_view_set_overwrite (GtkTextView *text_view, gboolean overwrite); gboolean gtk_text_view_get_overwrite (GtkTextView *text_view); void gtk_text_view_set_accepts_tab (GtkTextView *text_view, gboolean accepts_tab); gboolean gtk_text_view_get_accepts_tab (GtkTextView *text_view); void gtk_text_view_set_pixels_above_lines (GtkTextView *text_view, gint pixels_above_lines); gint gtk_text_view_get_pixels_above_lines (GtkTextView *text_view); void gtk_text_view_set_pixels_below_lines (GtkTextView *text_view, gint pixels_below_lines); gint gtk_text_view_get_pixels_below_lines (GtkTextView *text_view); void gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view, gint pixels_inside_wrap); gint gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view); void gtk_text_view_set_justification (GtkTextView *text_view, GtkJustification justification); GtkJustification gtk_text_view_get_justification (GtkTextView *text_view); void gtk_text_view_set_left_margin (GtkTextView *text_view, gint left_margin); gint gtk_text_view_get_left_margin (GtkTextView *text_view); void gtk_text_view_set_right_margin (GtkTextView *text_view, gint right_margin); gint gtk_text_view_get_right_margin (GtkTextView *text_view); void gtk_text_view_set_indent (GtkTextView *text_view, gint indent); gint gtk_text_view_get_indent (GtkTextView *text_view); void gtk_text_view_set_tabs (GtkTextView *text_view, PangoTabArray *tabs); PangoTabArray* gtk_text_view_get_tabs (GtkTextView *text_view); GtkTextAttributes* gtk_text_view_get_default_attributes (GtkTextView *text_view); alias _GtkTipsQuery GtkTipsQuery; alias _GtkTipsQueryClass GtkTipsQueryClass; struct _GtkTipsQuery { GtkLabel label; guint emit_always; guint in_query; 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, gchar *tip_text, gchar *tip_private); gint (*widget_selected) (GtkTipsQuery *tips_query, GtkWidget *widget, gchar *tip_text, gchar *tip_private, GdkEventButton *event); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GtkType gtk_tips_query_get_type () ; GtkWidget* gtk_tips_query_new (); 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, gchar *label_inactive, gchar *label_no_tip); enum GtkToolbarChildType { GTK_TOOLBAR_CHILD_SPACE, GTK_TOOLBAR_CHILD_BUTTON, GTK_TOOLBAR_CHILD_TOGGLEBUTTON, GTK_TOOLBAR_CHILD_RADIOBUTTON, GTK_TOOLBAR_CHILD_WIDGET }; alias _GtkToolbarChild GtkToolbarChild; struct _GtkToolbarChild { GtkToolbarChildType type; GtkWidget *widget; GtkWidget *icon; GtkWidget *label; } enum GtkToolbarSpaceStyle { GTK_TOOLBAR_SPACE_EMPTY, GTK_TOOLBAR_SPACE_LINE }; alias _GtkToolbar GtkToolbar; alias _GtkToolbarClass GtkToolbarClass; alias _GtkToolbarPrivate GtkToolbarPrivate; alias void _GtkToolbarPrivate; struct _GtkToolbar { GtkContainer container; gint num_children; GList *children; GtkOrientation orientation; GtkToolbarStyle style; GtkIconSize icon_size; GtkTooltips *tooltips; gint button_maxw; gint button_maxh; guint style_set_connection; guint icon_size_connection; guint style_set; guint icon_size_set; } struct _GtkToolbarClass { GtkContainerClass parent_class; void (* orientation_changed) (GtkToolbar *toolbar, GtkOrientation orientation); void (* style_changed) (GtkToolbar *toolbar, GtkToolbarStyle style); gboolean (* popup_context_menu) (GtkToolbar *toolbar, gint x, gint y, gint button_number); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); } GType gtk_toolbar_get_type () ; GtkWidget* gtk_toolbar_new (); void gtk_toolbar_insert (GtkToolbar *toolbar, GtkToolItem *item, gint pos); gint gtk_toolbar_get_item_index (GtkToolbar *toolbar, GtkToolItem *item); gint gtk_toolbar_get_n_items (GtkToolbar *toolbar); GtkToolItem * gtk_toolbar_get_nth_item (GtkToolbar *toolbar, gint n); gboolean gtk_toolbar_get_show_arrow (GtkToolbar *toolbar); void gtk_toolbar_set_show_arrow (GtkToolbar *toolbar, gboolean show_arrow); GtkOrientation gtk_toolbar_get_orientation (GtkToolbar *toolbar); void gtk_toolbar_set_orientation (GtkToolbar *toolbar, GtkOrientation orientation); gboolean gtk_toolbar_get_tooltips (GtkToolbar *toolbar); void gtk_toolbar_set_tooltips (GtkToolbar *toolbar, gboolean enable); GtkToolbarStyle gtk_toolbar_get_style (GtkToolbar *toolbar); void gtk_toolbar_set_style (GtkToolbar *toolbar, GtkToolbarStyle style); void gtk_toolbar_unset_style (GtkToolbar *toolbar); GtkIconSize gtk_toolbar_get_icon_size (GtkToolbar *toolbar); GtkReliefStyle gtk_toolbar_get_relief_style (GtkToolbar *toolbar); gint gtk_toolbar_get_drop_index (GtkToolbar *toolbar, gint x, gint y); void gtk_toolbar_set_drop_highlight_item (GtkToolbar *toolbar, GtkToolItem *tool_item, gint index_); gchar * _gtk_toolbar_elide_underscores ( gchar *original); void _gtk_toolbar_paint_space_line (GtkWidget *widget, GtkToolbar *toolbar, GdkRectangle *area, GtkAllocation *allocation); gint _gtk_toolbar_get_default_space_size (); void gtk_toolbar_set_icon_size (GtkToolbar *toolbar, GtkIconSize icon_size); void gtk_toolbar_unset_icon_size (GtkToolbar *toolbar); GtkWidget* gtk_toolbar_append_item (GtkToolbar *toolbar, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data); GtkWidget* gtk_toolbar_prepend_item (GtkToolbar *toolbar, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data); GtkWidget* gtk_toolbar_insert_item (GtkToolbar *toolbar, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data, gint position); GtkWidget* gtk_toolbar_insert_stock (GtkToolbar *toolbar, gchar *stock_id, char *tooltip_text, char *tooltip_private_text, 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); void gtk_toolbar_remove_space (GtkToolbar *toolbar, gint position); GtkWidget* gtk_toolbar_append_element (GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data); GtkWidget* gtk_toolbar_prepend_element (GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data); GtkWidget* gtk_toolbar_insert_element (GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget, char *text, char *tooltip_text, char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback, gpointer user_data, gint position); void gtk_toolbar_append_widget (GtkToolbar *toolbar, GtkWidget *widget, char *tooltip_text, char *tooltip_private_text); void gtk_toolbar_prepend_widget (GtkToolbar *toolbar, GtkWidget *widget, char *tooltip_text, char *tooltip_private_text); void gtk_toolbar_insert_widget (GtkToolbar *toolbar, GtkWidget *widget, char *tooltip_text, char *tooltip_private_text, gint position); alias _GtkTreeDragSource GtkTreeDragSource; alias void _GtkTreeDragSource; alias _GtkTreeDragSourceIface GtkTreeDragSourceIface; struct _GtkTreeDragSourceIface { GTypeInterface g_iface; gboolean (* row_draggable) (GtkTreeDragSource *drag_source, GtkTreePath *path); gboolean (* drag_data_get) (GtkTreeDragSource *drag_source, GtkTreePath *path, GtkSelectionData *selection_data); gboolean (* drag_data_delete) (GtkTreeDragSource *drag_source, GtkTreePath *path); } GType gtk_tree_drag_source_get_type () ; gboolean gtk_tree_drag_source_row_draggable (GtkTreeDragSource *drag_source, GtkTreePath *path); gboolean gtk_tree_drag_source_drag_data_delete (GtkTreeDragSource *drag_source, GtkTreePath *path); gboolean gtk_tree_drag_source_drag_data_get (GtkTreeDragSource *drag_source, GtkTreePath *path, GtkSelectionData *selection_data); alias _GtkTreeDragDest GtkTreeDragDest; alias void _GtkTreeDragDest; alias _GtkTreeDragDestIface GtkTreeDragDestIface; struct _GtkTreeDragDestIface { GTypeInterface g_iface; gboolean (* drag_data_received) (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data); gboolean (* row_drop_possible) (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, GtkSelectionData *selection_data); } GType gtk_tree_drag_dest_get_type () ; gboolean gtk_tree_drag_dest_drag_data_received (GtkTreeDragDest *drag_dest, GtkTreePath *dest, GtkSelectionData *selection_data); gboolean gtk_tree_drag_dest_row_drop_possible (GtkTreeDragDest *drag_dest, GtkTreePath *dest_path, GtkSelectionData *selection_data); gboolean gtk_tree_set_row_drag_data (GtkSelectionData *selection_data, GtkTreeModel *tree_model, GtkTreePath *path); gboolean gtk_tree_get_row_drag_data (GtkSelectionData *selection_data, GtkTreeModel **tree_model, GtkTreePath **path); alias _GtkTreeModelSort GtkTreeModelSort; alias _GtkTreeModelSortClass GtkTreeModelSortClass; struct _GtkTreeModelSort { GObject parent; gpointer root; gint stamp; guint child_flags; GtkTreeModel *child_model; gint zero_ref_count; GList *sort_list; gint sort_column_id; GtkSortType order; GtkTreeIterCompareFunc default_sort_func; gpointer default_sort_data; GtkDestroyNotify default_sort_destroy; guint changed_id; guint inserted_id; guint has_child_toggled_id; guint deleted_id; guint reordered_id; } struct _GtkTreeModelSortClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tree_model_sort_get_type () ; GtkTreeModel *gtk_tree_model_sort_new_with_model (GtkTreeModel *child_model); GtkTreeModel *gtk_tree_model_sort_get_model (GtkTreeModelSort *tree_model); GtkTreePath *gtk_tree_model_sort_convert_child_path_to_path (GtkTreeModelSort *tree_model_sort, GtkTreePath *child_path); void gtk_tree_model_sort_convert_child_iter_to_iter (GtkTreeModelSort *tree_model_sort, GtkTreeIter *sort_iter, GtkTreeIter *child_iter); GtkTreePath *gtk_tree_model_sort_convert_path_to_child_path (GtkTreeModelSort *tree_model_sort, GtkTreePath *sorted_path); void gtk_tree_model_sort_convert_iter_to_child_iter (GtkTreeModelSort *tree_model_sort, GtkTreeIter *child_iter, GtkTreeIter *sorted_iter); void gtk_tree_model_sort_reset_default_sort_func (GtkTreeModelSort *tree_model_sort); void gtk_tree_model_sort_clear_cache (GtkTreeModelSort *tree_model_sort); gboolean gtk_tree_model_sort_iter_is_valid (GtkTreeModelSort *tree_model_sort, GtkTreeIter *iter); alias gboolean (* GtkTreeSelectionFunc) (GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data); alias void (* GtkTreeSelectionForeachFunc) (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); struct _GtkTreeSelection { GObject parent; GtkTreeView *tree_view; GtkSelectionMode type; GtkTreeSelectionFunc user_func; gpointer user_data; GtkDestroyNotify destroy; } struct _GtkTreeSelectionClass { GObjectClass parent_class; void (* changed) (GtkTreeSelection *selection); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tree_selection_get_type (); void gtk_tree_selection_set_mode (GtkTreeSelection *selection, GtkSelectionMode type); GtkSelectionMode gtk_tree_selection_get_mode (GtkTreeSelection *selection); void gtk_tree_selection_set_select_function (GtkTreeSelection *selection, GtkTreeSelectionFunc func, gpointer data, GtkDestroyNotify destroy); gpointer gtk_tree_selection_get_user_data (GtkTreeSelection *selection); GtkTreeView* gtk_tree_selection_get_tree_view (GtkTreeSelection *selection); gboolean gtk_tree_selection_get_selected (GtkTreeSelection *selection, GtkTreeModel **model, GtkTreeIter *iter); GList * gtk_tree_selection_get_selected_rows (GtkTreeSelection *selection, GtkTreeModel **model); gint gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection); void gtk_tree_selection_selected_foreach (GtkTreeSelection *selection, GtkTreeSelectionForeachFunc func, gpointer data); void gtk_tree_selection_select_path (GtkTreeSelection *selection, GtkTreePath *path); void gtk_tree_selection_unselect_path (GtkTreeSelection *selection, GtkTreePath *path); void gtk_tree_selection_select_iter (GtkTreeSelection *selection, GtkTreeIter *iter); void gtk_tree_selection_unselect_iter (GtkTreeSelection *selection, GtkTreeIter *iter); gboolean gtk_tree_selection_path_is_selected (GtkTreeSelection *selection, GtkTreePath *path); gboolean gtk_tree_selection_iter_is_selected (GtkTreeSelection *selection, GtkTreeIter *iter); void gtk_tree_selection_select_all (GtkTreeSelection *selection); void gtk_tree_selection_unselect_all (GtkTreeSelection *selection); void gtk_tree_selection_select_range (GtkTreeSelection *selection, GtkTreePath *start_path, GtkTreePath *end_path); void gtk_tree_selection_unselect_range (GtkTreeSelection *selection, GtkTreePath *start_path, GtkTreePath *end_path); alias _GtkTreeStore GtkTreeStore; alias _GtkTreeStoreClass GtkTreeStoreClass; struct _GtkTreeStore { GObject parent; gint stamp; gpointer root; gpointer last; gint n_columns; gint sort_column_id; GList *sort_list; GtkSortType order; GType *column_headers; GtkTreeIterCompareFunc default_sort_func; gpointer default_sort_data; GtkDestroyNotify default_sort_destroy; guint columns_dirty; } struct _GtkTreeStoreClass { GObjectClass parent_class; void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } GType gtk_tree_store_get_type (); GtkTreeStore *gtk_tree_store_new (gint n_columns, ...); GtkTreeStore *gtk_tree_store_newv (gint n_columns, GType *types); void gtk_tree_store_set_column_types (GtkTreeStore *tree_store, gint n_columns, GType *types); void gtk_tree_store_set_value (GtkTreeStore *tree_store, GtkTreeIter *iter, gint column, GValue *value); void gtk_tree_store_set (GtkTreeStore *tree_store, GtkTreeIter *iter, ...); void gtk_tree_store_set_valist (GtkTreeStore *tree_store, GtkTreeIter *iter, va_list var_args); gboolean gtk_tree_store_remove (GtkTreeStore *tree_store, GtkTreeIter *iter); void gtk_tree_store_insert (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent, gint position); void gtk_tree_store_insert_before (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent, GtkTreeIter *sibling); void gtk_tree_store_insert_after (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent, GtkTreeIter *sibling); void gtk_tree_store_prepend (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent); void gtk_tree_store_append (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent); gboolean gtk_tree_store_is_ancestor (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *descendant); gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store, GtkTreeIter *iter); void gtk_tree_store_clear (GtkTreeStore *tree_store); gboolean gtk_tree_store_iter_is_valid (GtkTreeStore *tree_store, GtkTreeIter *iter); void gtk_tree_store_reorder (GtkTreeStore *tree_store, GtkTreeIter *parent, gint *new_order); void gtk_tree_store_swap (GtkTreeStore *tree_store, GtkTreeIter *a, GtkTreeIter *b); void gtk_tree_store_move_before (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *position); void gtk_tree_store_move_after (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *position); alias _GtkUIManager GtkUIManager; alias _GtkUIManagerClass GtkUIManagerClass; alias _GtkUIManagerPrivate GtkUIManagerPrivate; alias void _GtkUIManagerPrivate; struct _GtkUIManager { GObject parent; GtkUIManagerPrivate *private_data; } struct _GtkUIManagerClass { GObjectClass parent_class; void (* add_widget) (GtkUIManager *merge, GtkWidget *widget); void (* actions_changed) (GtkUIManager *merge); void (* connect_proxy) (GtkUIManager *merge, GtkAction *action, GtkWidget *proxy); void (* disconnect_proxy) (GtkUIManager *merge, GtkAction *action, GtkWidget *proxy); void (* pre_activate) (GtkUIManager *merge, GtkAction *action); void (* post_activate) (GtkUIManager *merge, GtkAction *action); void (*_gtk_reserved1) (); void (*_gtk_reserved2) (); void (*_gtk_reserved3) (); void (*_gtk_reserved4) (); } enum GtkUIManagerItemType { GTK_UI_MANAGER_AUTO = 0, GTK_UI_MANAGER_MENUBAR = 1 << 0, GTK_UI_MANAGER_MENU = 1 << 1, GTK_UI_MANAGER_TOOLBAR = 1 << 2, GTK_UI_MANAGER_PLACEHOLDER = 1 << 3, GTK_UI_MANAGER_POPUP = 1 << 4, GTK_UI_MANAGER_MENUITEM = 1 << 5, GTK_UI_MANAGER_TOOLITEM = 1 << 6, GTK_UI_MANAGER_SEPARATOR = 1 << 7, GTK_UI_MANAGER_ACCELERATOR = 1 << 8 }; GType gtk_ui_manager_get_type (); GtkUIManager *gtk_ui_manager_new (); void gtk_ui_manager_set_add_tearoffs (GtkUIManager *self, gboolean add_tearoffs); gboolean gtk_ui_manager_get_add_tearoffs (GtkUIManager *self); void gtk_ui_manager_insert_action_group (GtkUIManager *self, GtkActionGroup *action_group, gint pos); void gtk_ui_manager_remove_action_group (GtkUIManager *self, GtkActionGroup *action_group); GList *gtk_ui_manager_get_action_groups (GtkUIManager *self); GtkAccelGroup *gtk_ui_manager_get_accel_group (GtkUIManager *self); GtkWidget *gtk_ui_manager_get_widget (GtkUIManager *self, gchar *path); GSList *gtk_ui_manager_get_toplevels (GtkUIManager *self, GtkUIManagerItemType types); GtkAction *gtk_ui_manager_get_action (GtkUIManager *self, gchar *path); guint gtk_ui_manager_add_ui_from_string (GtkUIManager *self, gchar *buffer, gssize length, GError **error); guint gtk_ui_manager_add_ui_from_file (GtkUIManager *self, gchar *filename, GError **error); void gtk_ui_manager_add_ui (GtkUIManager *self, guint merge_id, gchar *path, gchar *name, gchar *action, GtkUIManagerItemType type, gboolean top); void gtk_ui_manager_remove_ui (GtkUIManager *self, guint merge_id); gchar *gtk_ui_manager_get_ui (GtkUIManager *self); void gtk_ui_manager_ensure_update (GtkUIManager *self); guint gtk_ui_manager_new_merge_id (GtkUIManager *self); alias _GtkVButtonBox GtkVButtonBox; alias _GtkVButtonBoxClass GtkVButtonBoxClass; struct _GtkVButtonBox { GtkButtonBox button_box; } struct _GtkVButtonBoxClass { GtkButtonBoxClass parent_class; } GType gtk_vbutton_box_get_type () ; GtkWidget *gtk_vbutton_box_new (); gint gtk_vbutton_box_get_spacing_default (); void gtk_vbutton_box_set_spacing_default (gint spacing); GtkButtonBoxStyle gtk_vbutton_box_get_layout_default (); void gtk_vbutton_box_set_layout_default (GtkButtonBoxStyle layout); alias _GtkVPaned GtkVPaned; alias _GtkVPanedClass GtkVPanedClass; struct _GtkVPaned { GtkPaned paned; } struct _GtkVPanedClass { GtkPanedClass parent_class; } GType gtk_vpaned_get_type () ; GtkWidget *gtk_vpaned_new (); alias _GtkVRuler GtkVRuler; alias _GtkVRulerClass GtkVRulerClass; struct _GtkVRuler { GtkRuler ruler; } struct _GtkVRulerClass { GtkRulerClass parent_class; } GType gtk_vruler_get_type () ; GtkWidget* gtk_vruler_new (); alias _GtkVScale GtkVScale; alias _GtkVScaleClass GtkVScaleClass; struct _GtkVScale { GtkScale scale; } struct _GtkVScaleClass { GtkScaleClass parent_class; } GType gtk_vscale_get_type () ; GtkWidget* gtk_vscale_new (GtkAdjustment *adjustment); GtkWidget* gtk_vscale_new_with_range (gdouble min, gdouble max, gdouble step); alias _GtkVSeparator GtkVSeparator; alias _GtkVSeparatorClass GtkVSeparatorClass; struct _GtkVSeparator { GtkSeparator separator; } struct _GtkVSeparatorClass { GtkSeparatorClass parent_class; } GType gtk_vseparator_get_type (); GtkWidget* gtk_vseparator_new (); }