--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/atk.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,529 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.atk;
+
+private import dwt.internal.gtk.c.atktypes;
+private import dwt.internal.gtk.runtime.Loader;
+
+/******************************************************************************
+
+******************************************************************************/
+
+private Linker atkLinker;
+
+/******************************************************************************
+
+******************************************************************************/
+
+static this()
+{
+    atkLinker = new Linker( getLibraryPath ~ importLibs[LIBRARY.ATK] );
+    atkLinker.link( atkLinks );
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+static ~this()
+{
+    delete atkLinker;
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+extern(C) 
+{	
+	// atk.Action
+	
+	gboolean function(AtkAction* action, gint i)atk_action_do_action;
+	gint function(AtkAction* action)atk_action_get_n_actions;
+	gchar* function(AtkAction* action, gint i)atk_action_get_description;
+	gchar* function(AtkAction* action, gint i)atk_action_get_name;
+	gchar* function(AtkAction* action, gint i)atk_action_get_localized_name;
+	gchar* function(AtkAction* action, gint i)atk_action_get_keybinding;
+	gboolean function(AtkAction* action, gint i, gchar* desc)atk_action_set_description;
+	
+	// atk.Component
+	
+	guint function(AtkComponent* component, AtkFocusHandler handler)atk_component_add_focus_handler;
+	gboolean function(AtkComponent* component, gint x, gint y, AtkCoordType coordType)atk_component_contains;
+	void function(AtkComponent* component, gint* x, gint* y, gint* width, gint* height, AtkCoordType coordType)atk_component_get_extents;
+	AtkLayer function(AtkComponent* component)atk_component_get_layer;
+	gint function(AtkComponent* component)atk_component_get_mdi_zorder;
+	void function(AtkComponent* component, gint* x, gint* y, AtkCoordType coordType)atk_component_get_position;
+	void function(AtkComponent* component, gint* width, gint* height)atk_component_get_size;
+	gboolean function(AtkComponent* component)atk_component_grab_focus;
+	AtkObject* function(AtkComponent* component, gint x, gint y, AtkCoordType coordType)atk_component_ref_accessible_at_point;
+	void function(AtkComponent* component, guint handlerId)atk_component_remove_focus_handler;
+	gboolean function(AtkComponent* component, gint x, gint y, gint width, gint height, AtkCoordType coordType)atk_component_set_extents;
+	gboolean function(AtkComponent* component, gint x, gint y, AtkCoordType coordType)atk_component_set_position;
+	gboolean function(AtkComponent* component, gint width, gint height)atk_component_set_size;
+	gdouble function(AtkComponent* component)atk_component_get_alpha;
+	
+	// atk.Document
+	
+	gchar* function(AtkDocument* document)atk_document_get_document_type;
+	gpointer function(AtkDocument* document)atk_document_get_document;
+	gchar* function(AtkDocument* document, gchar* attributeName)atk_document_get_attribute_value;
+	gboolean function(AtkDocument* document, gchar* attributeName, gchar* attributeValue)atk_document_set_attribute_value;
+	AtkAttributeSet* function(AtkDocument* document)atk_document_get_attributes;
+	gchar* function(AtkDocument* document)atk_document_get_locale;
+	
+	// atk.EditableText
+	
+	gboolean function(AtkEditableText* text, AtkAttributeSet* attribSet, gint startOffset, gint endOffset)atk_editable_text_set_run_attributes;
+	void function(AtkEditableText* text, gchar* string)atk_editable_text_set_text_contents;
+	void function(AtkEditableText* text, gchar* string, gint length, gint* position)atk_editable_text_insert_text;
+	void function(AtkEditableText* text, gint startPos, gint endPos)atk_editable_text_copy_text;
+	void function(AtkEditableText* text, gint startPos, gint endPos)atk_editable_text_cut_text;
+	void function(AtkEditableText* text, gint startPos, gint endPos)atk_editable_text_delete_text;
+	void function(AtkEditableText* text, gint position)atk_editable_text_paste_text;
+	
+	// atk.GObjectAccessible
+	
+	AtkObject* function(GObject* obj)atk_gobject_accessible_for_object;
+	GObject* function(AtkGObjectAccessible* obj)atk_gobject_accessible_get_object;
+	
+	// atk.Hyperlink
+	
+	gchar* function(AtkHyperlink* link, gint i)atk_hyperlink_get_uri;
+	AtkObject* function(AtkHyperlink* link, gint i)atk_hyperlink_get_object;
+	gint function(AtkHyperlink* link)atk_hyperlink_get_end_index;
+	gint function(AtkHyperlink* link)atk_hyperlink_get_start_index;
+	gboolean function(AtkHyperlink* link)atk_hyperlink_is_valid;
+	gboolean function(AtkHyperlink* link)atk_hyperlink_is_inline;
+	gint function(AtkHyperlink* link)atk_hyperlink_get_n_anchors;
+	gboolean function(AtkHyperlink* link)atk_hyperlink_is_selected_link;
+	
+	// atk.Hypertext
+	
+	AtkHyperlink* function(AtkHypertext* hypertext, gint linkIndex)atk_hypertext_get_link;
+	gint function(AtkHypertext* hypertext)atk_hypertext_get_n_links;
+	gint function(AtkHypertext* hypertext, gint charIndex)atk_hypertext_get_link_index;
+	
+	// atk.Image
+	
+	void function(AtkImage* image, gint* x, gint* y, AtkCoordType coordType)atk_image_get_image_position;
+	gchar* function(AtkImage* image)atk_image_get_image_description;
+	gboolean function(AtkImage* image, gchar* description)atk_image_set_image_description;
+	void function(AtkImage* image, gint* width, gint* height)atk_image_get_image_size;
+	gchar* function(AtkImage* image)atk_image_get_image_locale;
+	
+	// atk.NoOpObject
+	
+	AtkObject* function(GObject* obj)atk_no_op_object_new;
+	
+	// atk.NoOpObjectFactory
+	
+	AtkObjectFactory* function()atk_no_op_object_factory_new;
+	
+	// atk.ObjectAtk
+	
+	AtkRole function(gchar* name)atk_role_register;
+	AtkObject* function(AtkImplementor* implementor)atk_implementor_ref_accessible;
+	gchar* function(AtkObject* accessible)atk_object_get_name;
+	gchar* function(AtkObject* accessible)atk_object_get_description;
+	AtkObject* function(AtkObject* accessible)atk_object_get_parent;
+	gint function(AtkObject* accessible)atk_object_get_n_accessible_children;
+	AtkObject* function(AtkObject* accessible, gint i)atk_object_ref_accessible_child;
+	AtkRelationSet* function(AtkObject* accessible)atk_object_ref_relation_set;
+	AtkLayer function(AtkObject* accessible)atk_object_get_layer;
+	gint function(AtkObject* accessible)atk_object_get_mdi_zorder;
+	AtkRole function(AtkObject* accessible)atk_object_get_role;
+	AtkStateSet* function(AtkObject* accessible)atk_object_ref_state_set;
+	gint function(AtkObject* accessible)atk_object_get_index_in_parent;
+	void function(AtkObject* accessible, gchar* name)atk_object_set_name;
+	void function(AtkObject* accessible, gchar* description)atk_object_set_description;
+	void function(AtkObject* accessible, AtkObject* parent)atk_object_set_parent;
+	void function(AtkObject* accessible, AtkRole role)atk_object_set_role;
+	guint function(AtkObject* accessible, AtkPropertyChangeHandler* handler)atk_object_connect_property_change_handler;
+	void function(AtkObject* accessible, guint handlerId)atk_object_remove_property_change_handler;
+	void function(AtkObject* accessible, AtkState state, gboolean value)atk_object_notify_state_change;
+	void function(AtkObject* accessible, gpointer data)atk_object_initialize;
+	gboolean function(AtkObject* object, AtkRelationType relationship, AtkObject* target)atk_object_add_relationship;
+	gboolean function(AtkObject* object, AtkRelationType relationship, AtkObject* target)atk_object_remove_relationship;
+	AtkAttributeSet* function(AtkObject* accessible)atk_object_get_attributes;
+	gchar* function(AtkRole role)atk_role_get_name;
+	gchar* function(AtkRole role)atk_role_get_localized_name;
+	AtkRole function(gchar* name)atk_role_for_name;
+	
+	// atk.ObjectFactory
+	
+	AtkObject* function(AtkObjectFactory* factory, GObject* obj)atk_object_factory_create_accessible;
+	GType function(AtkObjectFactory* factory)atk_object_factory_get_accessible_type;
+	void function(AtkObjectFactory* factory)atk_object_factory_invalidate;
+	
+	// atk.Registry
+	
+	void function(AtkRegistry* registry, GType type, GType factoryType)atk_registry_set_factory_type;
+	GType function(AtkRegistry* registry, GType type)atk_registry_get_factory_type;
+	AtkObjectFactory* function(AtkRegistry* registry, GType type)atk_registry_get_factory;
+	AtkRegistry* function()atk_get_default_registry;
+	
+	// atk.Relation
+	
+	AtkRelationType function(gchar* name)atk_relation_type_register;
+	gchar* function(AtkRelationType type)atk_relation_type_get_name;
+	AtkRelationType function(gchar* name)atk_relation_type_for_name;
+	AtkRelation* function(AtkObject** targets, gint nTargets, AtkRelationType relationship)atk_relation_new;
+	AtkRelationType function(AtkRelation* relation)atk_relation_get_relation_type;
+	GPtrArray* function(AtkRelation* relation)atk_relation_get_target;
+	void function(AtkRelation* relation, AtkObject* target)atk_relation_add_target;
+	
+	// atk.RelationSet
+	
+	AtkRelationSet* function()atk_relation_set_new;
+	gboolean function(AtkRelationSet* set, AtkRelationType relationship)atk_relation_set_contains;
+	void function(AtkRelationSet* set, AtkRelation* relation)atk_relation_set_remove;
+	void function(AtkRelationSet* set, AtkRelation* relation)atk_relation_set_add;
+	gint function(AtkRelationSet* set)atk_relation_set_get_n_relations;
+	AtkRelation* function(AtkRelationSet* set, gint i)atk_relation_set_get_relation;
+	AtkRelation* function(AtkRelationSet* set, AtkRelationType relationship)atk_relation_set_get_relation_by_type;
+	void function(AtkRelationSet* set, AtkRelationType relationship, AtkObject* target)atk_relation_set_add_relation_by_type;
+	
+	// atk.Selection
+	
+	gboolean function(AtkSelection* selection, gint i)atk_selection_add_selection;
+	gboolean function(AtkSelection* selection)atk_selection_clear_selection;
+	AtkObject* function(AtkSelection* selection, gint i)atk_selection_ref_selection;
+	gint function(AtkSelection* selection)atk_selection_get_selection_count;
+	gboolean function(AtkSelection* selection, gint i)atk_selection_is_child_selected;
+	gboolean function(AtkSelection* selection, gint i)atk_selection_remove_selection;
+	gboolean function(AtkSelection* selection)atk_selection_select_all_selection;
+	
+	// atk.State
+	
+	AtkStateType function(gchar* name)atk_state_type_register;
+	gchar* function(AtkStateType type)atk_state_type_get_name;
+	AtkStateType function(gchar* name)atk_state_type_for_name;
+	
+	// atk.StateSet
+	
+	AtkStateSet* function()atk_state_set_new;
+	gboolean function(AtkStateSet* set)atk_state_set_is_empty;
+	gboolean function(AtkStateSet* set, AtkStateType type)atk_state_set_add_state;
+	void function(AtkStateSet* set, AtkStateType* types, gint nTypes)atk_state_set_add_states;
+	void function(AtkStateSet* set)atk_state_set_clear_states;
+	gboolean function(AtkStateSet* set, AtkStateType type)atk_state_set_contains_state;
+	gboolean function(AtkStateSet* set, AtkStateType* types, gint nTypes)atk_state_set_contains_states;
+	gboolean function(AtkStateSet* set, AtkStateType type)atk_state_set_remove_state;
+	AtkStateSet* function(AtkStateSet* set, AtkStateSet* compareSet)atk_state_set_and_sets;
+	AtkStateSet* function(AtkStateSet* set, AtkStateSet* compareSet)atk_state_set_or_sets;
+	AtkStateSet* function(AtkStateSet* set, AtkStateSet* compareSet)atk_state_set_xor_sets;
+	
+	// atk.StreamableContent
+	
+	gint function(AtkStreamableContent* streamable)atk_streamable_content_get_n_mime_types;
+	gchar* function(AtkStreamableContent* streamable, gint i)atk_streamable_content_get_mime_type;
+	GIOChannel* function(AtkStreamableContent* streamable, gchar* mimeType)atk_streamable_content_get_stream;
+	gchar* function(AtkStreamableContent* streamable, gchar* mimeType)atk_streamable_content_get_uri;
+	
+	// atk.Table
+	
+	AtkObject* function(AtkTable* table, gint row, gint column)atk_table_ref_at;
+	gint function(AtkTable* table, gint row, gint column)atk_table_get_index_at;
+	gint function(AtkTable* table, gint index)atk_table_get_column_at_index;
+	gint function(AtkTable* table, gint index)atk_table_get_row_at_index;
+	gint function(AtkTable* table)atk_table_get_n_columns;
+	gint function(AtkTable* table)atk_table_get_n_rows;
+	gint function(AtkTable* table, gint row, gint column)atk_table_get_column_extent_at;
+	gint function(AtkTable* table, gint row, gint column)atk_table_get_row_extent_at;
+	AtkObject* function(AtkTable* table)atk_table_get_caption;
+	gchar* function(AtkTable* table, gint column)atk_table_get_column_description;
+	gchar* function(AtkTable* table, gint row)atk_table_get_row_description;
+	AtkObject* function(AtkTable* table, gint column)atk_table_get_column_header;
+	AtkObject* function(AtkTable* table, gint row)atk_table_get_row_header;
+	AtkObject* function(AtkTable* table)atk_table_get_summary;
+	void function(AtkTable* table, AtkObject* caption)atk_table_set_caption;
+	void function(AtkTable* table, gint row, gchar* description)atk_table_set_row_description;
+	void function(AtkTable* table, gint column, gchar* description)atk_table_set_column_description;
+	void function(AtkTable* table, gint row, AtkObject* header)atk_table_set_row_header;
+	void function(AtkTable* table, gint column, AtkObject* header)atk_table_set_column_header;
+	void function(AtkTable* table, AtkObject* accessible)atk_table_set_summary;
+	gint function(AtkTable* table, gint** selected)atk_table_get_selected_columns;
+	gint function(AtkTable* table, gint** selected)atk_table_get_selected_rows;
+	gboolean function(AtkTable* table, gint column)atk_table_is_column_selected;
+	gboolean function(AtkTable* table, gint row)atk_table_is_row_selected;
+	gboolean function(AtkTable* table, gint row, gint column)atk_table_is_selected;
+	gboolean function(AtkTable* table, gint column)atk_table_add_column_selection;
+	gboolean function(AtkTable* table, gint row)atk_table_add_row_selection;
+	gboolean function(AtkTable* table, gint column)atk_table_remove_column_selection;
+	gboolean function(AtkTable* table, gint row)atk_table_remove_row_selection;
+	
+	// atk.Text
+	
+	gchar* function(AtkText* text, gint startOffset, gint endOffset)atk_text_get_text;
+	gunichar function(AtkText* text, gint offset)atk_text_get_character_at_offset;
+	gchar* function(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)atk_text_get_text_after_offset;
+	gchar* function(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)atk_text_get_text_at_offset;
+	gchar* function(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)atk_text_get_text_before_offset;
+	gint function(AtkText* text)atk_text_get_caret_offset;
+	void function(AtkText* text, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords)atk_text_get_character_extents;
+	AtkAttributeSet* function(AtkText* text, gint offset, gint* startOffset, gint* endOffset)atk_text_get_run_attributes;
+	AtkAttributeSet* function(AtkText* text)atk_text_get_default_attributes;
+	gint function(AtkText* text)atk_text_get_character_count;
+	gint function(AtkText* text, gint x, gint y, AtkCoordType coords)atk_text_get_offset_at_point;
+	AtkTextRange** function(AtkText* text, AtkTextRectangle* rect, AtkCoordType coordType, AtkTextClipType xClipType, AtkTextClipType yClipType)atk_text_get_bounded_ranges;
+	void function(AtkText* text, gint startOffset, gint endOffset, AtkCoordType coordType, AtkTextRectangle* rect)atk_text_get_range_extents;
+	void function(AtkTextRange** ranges)atk_text_free_ranges;
+	gint function(AtkText* text)atk_text_get_n_selections;
+	gchar* function(AtkText* text, gint selectionNum, gint* startOffset, gint* endOffset)atk_text_get_selection;
+	gboolean function(AtkText* text, gint startOffset, gint endOffset)atk_text_add_selection;
+	gboolean function(AtkText* text, gint selectionNum)atk_text_remove_selection;
+	gboolean function(AtkText* text, gint selectionNum, gint startOffset, gint endOffset)atk_text_set_selection;
+	gboolean function(AtkText* text, gint offset)atk_text_set_caret_offset;
+	void function(AtkAttributeSet* attribSet)atk_attribute_set_free;
+	AtkTextAttribute function(gchar* name)atk_text_attribute_register;
+	gchar* function(AtkTextAttribute attr)atk_text_attribute_get_name;
+	AtkTextAttribute function(gchar* name)atk_text_attribute_for_name;
+	gchar* function(AtkTextAttribute attr, gint index)atk_text_attribute_get_value;
+	
+	// atk.Util
+	
+	guint function(AtkEventListener focusTracker)atk_add_focus_tracker;
+	void function(guint trackerId)atk_remove_focus_tracker;
+	void function(AtkEventListenerInit init)atk_focus_tracker_init;
+	void function(AtkObject* object)atk_focus_tracker_notify;
+	guint function(GSignalEmissionHook listener, gchar* eventType)atk_add_global_event_listener;
+	void function(guint listenerId)atk_remove_global_event_listener;
+	guint function(AtkKeySnoopFunc listener, gpointer data)atk_add_key_event_listener;
+	void function(guint listenerId)atk_remove_key_event_listener;
+	AtkObject* function()atk_get_root;
+	AtkObject* function()atk_get_focus_object;
+	gchar* function()atk_get_toolkit_name;
+	gchar* function()atk_get_toolkit_version;
+	
+	// atk.ValueAtk
+	
+	void function(AtkValue* obj, GValue* value)atk_value_get_current_value;
+	void function(AtkValue* obj, GValue* value)atk_value_get_maximum_value;
+	void function(AtkValue* obj, GValue* value)atk_value_get_minimum_value;
+	gboolean function(AtkValue* obj, GValue* value)atk_value_set_current_value;
+	void function(AtkValue* obj, GValue* value)atk_value_get_minimum_increment;
+}
+
+Symbol[] atkLinks = 
+[
+
+	{ "atk_action_do_action",  cast(void**)& atk_action_do_action},
+	{ "atk_action_get_n_actions",  cast(void**)& atk_action_get_n_actions},
+	{ "atk_action_get_description",  cast(void**)& atk_action_get_description},
+	{ "atk_action_get_name",  cast(void**)& atk_action_get_name},
+	{ "atk_action_get_localized_name",  cast(void**)& atk_action_get_localized_name},
+	{ "atk_action_get_keybinding",  cast(void**)& atk_action_get_keybinding},
+	{ "atk_action_set_description",  cast(void**)& atk_action_set_description},
+	{ "atk_component_add_focus_handler",  cast(void**)& atk_component_add_focus_handler},
+	{ "atk_component_contains",  cast(void**)& atk_component_contains},
+	{ "atk_component_get_extents",  cast(void**)& atk_component_get_extents},
+	{ "atk_component_get_layer",  cast(void**)& atk_component_get_layer},
+	{ "atk_component_get_mdi_zorder",  cast(void**)& atk_component_get_mdi_zorder},
+	{ "atk_component_get_position",  cast(void**)& atk_component_get_position},
+	{ "atk_component_get_size",  cast(void**)& atk_component_get_size},
+	{ "atk_component_grab_focus",  cast(void**)& atk_component_grab_focus},
+	{ "atk_component_ref_accessible_at_point",  cast(void**)& atk_component_ref_accessible_at_point},
+	{ "atk_component_remove_focus_handler",  cast(void**)& atk_component_remove_focus_handler},
+	{ "atk_component_set_extents",  cast(void**)& atk_component_set_extents},
+	{ "atk_component_set_position",  cast(void**)& atk_component_set_position},
+	{ "atk_component_set_size",  cast(void**)& atk_component_set_size},
+	{ "atk_component_get_alpha",  cast(void**)& atk_component_get_alpha},
+	{ "atk_document_get_document_type",  cast(void**)& atk_document_get_document_type},
+	{ "atk_document_get_document",  cast(void**)& atk_document_get_document},
+	{ "atk_document_get_attribute_value",  cast(void**)& atk_document_get_attribute_value},
+	{ "atk_document_set_attribute_value",  cast(void**)& atk_document_set_attribute_value},
+	{ "atk_document_get_attributes",  cast(void**)& atk_document_get_attributes},
+	{ "atk_document_get_locale",  cast(void**)& atk_document_get_locale},
+	{ "atk_editable_text_set_run_attributes",  cast(void**)& atk_editable_text_set_run_attributes},
+	{ "atk_editable_text_set_text_contents",  cast(void**)& atk_editable_text_set_text_contents},
+	{ "atk_editable_text_insert_text",  cast(void**)& atk_editable_text_insert_text},
+	{ "atk_editable_text_copy_text",  cast(void**)& atk_editable_text_copy_text},
+	{ "atk_editable_text_cut_text",  cast(void**)& atk_editable_text_cut_text},
+	{ "atk_editable_text_delete_text",  cast(void**)& atk_editable_text_delete_text},
+	{ "atk_editable_text_paste_text",  cast(void**)& atk_editable_text_paste_text},
+	{ "atk_gobject_accessible_for_object",  cast(void**)& atk_gobject_accessible_for_object},
+	{ "atk_gobject_accessible_get_object",  cast(void**)& atk_gobject_accessible_get_object},
+	{ "atk_hyperlink_get_uri",  cast(void**)& atk_hyperlink_get_uri},
+	{ "atk_hyperlink_get_object",  cast(void**)& atk_hyperlink_get_object},
+	{ "atk_hyperlink_get_end_index",  cast(void**)& atk_hyperlink_get_end_index},
+	{ "atk_hyperlink_get_start_index",  cast(void**)& atk_hyperlink_get_start_index},
+	{ "atk_hyperlink_is_valid",  cast(void**)& atk_hyperlink_is_valid},
+	{ "atk_hyperlink_is_inline",  cast(void**)& atk_hyperlink_is_inline},
+	{ "atk_hyperlink_get_n_anchors",  cast(void**)& atk_hyperlink_get_n_anchors},
+	{ "atk_hyperlink_is_selected_link",  cast(void**)& atk_hyperlink_is_selected_link},
+	{ "atk_hypertext_get_link",  cast(void**)& atk_hypertext_get_link},
+	{ "atk_hypertext_get_n_links",  cast(void**)& atk_hypertext_get_n_links},
+	{ "atk_hypertext_get_link_index",  cast(void**)& atk_hypertext_get_link_index},
+	{ "atk_image_get_image_position",  cast(void**)& atk_image_get_image_position},
+	{ "atk_image_get_image_description",  cast(void**)& atk_image_get_image_description},
+	{ "atk_image_set_image_description",  cast(void**)& atk_image_set_image_description},
+	{ "atk_image_get_image_size",  cast(void**)& atk_image_get_image_size},
+	{ "atk_image_get_image_locale",  cast(void**)& atk_image_get_image_locale},
+	{ "atk_no_op_object_new",  cast(void**)& atk_no_op_object_new},
+	{ "atk_no_op_object_factory_new",  cast(void**)& atk_no_op_object_factory_new},
+	{ "atk_role_register",  cast(void**)& atk_role_register},
+	{ "atk_implementor_ref_accessible",  cast(void**)& atk_implementor_ref_accessible},
+	{ "atk_object_get_name",  cast(void**)& atk_object_get_name},
+	{ "atk_object_get_description",  cast(void**)& atk_object_get_description},
+	{ "atk_object_get_parent",  cast(void**)& atk_object_get_parent},
+	{ "atk_object_get_n_accessible_children",  cast(void**)& atk_object_get_n_accessible_children},
+	{ "atk_object_ref_accessible_child",  cast(void**)& atk_object_ref_accessible_child},
+	{ "atk_object_ref_relation_set",  cast(void**)& atk_object_ref_relation_set},
+	{ "atk_object_get_layer",  cast(void**)& atk_object_get_layer},
+	{ "atk_object_get_mdi_zorder",  cast(void**)& atk_object_get_mdi_zorder},
+	{ "atk_object_get_role",  cast(void**)& atk_object_get_role},
+	{ "atk_object_ref_state_set",  cast(void**)& atk_object_ref_state_set},
+	{ "atk_object_get_index_in_parent",  cast(void**)& atk_object_get_index_in_parent},
+	{ "atk_object_set_name",  cast(void**)& atk_object_set_name},
+	{ "atk_object_set_description",  cast(void**)& atk_object_set_description},
+	{ "atk_object_set_parent",  cast(void**)& atk_object_set_parent},
+	{ "atk_object_set_role",  cast(void**)& atk_object_set_role},
+	{ "atk_object_connect_property_change_handler",  cast(void**)& atk_object_connect_property_change_handler},
+	{ "atk_object_remove_property_change_handler",  cast(void**)& atk_object_remove_property_change_handler},
+	{ "atk_object_notify_state_change",  cast(void**)& atk_object_notify_state_change},
+	{ "atk_object_initialize",  cast(void**)& atk_object_initialize},
+	{ "atk_object_add_relationship",  cast(void**)& atk_object_add_relationship},
+	{ "atk_object_remove_relationship",  cast(void**)& atk_object_remove_relationship},
+	{ "atk_object_get_attributes",  cast(void**)& atk_object_get_attributes},
+	{ "atk_role_get_name",  cast(void**)& atk_role_get_name},
+	{ "atk_role_get_localized_name",  cast(void**)& atk_role_get_localized_name},
+	{ "atk_role_for_name",  cast(void**)& atk_role_for_name},
+	{ "atk_object_factory_create_accessible",  cast(void**)& atk_object_factory_create_accessible},
+	{ "atk_object_factory_get_accessible_type",  cast(void**)& atk_object_factory_get_accessible_type},
+	{ "atk_object_factory_invalidate",  cast(void**)& atk_object_factory_invalidate},
+	{ "atk_registry_set_factory_type",  cast(void**)& atk_registry_set_factory_type},
+	{ "atk_registry_get_factory_type",  cast(void**)& atk_registry_get_factory_type},
+	{ "atk_registry_get_factory",  cast(void**)& atk_registry_get_factory},
+	{ "atk_get_default_registry",  cast(void**)& atk_get_default_registry},
+	{ "atk_relation_type_register",  cast(void**)& atk_relation_type_register},
+	{ "atk_relation_type_get_name",  cast(void**)& atk_relation_type_get_name},
+	{ "atk_relation_type_for_name",  cast(void**)& atk_relation_type_for_name},
+	{ "atk_relation_new",  cast(void**)& atk_relation_new},
+	{ "atk_relation_get_relation_type",  cast(void**)& atk_relation_get_relation_type},
+	{ "atk_relation_get_target",  cast(void**)& atk_relation_get_target},
+	{ "atk_relation_add_target",  cast(void**)& atk_relation_add_target},
+	{ "atk_relation_set_new",  cast(void**)& atk_relation_set_new},
+	{ "atk_relation_set_contains",  cast(void**)& atk_relation_set_contains},
+	{ "atk_relation_set_remove",  cast(void**)& atk_relation_set_remove},
+	{ "atk_relation_set_add",  cast(void**)& atk_relation_set_add},
+	{ "atk_relation_set_get_n_relations",  cast(void**)& atk_relation_set_get_n_relations},
+	{ "atk_relation_set_get_relation",  cast(void**)& atk_relation_set_get_relation},
+	{ "atk_relation_set_get_relation_by_type",  cast(void**)& atk_relation_set_get_relation_by_type},
+	{ "atk_relation_set_add_relation_by_type",  cast(void**)& atk_relation_set_add_relation_by_type},
+	{ "atk_selection_add_selection",  cast(void**)& atk_selection_add_selection},
+	{ "atk_selection_clear_selection",  cast(void**)& atk_selection_clear_selection},
+	{ "atk_selection_ref_selection",  cast(void**)& atk_selection_ref_selection},
+	{ "atk_selection_get_selection_count",  cast(void**)& atk_selection_get_selection_count},
+	{ "atk_selection_is_child_selected",  cast(void**)& atk_selection_is_child_selected},
+	{ "atk_selection_remove_selection",  cast(void**)& atk_selection_remove_selection},
+	{ "atk_selection_select_all_selection",  cast(void**)& atk_selection_select_all_selection},
+	{ "atk_state_type_register",  cast(void**)& atk_state_type_register},
+	{ "atk_state_type_get_name",  cast(void**)& atk_state_type_get_name},
+	{ "atk_state_type_for_name",  cast(void**)& atk_state_type_for_name},
+	{ "atk_state_set_new",  cast(void**)& atk_state_set_new},
+	{ "atk_state_set_is_empty",  cast(void**)& atk_state_set_is_empty},
+	{ "atk_state_set_add_state",  cast(void**)& atk_state_set_add_state},
+	{ "atk_state_set_add_states",  cast(void**)& atk_state_set_add_states},
+	{ "atk_state_set_clear_states",  cast(void**)& atk_state_set_clear_states},
+	{ "atk_state_set_contains_state",  cast(void**)& atk_state_set_contains_state},
+	{ "atk_state_set_contains_states",  cast(void**)& atk_state_set_contains_states},
+	{ "atk_state_set_remove_state",  cast(void**)& atk_state_set_remove_state},
+	{ "atk_state_set_and_sets",  cast(void**)& atk_state_set_and_sets},
+	{ "atk_state_set_or_sets",  cast(void**)& atk_state_set_or_sets},
+	{ "atk_state_set_xor_sets",  cast(void**)& atk_state_set_xor_sets},
+	{ "atk_streamable_content_get_n_mime_types",  cast(void**)& atk_streamable_content_get_n_mime_types},
+	{ "atk_streamable_content_get_mime_type",  cast(void**)& atk_streamable_content_get_mime_type},
+	{ "atk_streamable_content_get_stream",  cast(void**)& atk_streamable_content_get_stream},
+	{ "atk_streamable_content_get_uri",  cast(void**)& atk_streamable_content_get_uri},
+	{ "atk_table_ref_at",  cast(void**)& atk_table_ref_at},
+	{ "atk_table_get_index_at",  cast(void**)& atk_table_get_index_at},
+	{ "atk_table_get_column_at_index",  cast(void**)& atk_table_get_column_at_index},
+	{ "atk_table_get_row_at_index",  cast(void**)& atk_table_get_row_at_index},
+	{ "atk_table_get_n_columns",  cast(void**)& atk_table_get_n_columns},
+	{ "atk_table_get_n_rows",  cast(void**)& atk_table_get_n_rows},
+	{ "atk_table_get_column_extent_at",  cast(void**)& atk_table_get_column_extent_at},
+	{ "atk_table_get_row_extent_at",  cast(void**)& atk_table_get_row_extent_at},
+	{ "atk_table_get_caption",  cast(void**)& atk_table_get_caption},
+	{ "atk_table_get_column_description",  cast(void**)& atk_table_get_column_description},
+	{ "atk_table_get_row_description",  cast(void**)& atk_table_get_row_description},
+	{ "atk_table_get_column_header",  cast(void**)& atk_table_get_column_header},
+	{ "atk_table_get_row_header",  cast(void**)& atk_table_get_row_header},
+	{ "atk_table_get_summary",  cast(void**)& atk_table_get_summary},
+	{ "atk_table_set_caption",  cast(void**)& atk_table_set_caption},
+	{ "atk_table_set_row_description",  cast(void**)& atk_table_set_row_description},
+	{ "atk_table_set_column_description",  cast(void**)& atk_table_set_column_description},
+	{ "atk_table_set_row_header",  cast(void**)& atk_table_set_row_header},
+	{ "atk_table_set_column_header",  cast(void**)& atk_table_set_column_header},
+	{ "atk_table_set_summary",  cast(void**)& atk_table_set_summary},
+	{ "atk_table_get_selected_columns",  cast(void**)& atk_table_get_selected_columns},
+	{ "atk_table_get_selected_rows",  cast(void**)& atk_table_get_selected_rows},
+	{ "atk_table_is_column_selected",  cast(void**)& atk_table_is_column_selected},
+	{ "atk_table_is_row_selected",  cast(void**)& atk_table_is_row_selected},
+	{ "atk_table_is_selected",  cast(void**)& atk_table_is_selected},
+	{ "atk_table_add_column_selection",  cast(void**)& atk_table_add_column_selection},
+	{ "atk_table_add_row_selection",  cast(void**)& atk_table_add_row_selection},
+	{ "atk_table_remove_column_selection",  cast(void**)& atk_table_remove_column_selection},
+	{ "atk_table_remove_row_selection",  cast(void**)& atk_table_remove_row_selection},
+	{ "atk_text_get_text",  cast(void**)& atk_text_get_text},
+	{ "atk_text_get_character_at_offset",  cast(void**)& atk_text_get_character_at_offset},
+	{ "atk_text_get_text_after_offset",  cast(void**)& atk_text_get_text_after_offset},
+	{ "atk_text_get_text_at_offset",  cast(void**)& atk_text_get_text_at_offset},
+	{ "atk_text_get_text_before_offset",  cast(void**)& atk_text_get_text_before_offset},
+	{ "atk_text_get_caret_offset",  cast(void**)& atk_text_get_caret_offset},
+	{ "atk_text_get_character_extents",  cast(void**)& atk_text_get_character_extents},
+	{ "atk_text_get_run_attributes",  cast(void**)& atk_text_get_run_attributes},
+	{ "atk_text_get_default_attributes",  cast(void**)& atk_text_get_default_attributes},
+	{ "atk_text_get_character_count",  cast(void**)& atk_text_get_character_count},
+	{ "atk_text_get_offset_at_point",  cast(void**)& atk_text_get_offset_at_point},
+	{ "atk_text_get_bounded_ranges",  cast(void**)& atk_text_get_bounded_ranges},
+	{ "atk_text_get_range_extents",  cast(void**)& atk_text_get_range_extents},
+	{ "atk_text_free_ranges",  cast(void**)& atk_text_free_ranges},
+	{ "atk_text_get_n_selections",  cast(void**)& atk_text_get_n_selections},
+	{ "atk_text_get_selection",  cast(void**)& atk_text_get_selection},
+	{ "atk_text_add_selection",  cast(void**)& atk_text_add_selection},
+	{ "atk_text_remove_selection",  cast(void**)& atk_text_remove_selection},
+	{ "atk_text_set_selection",  cast(void**)& atk_text_set_selection},
+	{ "atk_text_set_caret_offset",  cast(void**)& atk_text_set_caret_offset},
+	{ "atk_attribute_set_free",  cast(void**)& atk_attribute_set_free},
+	{ "atk_text_attribute_register",  cast(void**)& atk_text_attribute_register},
+	{ "atk_text_attribute_get_name",  cast(void**)& atk_text_attribute_get_name},
+	{ "atk_text_attribute_for_name",  cast(void**)& atk_text_attribute_for_name},
+	{ "atk_text_attribute_get_value",  cast(void**)& atk_text_attribute_get_value},
+	{ "atk_add_focus_tracker",  cast(void**)& atk_add_focus_tracker},
+	{ "atk_remove_focus_tracker",  cast(void**)& atk_remove_focus_tracker},
+	{ "atk_focus_tracker_init",  cast(void**)& atk_focus_tracker_init},
+	{ "atk_focus_tracker_notify",  cast(void**)& atk_focus_tracker_notify},
+	{ "atk_add_global_event_listener",  cast(void**)& atk_add_global_event_listener},
+	{ "atk_remove_global_event_listener",  cast(void**)& atk_remove_global_event_listener},
+	{ "atk_add_key_event_listener",  cast(void**)& atk_add_key_event_listener},
+	{ "atk_remove_key_event_listener",  cast(void**)& atk_remove_key_event_listener},
+	{ "atk_get_root",  cast(void**)& atk_get_root},
+	{ "atk_get_focus_object",  cast(void**)& atk_get_focus_object},
+	{ "atk_get_toolkit_name",  cast(void**)& atk_get_toolkit_name},
+	{ "atk_get_toolkit_version",  cast(void**)& atk_get_toolkit_version},
+	{ "atk_value_get_current_value",  cast(void**)& atk_value_get_current_value},
+	{ "atk_value_get_maximum_value",  cast(void**)& atk_value_get_maximum_value},
+	{ "atk_value_get_minimum_value",  cast(void**)& atk_value_get_minimum_value},
+	{ "atk_value_set_current_value",  cast(void**)& atk_value_set_current_value},
+	{ "atk_value_get_minimum_increment",  cast(void**)& atk_value_get_minimum_increment},
+
+];

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/atktypes.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,623 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.atktypes;
+
+public import dwt.internal.gtk.c.glibtypes;
+public import dwt.internal.gtk.c.gobjecttypes;
+
+/******************************************************************************
+
+******************************************************************************/
+
+public alias void* AtkFocusHandler;
+public struct AtkStateSet;
+public struct AtkRectangle;
+
+
+/**
+ * typedef guint64 AtkState;
+ * The AtkState value should not be referenceed directly.
+ */
+public alias ulong AtkState;
+
+/**
+ * typedef GSList AtkAttributeSet;
+ * This is a singly-linked list (a GSList) of AtkAttribute. It is
+ * used by atk_text_get_run_attributes(), atk_text_get_default_attributes()
+ * and atk_editable_text_set_run_attributes()
+ */
+public alias GSList AtkAttributeSet;
+/**
+ * Describes the type of link
+ * ATK_HYPERLINK_IS_INLINE
+ */
+public enum AtkHyperlinkStateFlags
+{
+	IS_INLINE = 1 << 0
+}
+/**
+ * Describes the role of an object
+ * These are the built-in enumerated roles that UI components can have in
+ * ATK. Other roles may be added at runtime, so an AtkRole >=
+ * ATK_ROLE_LAST_DEFINED is not necessarily an error.
+ * ATK_ROLE_INVALID
+ */
+public enum AtkRole
+{
+	INVALID = 0,
+	ACCEL_LABEL,
+	ALERT,
+	ANIMATION,
+	ARROW,
+	CALENDAR,
+	CANVAS,
+	CHECK_BOX,
+	CHECK_MENU_ITEM,
+	COLOR_CHOOSER,
+	COLUMN_HEADER,
+	COMBO_BOX,
+	DATE_EDITOR,
+	DESKTOP_ICON,
+	DESKTOP_FRAME,
+	DIAL,
+	DIALOG,
+	DIRECTORY_PANE,
+	DRAWING_AREA,
+	FILE_CHOOSER,
+	FILLER,
+	FONT_CHOOSER,
+	FRAME,
+	GLASS_PANE,
+	HTML_CONTAINER,
+	ICON,
+	IMAGE,
+	INTERNAL_FRAME,
+	LABEL,
+	LAYERED_PANE,
+	LIST,
+	LIST_ITEM,
+	MENU,
+	MENU_BAR,
+	MENU_ITEM,
+	OPTION_PANE,
+	PAGE_TAB,
+	PAGE_TAB_LIST,
+	PANEL,
+	PASSWORD_TEXT,
+	POPUP_MENU,
+	PROGRESS_BAR,
+	PUSH_BUTTON,
+	RADIO_BUTTON,
+	RADIO_MENU_ITEM,
+	ROOT_PANE,
+	ROW_HEADER,
+	SCROLL_BAR,
+	SCROLL_PANE,
+	SEPARATOR,
+	SLIDER,
+	SPLIT_PANE,
+	SPIN_BUTTON,
+	STATUSBAR,
+	TABLE,
+	TABLE_CELL,
+	TABLE_COLUMN_HEADER,
+	TABLE_ROW_HEADER,
+	TEAR_OFF_MENU_ITEM,
+	TERMINAL,
+	TEXT,
+	TOGGLE_BUTTON,
+	TOOL_BAR,
+	TOOL_TIP,
+	TREE,
+	TREE_TABLE,
+	UNKNOWN,
+	VIEWPORT,
+	WINDOW,
+	HEADER,
+	FOOTER,
+	PARAGRAPH,
+	RULER,
+	APPLICATION,
+	AUTOCOMPLETE,
+	EDITBAR,
+	EMBEDDED,
+	ENTRY,
+	CHART,
+	CAPTION,
+	DOCUMENT_FRAME,
+	HEADING,
+	PAGE,
+	SECTION,
+	REDUNDANT_OBJECT,
+	FORM,
+	LINK,
+	INPUT_METHOD_WINDOW,
+	LAST_DEFINED
+}
+/**
+ * Describes the layer of a component
+ * These enumerated "layer values" are used when determining which UI
+ * rendering layer a component is drawn into, which can help in making
+ * determinations of when components occlude one another.
+ * ATK_LAYER_INVALID
+ */
+public enum AtkLayer
+{
+	INVALID,
+	BACKGROUND,
+	CANVAS,
+	WIDGET,
+	MDI,
+	POPUP,
+	OVERLAY,
+	WINDOW
+}
+/**
+ * Describes the type of the relation
+ * ATK_RELATION_NULL
+ */
+public enum AtkRelationType
+{
+	NULL = 0,
+	CONTROLLED_BY,
+	CONTROLLER_FOR,
+	LABEL_FOR,
+	LABELLED_BY,
+	MEMBER_OF,
+	NODE_CHILD_OF,
+	FLOWS_TO,
+	FLOWS_FROM,
+	SUBWINDOW_OF,
+	EMBEDS,
+	EMBEDDED_BY,
+	POPUP_FOR,
+	PARENT_WINDOW_OF,
+	DESCRIBED_BY,
+	DESCRIPTION_FOR,
+	LAST_DEFINED
+}
+/**
+ * The possible types of states of an object
+ * ATK_STATE_INVALID
+ */
+public enum AtkStateType
+{
+	INVALID,
+	ACTIVE,
+	ARMED,
+	BUSY,
+	CHECKED,
+	DEFUNCT,
+	EDITABLE,
+	ENABLED,
+	EXPANDABLE,
+	EXPANDED,
+	FOCUSABLE,
+	FOCUSED,
+	HORIZONTAL,
+	ICONIFIED,
+	MODAL,
+	MULTI_LINE,
+	MULTISELECTABLE,
+	OPAQUE,
+	PRESSED,
+	RESIZABLE,
+	SELECTABLE,
+	SELECTED,
+	SENSITIVE,
+	SHOWING,
+	SINGLE_LINE,
+	STALE,
+	TRANSIENT,
+	VERTICAL,
+	VISIBLE,
+	MANAGES_DESCENDANTS,
+	INDETERMINATE,
+	TRUNCATED,
+	REQUIRED,
+	INVALID_ENTRY,
+	SUPPORTS_AUTOCOMPLETION,
+	SELECTABLE_TEXT,
+	DEFAULT,
+	ANIMATED,
+	VISITED,
+	LAST_DEFINED
+}
+/**
+ * Text boundary types used for specifying boundaries for regions of text
+ * ATK_TEXT_BOUNDARY_CHAR
+ */
+public enum AtkTextBoundary
+{
+	CHAR,
+	WORD_START,
+	WORD_END,
+	SENTENCE_START,
+	SENTENCE_END,
+	LINE_START,
+	LINE_END
+}
+/**
+ * Describes the type of clipping required.
+ * ATK_TEXT_CLIP_NONE
+ */
+public enum AtkTextClipType
+{
+	NONE,
+	MIN,
+	MAX,
+	BOTH
+}
+/**
+ * Describes the text attributes supported
+ * ATK_TEXT_ATTR_INVALID
+ */
+public enum AtkTextAttribute
+{
+	INVALID = 0,
+	LEFT_MARGIN,
+	RIGHT_MARGIN,
+	INDENT,
+	INVISIBLE,
+	EDITABLE,
+	PIXELS_ABOVE_LINES,
+	PIXELS_BELOW_LINES,
+	PIXELS_INSIDE_WRAP,
+	BG_FULL_HEIGHT,
+	RISE,
+	UNDERLINE,
+	STRIKETHROUGH,
+	SIZE,
+	SCALE,
+	WEIGHT,
+	LANGUAGE,
+	FAMILY_NAME,
+	BG_COLOR,
+	FG_COLOR,
+	BG_STIPPLE,
+	FG_STIPPLE,
+	WRAP_MODE,
+	DIRECTION,
+	JUSTIFICATION,
+	STRETCH,
+	VARIANT,
+	STYLE,
+	LAST_DEFINED
+}
+/**
+ * Specifies how xy coordinates are to be interpreted. Used by functions such
+ * as atk_component_get_position() and atk_text_get_character_extents()
+ * ATK_XY_SCREEN
+ */
+public enum AtkCoordType
+{
+	XY_SCREEN,
+	XY_WINDOW
+}
+/**
+ * Specifies the type of a keyboard evemt.
+ * ATK_KEY_EVENT_PRESS
+ */
+public enum AtkKeyEventType
+{
+	PRESS,
+	RELEASE,
+	LAST_DEFINED
+}
+
+/**
+ * Main Gtk struct.
+ * The AtkAction structure does not contain any fields.
+ */
+public struct AtkAction{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkComponent structure does not contain any fields.
+ */
+public struct AtkComponent{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkDocument structure does not contain any fields.
+ */
+public struct AtkDocument{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkEditableText structure does not contain any fields.
+ */
+public struct AtkEditableText{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkGObjectAccessible structure should not be accessed directly.
+ */
+public struct AtkGObjectAccessible{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkHyperlink structure should not be accessed directly.
+ */
+public struct AtkHyperlink{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkHypertext structure does not contain any fields.
+ */
+public struct AtkHypertext{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkImage structure does not contain any fields.
+ */
+public struct AtkImage{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkNoOpObject structure should not be accessed directly.
+ */
+public struct AtkNoOpObject{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkNoOpObjectFactory structure should not be accessed directly.
+ */
+public struct AtkNoOpObjectFactory{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkObject structure should not be accessed directly.
+ */
+public struct AtkObject{}
+
+
+/**
+ * The AtkImplementor interface is implemented by objects for which AtkObject peers may be obtained via calls to iface->(ref_accessible)(implementor);
+ */
+public struct AtkImplementor{}
+
+
+/**
+ * note: For most properties the old_value field of AtkPropertyValues will
+ * not contain a valid value.
+ * Currently, the only property for which old_value is used is
+ * accessible-state; for instance if there is a focus state the
+ * property change handler will be called for the object which lost the focus
+ * with the old_value containing an AtkState value corresponding to focused
+ * and the property change handler will be called for the object which
+ * received the focus with the new_value containing an AtkState value
+ * corresponding to focused.
+ * The Atk PropertyValue structure is used when notifying a change in property.
+ * Currently, the only property for which old_value is used is
+ * accessible-state; for instance if there is a focus change the
+ * property change handler will be called for the object which lost the focus
+ * with the old_value containing the AtkState value corresponding to focused
+ * and the property change handler will be called for the object which
+ * received the focus with the new_value containing the AtkState value
+ * corresponding to focused.
+ * constgchar*property_name;
+ */
+public struct AtkPropertyValues{}
+// char *propertyName;
+// AtkObject.html
+// GValue oldValue;
+// AtkObject.html
+// GValue newValue;
+// AtkObject.html
+
+
+/**
+ * Main Gtk struct.
+ * The AtkObjectFactory structure should not be accessed directly.
+ */
+public struct AtkObjectFactory{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkRegistry structure should not be accessed directly.
+ */
+public struct AtkRegistry{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkRelation structure should not be accessed directly.
+ */
+public struct AtkRelation{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkRelationSet structure should not be accessed directly.
+ */
+public struct AtkRelationSet{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkAction structure does not contain any fields.
+ */
+public struct AtkSelection{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkStreamableContent structure does not contain any fields.
+ */
+public struct AtkStreamableContent{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkTable structure does not contain any fields.
+ */
+public struct AtkTable{}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkText structure does not contain any fields.
+ */
+public struct AtkText{}
+
+
+/**
+ * A structure used to describe a text range.
+ * AtkTextRectanglebounds;
+ */
+public struct AtkTextRange{}
+// AtkTextRectangle bounds;
+// AtkText.html
+// int startOffset;
+// AtkText.html
+// int endOffset;
+// AtkText.html
+// char* content;
+// AtkText.html
+
+
+/**
+ * A structure used to store a rectangle used by AtkText.
+ * gintx;
+ */
+public struct AtkTextRectangle
+{
+	int x;
+	int y;
+	int width;
+	int height;
+}
+
+
+/**
+ * A string name/value pair representing a text attribute.
+ * gchar*name;
+ */
+public struct AtkAttribute
+{
+	char* name;
+	char* value;
+}
+
+
+/**
+ * The AtkUtil struct does not contain any fields.
+ */
+public struct AtkUtil{}
+
+
+/**
+ * Encapsulates information about a key event.
+ * ginttype;
+ */
+public struct AtkKeyEventStruct
+{
+	int type;
+	uint state;
+	uint keyval;
+	int length;
+	char *string;
+	ushort keycode;
+	uint timestamp;
+}
+
+
+/**
+ * Main Gtk struct.
+ * The AtkValue structure does not contain any fields.
+ */
+public struct AtkValue{}
+
+
+/*
+ * An AtkFunction is a function definition used for padding which has been added
+ * to class and interface structures to allow for expansion in the future.
+ * data:
+ * a gpointer to parameter data.
+ * Returns:
+ * Nothing useful, this is only a dummy prototype.
+ */
+// gboolean (*AtkFunction) (gpointer data);
+public typedef extern(C) int  function (void*) AtkFunction;
+
+/*
+ * An AtkPropertyChangeHandler is a function which is executed when an AtkObject's property changes value. It is specified in a call to
+ * atk_object_connect_property_change_handler().
+ * Param1:
+ *  an AtkObject
+ * Param2:
+ *  an AtkPropertyValues
+ */
+// void (*AtkPropertyChangeHandler) (AtkObject *,  AtkPropertyValues *);
+public typedef extern(C) void  function (AtkObject*, AtkPropertyValues*) AtkPropertyChangeHandler;
+
+/*
+ * A function which is called when an object emits a matching event,
+ * as used in atk_add_focus_tracker.
+ * Currently the only events for which object-specific handlers are
+ * supported are events of type "focus:". Most clients of ATK will prefer to
+ * attach signal handlers for the various ATK signals instead.
+ * see: atk_add_focus_tracker.
+ * obj:
+ *  An AtkObject instance for whom the callback will be called when
+ * the specified event (e.g. 'focus:') takes place.
+ */
+// void (*AtkEventListener) (AtkObject *obj);
+public typedef extern(C) void  function (AtkObject*) AtkEventListener;
+
+/*
+ * An AtkEventListenerInit function is a special function that is
+ * called in order to initialize the per-object event registration system
+ * used by AtkEventListener, if any preparation is required.
+ * see: atk_focus_tracker_init.
+ */
+// void (*AtkEventListenerInit) (void);
+public typedef extern(C) void  function () AtkEventListenerInit;
+
+/*
+ * An AtkKeySnoopFunc is a type of callback which is called whenever a key event occurs,
+ * if registered via atk_add_key_event_listener. It allows for pre-emptive
+ * interception of key events via the return code as described below.
+ * event:
+ *  an AtkKeyEventStruct containing information about the key event for which
+ * notification is being given.
+ * func_data:
+ *  a block of data which will be passed to the event listener, on notification.
+ * Returns:
+ *  TRUE (nonzero) if the event emission should be stopped and the event
+ * discarded without being passed to the normal GUI recipient; FALSE (zero) if the
+ * event dispatch to the client application should proceed as normal.
+ * see: atk_add_key_event_listener.
+ */
+// gint (*AtkKeySnoopFunc) (AtkKeyEventStruct *event,  gpointer func_data);
+public typedef extern(C) int  function (AtkKeyEventStruct*, void*) AtkKeySnoopFunc;

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/cairo.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,463 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.cairo;
+
+private import dwt.internal.gtk.c.cairotypes;
+private import dwt.internal.gtk.runtime.Loader;
+
+/******************************************************************************
+
+******************************************************************************/
+
+private Linker cairoLinker;
+
+/******************************************************************************
+
+******************************************************************************/
+
+static this()
+{
+    cairoLinker = new Linker( getLibraryPath ~ importLibs[LIBRARY.CAIRO] );
+    cairoLinker.link( cairoLinks );
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+static ~this()
+{
+    delete cairoLinker;
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+extern(C) 
+{	
+	// cairo.Context
+	
+	cairo_t* function(cairo_surface_t* target)cairo_create;
+	cairo_t* function(cairo_t* cr)cairo_reference;
+	void function(cairo_t* cr)cairo_destroy;
+	cairo_status_t function(cairo_t* cr)cairo_status;
+	void function(cairo_t* cr)cairo_save;
+	void function(cairo_t* cr)cairo_restore;
+	cairo_surface_t* function(cairo_t* cr)cairo_get_target;
+	void function(cairo_t* cr)cairo_push_group;
+	void function(cairo_t* cr, cairo_content_t content)cairo_push_group_with_content;
+	cairo_pattern_t* function(cairo_t* cr)cairo_pop_group;
+	void function(cairo_t* cr)cairo_pop_group_to_source;
+	cairo_surface_t* function(cairo_t* cr)cairo_get_group_target;
+	void function(cairo_t* cr, double red, double green, double blue)cairo_set_source_rgb;
+	void function(cairo_t* cr, double red, double green, double blue, double alpha)cairo_set_source_rgba;
+	void function(cairo_t* cr, cairo_pattern_t* source)cairo_set_source;
+	void function(cairo_t* cr, cairo_surface_t* surface, double x, double y)cairo_set_source_surface;
+	cairo_pattern_t* function(cairo_t* cr)cairo_get_source;
+	void function(cairo_t* cr, cairo_antialias_t antialias)cairo_set_antialias;
+	cairo_antialias_t function(cairo_t* cr)cairo_get_antialias;
+	void function(cairo_t* cr, double* dashes, int numDashes, double offset)cairo_set_dash;
+	void function(cairo_t* cr, cairo_fill_rule_t fillRule)cairo_set_fill_rule;
+	cairo_fill_rule_t function(cairo_t* cr)cairo_get_fill_rule;
+	void function(cairo_t* cr, cairo_line_cap_t lineCap)cairo_set_line_cap;
+	cairo_line_cap_t function(cairo_t* cr)cairo_get_line_cap;
+	void function(cairo_t* cr, cairo_line_join_t lineJoin)cairo_set_line_join;
+	cairo_line_join_t function(cairo_t* cr)cairo_get_line_join;
+	void function(cairo_t* cr, double width)cairo_set_line_width;
+	double function(cairo_t* cr)cairo_get_line_width;
+	void function(cairo_t* cr, double limit)cairo_set_miter_limit;
+	double function(cairo_t* cr)cairo_get_miter_limit;
+	void function(cairo_t* cr, cairo_operator_t op)cairo_set_operator;
+	cairo_operator_t function(cairo_t* cr)cairo_get_operator;
+	void function(cairo_t* cr, double tolerance)cairo_set_tolerance;
+	double function(cairo_t* cr)cairo_get_tolerance;
+	void function(cairo_t* cr)cairo_clip;
+	void function(cairo_t* cr)cairo_clip_preserve;
+	void function(cairo_t* cr)cairo_reset_clip;
+	void function(cairo_t* cr)cairo_fill;
+	void function(cairo_t* cr)cairo_fill_preserve;
+	void function(cairo_t* cr, double* x1, double* y1, double* x2, double* y2)cairo_fill_extents;
+	cairo_bool_t function(cairo_t* cr, double x, double y)cairo_in_fill;
+	void function(cairo_t* cr, cairo_pattern_t* pattern)cairo_mask;
+	void function(cairo_t* cr, cairo_surface_t* surface, double surfaceX, double surfaceY)cairo_mask_surface;
+	void function(cairo_t* cr)cairo_paint;
+	void function(cairo_t* cr, double alpha)cairo_paint_with_alpha;
+	void function(cairo_t* cr)cairo_stroke;
+	void function(cairo_t* cr)cairo_stroke_preserve;
+	void function(cairo_t* cr, double* x1, double* y1, double* x2, double* y2)cairo_stroke_extents;
+	cairo_bool_t function(cairo_t* cr, double x, double y)cairo_in_stroke;
+	void function(cairo_t* cr)cairo_copy_page;
+	void function(cairo_t* cr)cairo_show_page;
+	cairo_path_t* function(cairo_t* cr)cairo_copy_path;
+	cairo_path_t* function(cairo_t* cr)cairo_copy_path_flat;
+	void function(cairo_path_t* path)cairo_path_destroy;
+	void function(cairo_t* cr, cairo_path_t* path)cairo_append_path;
+	void function(cairo_t* cr, double* x, double* y)cairo_get_current_point;
+	void function(cairo_t* cr)cairo_new_path;
+	void function(cairo_t* cr)cairo_new_sub_path;
+	void function(cairo_t* cr)cairo_close_path;
+	void function(cairo_t* cr, double xc, double yc, double radius, double angle1, double angle2)cairo_arc;
+	void function(cairo_t* cr, double xc, double yc, double radius, double angle1, double angle2)cairo_arc_negative;
+	void function(cairo_t* cr, double x1, double y1, double x2, double y2, double x3, double y3)cairo_curve_to;
+	void function(cairo_t* cr, double x, double y)cairo_line_to;
+	void function(cairo_t* cr, double x, double y)cairo_move_to;
+	void function(cairo_t* cr, double x, double y, double width, double height)cairo_rectangle;
+	void function(cairo_t* cr, cairo_glyph_t* glyphs, int numGlyphs)cairo_glyph_path;
+	void function(cairo_t* cr, char* utf8)cairo_text_path;
+	void function(cairo_t* cr, double dx1, double dy1, double dx2, double dy2, double dx3, double dy3)cairo_rel_curve_to;
+	void function(cairo_t* cr, double dx, double dy)cairo_rel_line_to;
+	void function(cairo_t* cr, double dx, double dy)cairo_rel_move_to;
+	void function(cairo_t* cr, double tx, double ty)cairo_translate;
+	void function(cairo_t* cr, double sx, double sy)cairo_scale;
+	void function(cairo_t* cr, double angle)cairo_rotate;
+	void function(cairo_t* cr, cairo_matrix_t* matrix)cairo_transform;
+	void function(cairo_t* cr, cairo_matrix_t* matrix)cairo_set_matrix;
+	void function(cairo_t* cr, cairo_matrix_t* matrix)cairo_get_matrix;
+	void function(cairo_t* cr)cairo_identity_matrix;
+	void function(cairo_t* cr, double* x, double* y)cairo_user_to_device;
+	void function(cairo_t* cr, double* dx, double* dy)cairo_user_to_device_distance;
+	void function(cairo_t* cr, double* x, double* y)cairo_device_to_user;
+	void function(cairo_t* cr, double* dx, double* dy)cairo_device_to_user_distance;
+	void function(cairo_t* cr, char* family, cairo_font_slant_t slant, cairo_font_weight_t weight)cairo_select_font_face;
+	void function(cairo_t* cr, double size)cairo_set_font_size;
+	void function(cairo_t* cr, cairo_matrix_t* matrix)cairo_set_font_matrix;
+	void function(cairo_t* cr, cairo_matrix_t* matrix)cairo_get_font_matrix;
+	void function(cairo_t* cr, cairo_font_options_t* options)cairo_set_font_options;
+	void function(cairo_t* cr, cairo_font_options_t* options)cairo_get_font_options;
+	void function(cairo_t* cr, char* utf8)cairo_show_text;
+	void function(cairo_t* cr, cairo_glyph_t* glyphs, int numGlyphs)cairo_show_glyphs;
+	cairo_font_face_t* function(cairo_t* cr)cairo_get_font_face;
+	void function(cairo_t* cr, cairo_font_extents_t* extents)cairo_font_extents;
+	void function(cairo_t* cr, cairo_font_face_t* fontFace)cairo_set_font_face;
+	void function(cairo_t* cr, cairo_scaled_font_t* scaledFont)cairo_set_scaled_font;
+	void function(cairo_t* cr, char* utf8, cairo_text_extents_t* extents)cairo_text_extents;
+	void function(cairo_t* cr, cairo_glyph_t* glyphs, int numGlyphs, cairo_text_extents_t* extents)cairo_glyph_extents;
+	
+	// cairo.Pattern
+	
+	void function(cairo_pattern_t* pattern, double offset, double red, double green, double blue)cairo_pattern_add_color_stop_rgb;
+	void function(cairo_pattern_t* pattern, double offset, double red, double green, double blue, double alpha)cairo_pattern_add_color_stop_rgba;
+	cairo_pattern_t* function(double red, double green, double blue)cairo_pattern_create_rgb;
+	cairo_pattern_t* function(double red, double green, double blue, double alpha)cairo_pattern_create_rgba;
+	cairo_pattern_t* function(cairo_surface_t* surface)cairo_pattern_create_for_surface;
+	cairo_pattern_t* function(double x0, double y0, double x1, double y1)cairo_pattern_create_linear;
+	cairo_pattern_t* function(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1)cairo_pattern_create_radial;
+	void function(cairo_pattern_t* pattern)cairo_pattern_destroy;
+	cairo_pattern_t* function(cairo_pattern_t* pattern)cairo_pattern_reference;
+	cairo_status_t function(cairo_pattern_t* pattern)cairo_pattern_status;
+	void function(cairo_pattern_t* pattern, cairo_extend_t extend)cairo_pattern_set_extend;
+	cairo_extend_t function(cairo_pattern_t* pattern)cairo_pattern_get_extend;
+	void function(cairo_pattern_t* pattern, cairo_filter_t filter)cairo_pattern_set_filter;
+	cairo_filter_t function(cairo_pattern_t* pattern)cairo_pattern_get_filter;
+	void function(cairo_pattern_t* pattern, cairo_matrix_t* matrix)cairo_pattern_set_matrix;
+	void function(cairo_pattern_t* pattern, cairo_matrix_t* matrix)cairo_pattern_get_matrix;
+	cairo_pattern_type_t function(cairo_pattern_t* pattern)cairo_pattern_get_type;
+	
+	// cairo.FontFace
+	
+	cairo_font_face_t* function(cairo_font_face_t* fontFace)cairo_font_face_reference;
+	void function(cairo_font_face_t* fontFace)cairo_font_face_destroy;
+	cairo_status_t function(cairo_font_face_t* fontFace)cairo_font_face_status;
+	void* function(cairo_font_face_t* fontFace, cairo_user_data_key_t* key)cairo_font_face_get_user_data;
+	cairo_status_t function(cairo_font_face_t* fontFace, cairo_user_data_key_t* key, void* userData, cairo_destroy_func_t destroy)cairo_font_face_set_user_data;
+	cairo_font_type_t function(cairo_font_face_t* fontFace)cairo_font_face_get_type;
+	
+	// cairo.ScaledFont
+	
+	cairo_scaled_font_t* function(cairo_font_face_t* fontFace, cairo_matrix_t* fontMatrix, cairo_matrix_t* ctm, cairo_font_options_t* options)cairo_scaled_font_create;
+	cairo_scaled_font_t* function(cairo_scaled_font_t* scaledFont)cairo_scaled_font_reference;
+	void function(cairo_scaled_font_t* scaledFont)cairo_scaled_font_destroy;
+	cairo_status_t function(cairo_scaled_font_t* scaledFont)cairo_scaled_font_status;
+	void function(cairo_scaled_font_t* scaledFont, cairo_font_extents_t* extents)cairo_scaled_font_extents;
+	void function(cairo_scaled_font_t* scaledFont, char* utf8, cairo_text_extents_t* extents)cairo_scaled_font_text_extents;
+	void function(cairo_scaled_font_t* scaledFont, cairo_glyph_t* glyphs, int numGlyphs, cairo_text_extents_t* extents)cairo_scaled_font_glyph_extents;
+	cairo_font_face_t* function(cairo_scaled_font_t* scaledFont)cairo_scaled_font_get_font_face;
+	void function(cairo_scaled_font_t* scaledFont, cairo_font_options_t* options)cairo_scaled_font_get_font_options;
+	void function(cairo_scaled_font_t* scaledFont, cairo_matrix_t* fontMatrix)cairo_scaled_font_get_font_matrix;
+	void function(cairo_scaled_font_t* scaledFont, cairo_matrix_t* ctm)cairo_scaled_font_get_ctm;
+	cairo_font_type_t function(cairo_scaled_font_t* scaledFont)cairo_scaled_font_get_type;
+	
+	// cairo.FontOption
+	
+	cairo_font_options_t* function()cairo_font_options_create;
+	cairo_font_options_t* function(cairo_font_options_t* original)cairo_font_options_copy;
+	void function(cairo_font_options_t* options)cairo_font_options_destroy;
+	cairo_status_t function(cairo_font_options_t* options)cairo_font_options_status;
+	void function(cairo_font_options_t* options, cairo_font_options_t* other)cairo_font_options_merge;
+	ulong function(cairo_font_options_t* options)cairo_font_options_hash;
+	cairo_bool_t function(cairo_font_options_t* options, cairo_font_options_t* other)cairo_font_options_equal;
+	void function(cairo_font_options_t* options, cairo_antialias_t antialias)cairo_font_options_set_antialias;
+	cairo_antialias_t function(cairo_font_options_t* options)cairo_font_options_get_antialias;
+	void function(cairo_font_options_t* options, cairo_subpixel_order_t subpixelOrder)cairo_font_options_set_subpixel_order;
+	cairo_subpixel_order_t function(cairo_font_options_t* options)cairo_font_options_get_subpixel_order;
+	void function(cairo_font_options_t* options, cairo_hint_style_t hintStyle)cairo_font_options_set_hint_style;
+	cairo_hint_style_t function(cairo_font_options_t* options)cairo_font_options_get_hint_style;
+	void function(cairo_font_options_t* options, cairo_hint_metrics_t hintMetrics)cairo_font_options_set_hint_metrics;
+	cairo_hint_metrics_t function(cairo_font_options_t* options)cairo_font_options_get_hint_metrics;
+	
+	// cairo.Surface
+	
+	cairo_surface_t* function(cairo_surface_t* other, cairo_content_t content, int width, int height)cairo_surface_create_similar;
+	void function(cairo_surface_t* surface)cairo_surface_destroy;
+	void function(cairo_surface_t* surface)cairo_surface_finish;
+	void function(cairo_surface_t* surface)cairo_surface_flush;
+	void function(cairo_surface_t* surface, cairo_font_options_t* options)cairo_surface_get_font_options;
+	cairo_content_t function(cairo_surface_t* surface)cairo_surface_get_content;
+	cairo_status_t function(cairo_surface_t* surface, cairo_user_data_key_t* key, void* userData, cairo_destroy_func_t destroy)cairo_surface_set_user_data;
+	void* function(cairo_surface_t* surface, cairo_user_data_key_t* key)cairo_surface_get_user_data;
+	void function(cairo_surface_t* surface)cairo_surface_mark_dirty;
+	void function(cairo_surface_t* surface, int x, int y, int width, int height)cairo_surface_mark_dirty_rectangle;
+	cairo_surface_t* function(cairo_surface_t* surface)cairo_surface_reference;
+	void function(cairo_surface_t* surface, double xOffset, double yOffset)cairo_surface_set_device_offset;
+	void function(cairo_surface_t* surface, double* xOffset, double* yOffset)cairo_surface_get_device_offset;
+	void function(cairo_surface_t* surface, double xPixelsPerInch, double yPixelsPerInch)cairo_surface_set_fallback_resolution;
+	cairo_status_t function(cairo_surface_t* surface)cairo_surface_status;
+	cairo_surface_type_t function(cairo_surface_t* surface)cairo_surface_get_type;
+	cairo_surface_t* function(cairo_format_t format, int width, int height)cairo_image_surface_create;
+	cairo_surface_t* function(uchar* data, cairo_format_t format, int width, int height, int stride)cairo_image_surface_create_for_data;
+	uchar* function(cairo_surface_t* surface)cairo_image_surface_get_data;
+	cairo_format_t function(cairo_surface_t* surface)cairo_image_surface_get_format;
+	int function(cairo_surface_t* surface)cairo_image_surface_get_width;
+	int function(cairo_surface_t* surface)cairo_image_surface_get_height;
+	int function(cairo_surface_t* surface)cairo_image_surface_get_stride;
+	
+	// cairo.Matrix
+	
+	void function(cairo_matrix_t* matrix, double xx, double yx, double xy, double yy, double x0, double y0)cairo_matrix_init;
+	void function(cairo_matrix_t* matrix)cairo_matrix_init_identity;
+	void function(cairo_matrix_t* matrix, double tx, double ty)cairo_matrix_init_translate;
+	void function(cairo_matrix_t* matrix, double sx, double sy)cairo_matrix_init_scale;
+	void function(cairo_matrix_t* matrix, double radians)cairo_matrix_init_rotate;
+	void function(cairo_matrix_t* matrix, double tx, double ty)cairo_matrix_translate;
+	void function(cairo_matrix_t* matrix, double sx, double sy)cairo_matrix_scale;
+	void function(cairo_matrix_t* matrix, double radians)cairo_matrix_rotate;
+	cairo_status_t function(cairo_matrix_t* matrix)cairo_matrix_invert;
+	void function(cairo_matrix_t* result, cairo_matrix_t* a, cairo_matrix_t* b)cairo_matrix_multiply;
+	void function(cairo_matrix_t* matrix, double* dx, double* dy)cairo_matrix_transform_distance;
+	void function(cairo_matrix_t* matrix, double* x, double* y)cairo_matrix_transform_point;
+	
+	// cairo.Status
+	
+	char* function(cairo_status_t status)cairo_status_to_string;
+	void function()cairo_debug_reset_static_data;
+	
+	// cairo.Version
+	
+	int function()cairo_version;
+	char* function()cairo_version_string;
+	
+	// cairo.
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+Symbol[] cairoLinks = 
+[
+
+	{ "cairo_create",  cast(void**)& cairo_create},
+	{ "cairo_reference",  cast(void**)& cairo_reference},
+	{ "cairo_destroy",  cast(void**)& cairo_destroy},
+	{ "cairo_status",  cast(void**)& cairo_status},
+	{ "cairo_save",  cast(void**)& cairo_save},
+	{ "cairo_restore",  cast(void**)& cairo_restore},
+	{ "cairo_get_target",  cast(void**)& cairo_get_target},
+	{ "cairo_push_group",  cast(void**)& cairo_push_group},
+	{ "cairo_push_group_with_content",  cast(void**)& cairo_push_group_with_content},
+	{ "cairo_pop_group",  cast(void**)& cairo_pop_group},
+	{ "cairo_pop_group_to_source",  cast(void**)& cairo_pop_group_to_source},
+	{ "cairo_get_group_target",  cast(void**)& cairo_get_group_target},
+	{ "cairo_set_source_rgb",  cast(void**)& cairo_set_source_rgb},
+	{ "cairo_set_source_rgba",  cast(void**)& cairo_set_source_rgba},
+	{ "cairo_set_source",  cast(void**)& cairo_set_source},
+	{ "cairo_set_source_surface",  cast(void**)& cairo_set_source_surface},
+	{ "cairo_get_source",  cast(void**)& cairo_get_source},
+	{ "cairo_set_antialias",  cast(void**)& cairo_set_antialias},
+	{ "cairo_get_antialias",  cast(void**)& cairo_get_antialias},
+	{ "cairo_set_dash",  cast(void**)& cairo_set_dash},
+	{ "cairo_set_fill_rule",  cast(void**)& cairo_set_fill_rule},
+	{ "cairo_get_fill_rule",  cast(void**)& cairo_get_fill_rule},
+	{ "cairo_set_line_cap",  cast(void**)& cairo_set_line_cap},
+	{ "cairo_get_line_cap",  cast(void**)& cairo_get_line_cap},
+	{ "cairo_set_line_join",  cast(void**)& cairo_set_line_join},
+	{ "cairo_get_line_join",  cast(void**)& cairo_get_line_join},
+	{ "cairo_set_line_width",  cast(void**)& cairo_set_line_width},
+	{ "cairo_get_line_width",  cast(void**)& cairo_get_line_width},
+	{ "cairo_set_miter_limit",  cast(void**)& cairo_set_miter_limit},
+	{ "cairo_get_miter_limit",  cast(void**)& cairo_get_miter_limit},
+	{ "cairo_set_operator",  cast(void**)& cairo_set_operator},
+	{ "cairo_get_operator",  cast(void**)& cairo_get_operator},
+	{ "cairo_set_tolerance",  cast(void**)& cairo_set_tolerance},
+	{ "cairo_get_tolerance",  cast(void**)& cairo_get_tolerance},
+	{ "cairo_clip",  cast(void**)& cairo_clip},
+	{ "cairo_clip_preserve",  cast(void**)& cairo_clip_preserve},
+	{ "cairo_reset_clip",  cast(void**)& cairo_reset_clip},
+	{ "cairo_fill",  cast(void**)& cairo_fill},
+	{ "cairo_fill_preserve",  cast(void**)& cairo_fill_preserve},
+	{ "cairo_fill_extents",  cast(void**)& cairo_fill_extents},
+	{ "cairo_in_fill",  cast(void**)& cairo_in_fill},
+	{ "cairo_mask",  cast(void**)& cairo_mask},
+	{ "cairo_mask_surface",  cast(void**)& cairo_mask_surface},
+	{ "cairo_paint",  cast(void**)& cairo_paint},
+	{ "cairo_paint_with_alpha",  cast(void**)& cairo_paint_with_alpha},
+	{ "cairo_stroke",  cast(void**)& cairo_stroke},
+	{ "cairo_stroke_preserve",  cast(void**)& cairo_stroke_preserve},
+	{ "cairo_stroke_extents",  cast(void**)& cairo_stroke_extents},
+	{ "cairo_in_stroke",  cast(void**)& cairo_in_stroke},
+	{ "cairo_copy_page",  cast(void**)& cairo_copy_page},
+	{ "cairo_show_page",  cast(void**)& cairo_show_page},
+	{ "cairo_copy_path",  cast(void**)& cairo_copy_path},
+	{ "cairo_copy_path_flat",  cast(void**)& cairo_copy_path_flat},
+	{ "cairo_path_destroy",  cast(void**)& cairo_path_destroy},
+	{ "cairo_append_path",  cast(void**)& cairo_append_path},
+	{ "cairo_get_current_point",  cast(void**)& cairo_get_current_point},
+	{ "cairo_new_path",  cast(void**)& cairo_new_path},
+	{ "cairo_new_sub_path",  cast(void**)& cairo_new_sub_path},
+	{ "cairo_close_path",  cast(void**)& cairo_close_path},
+	{ "cairo_arc",  cast(void**)& cairo_arc},
+	{ "cairo_arc_negative",  cast(void**)& cairo_arc_negative},
+	{ "cairo_curve_to",  cast(void**)& cairo_curve_to},
+	{ "cairo_line_to",  cast(void**)& cairo_line_to},
+	{ "cairo_move_to",  cast(void**)& cairo_move_to},
+	{ "cairo_rectangle",  cast(void**)& cairo_rectangle},
+	{ "cairo_glyph_path",  cast(void**)& cairo_glyph_path},
+	{ "cairo_text_path",  cast(void**)& cairo_text_path},
+	{ "cairo_rel_curve_to",  cast(void**)& cairo_rel_curve_to},
+	{ "cairo_rel_line_to",  cast(void**)& cairo_rel_line_to},
+	{ "cairo_rel_move_to",  cast(void**)& cairo_rel_move_to},
+	{ "cairo_translate",  cast(void**)& cairo_translate},
+	{ "cairo_scale",  cast(void**)& cairo_scale},
+	{ "cairo_rotate",  cast(void**)& cairo_rotate},
+	{ "cairo_transform",  cast(void**)& cairo_transform},
+	{ "cairo_set_matrix",  cast(void**)& cairo_set_matrix},
+	{ "cairo_get_matrix",  cast(void**)& cairo_get_matrix},
+	{ "cairo_identity_matrix",  cast(void**)& cairo_identity_matrix},
+	{ "cairo_user_to_device",  cast(void**)& cairo_user_to_device},
+	{ "cairo_user_to_device_distance",  cast(void**)& cairo_user_to_device_distance},
+	{ "cairo_device_to_user",  cast(void**)& cairo_device_to_user},
+	{ "cairo_device_to_user_distance",  cast(void**)& cairo_device_to_user_distance},
+	{ "cairo_select_font_face",  cast(void**)& cairo_select_font_face},
+	{ "cairo_set_font_size",  cast(void**)& cairo_set_font_size},
+	{ "cairo_set_font_matrix",  cast(void**)& cairo_set_font_matrix},
+	{ "cairo_get_font_matrix",  cast(void**)& cairo_get_font_matrix},
+	{ "cairo_set_font_options",  cast(void**)& cairo_set_font_options},
+	{ "cairo_get_font_options",  cast(void**)& cairo_get_font_options},
+	{ "cairo_show_text",  cast(void**)& cairo_show_text},
+	{ "cairo_show_glyphs",  cast(void**)& cairo_show_glyphs},
+	{ "cairo_get_font_face",  cast(void**)& cairo_get_font_face},
+	{ "cairo_font_extents",  cast(void**)& cairo_font_extents},
+	{ "cairo_set_font_face",  cast(void**)& cairo_set_font_face},
+	{ "cairo_set_scaled_font",  cast(void**)& cairo_set_scaled_font},
+	{ "cairo_text_extents",  cast(void**)& cairo_text_extents},
+	{ "cairo_glyph_extents",  cast(void**)& cairo_glyph_extents},
+	{ "cairo_pattern_add_color_stop_rgb",  cast(void**)& cairo_pattern_add_color_stop_rgb},
+	{ "cairo_pattern_add_color_stop_rgba",  cast(void**)& cairo_pattern_add_color_stop_rgba},
+	{ "cairo_pattern_create_rgb",  cast(void**)& cairo_pattern_create_rgb},
+	{ "cairo_pattern_create_rgba",  cast(void**)& cairo_pattern_create_rgba},
+	{ "cairo_pattern_create_for_surface",  cast(void**)& cairo_pattern_create_for_surface},
+	{ "cairo_pattern_create_linear",  cast(void**)& cairo_pattern_create_linear},
+	{ "cairo_pattern_create_radial",  cast(void**)& cairo_pattern_create_radial},
+	{ "cairo_pattern_destroy",  cast(void**)& cairo_pattern_destroy},
+	{ "cairo_pattern_reference",  cast(void**)& cairo_pattern_reference},
+	{ "cairo_pattern_status",  cast(void**)& cairo_pattern_status},
+	{ "cairo_pattern_set_extend",  cast(void**)& cairo_pattern_set_extend},
+	{ "cairo_pattern_get_extend",  cast(void**)& cairo_pattern_get_extend},
+	{ "cairo_pattern_set_filter",  cast(void**)& cairo_pattern_set_filter},
+	{ "cairo_pattern_get_filter",  cast(void**)& cairo_pattern_get_filter},
+	{ "cairo_pattern_set_matrix",  cast(void**)& cairo_pattern_set_matrix},
+	{ "cairo_pattern_get_matrix",  cast(void**)& cairo_pattern_get_matrix},
+	{ "cairo_pattern_get_type",  cast(void**)& cairo_pattern_get_type},
+	{ "cairo_font_face_reference",  cast(void**)& cairo_font_face_reference},
+	{ "cairo_font_face_destroy",  cast(void**)& cairo_font_face_destroy},
+	{ "cairo_font_face_status",  cast(void**)& cairo_font_face_status},
+	{ "cairo_font_face_get_user_data",  cast(void**)& cairo_font_face_get_user_data},
+	{ "cairo_font_face_set_user_data",  cast(void**)& cairo_font_face_set_user_data},
+	{ "cairo_font_face_get_type",  cast(void**)& cairo_font_face_get_type},
+	{ "cairo_scaled_font_create",  cast(void**)& cairo_scaled_font_create},
+	{ "cairo_scaled_font_reference",  cast(void**)& cairo_scaled_font_reference},
+	{ "cairo_scaled_font_destroy",  cast(void**)& cairo_scaled_font_destroy},
+	{ "cairo_scaled_font_status",  cast(void**)& cairo_scaled_font_status},
+	{ "cairo_scaled_font_extents",  cast(void**)& cairo_scaled_font_extents},
+	{ "cairo_scaled_font_text_extents",  cast(void**)& cairo_scaled_font_text_extents},
+	{ "cairo_scaled_font_glyph_extents",  cast(void**)& cairo_scaled_font_glyph_extents},
+	{ "cairo_scaled_font_get_font_face",  cast(void**)& cairo_scaled_font_get_font_face},
+	{ "cairo_scaled_font_get_font_options",  cast(void**)& cairo_scaled_font_get_font_options},
+	{ "cairo_scaled_font_get_font_matrix",  cast(void**)& cairo_scaled_font_get_font_matrix},
+	{ "cairo_scaled_font_get_ctm",  cast(void**)& cairo_scaled_font_get_ctm},
+	{ "cairo_scaled_font_get_type",  cast(void**)& cairo_scaled_font_get_type},
+	{ "cairo_font_options_create",  cast(void**)& cairo_font_options_create},
+	{ "cairo_font_options_copy",  cast(void**)& cairo_font_options_copy},
+	{ "cairo_font_options_destroy",  cast(void**)& cairo_font_options_destroy},
+	{ "cairo_font_options_status",  cast(void**)& cairo_font_options_status},
+	{ "cairo_font_options_merge",  cast(void**)& cairo_font_options_merge},
+	{ "cairo_font_options_hash",  cast(void**)& cairo_font_options_hash},
+	{ "cairo_font_options_equal",  cast(void**)& cairo_font_options_equal},
+	{ "cairo_font_options_set_antialias",  cast(void**)& cairo_font_options_set_antialias},
+	{ "cairo_font_options_get_antialias",  cast(void**)& cairo_font_options_get_antialias},
+	{ "cairo_font_options_set_subpixel_order",  cast(void**)& cairo_font_options_set_subpixel_order},
+	{ "cairo_font_options_get_subpixel_order",  cast(void**)& cairo_font_options_get_subpixel_order},
+	{ "cairo_font_options_set_hint_style",  cast(void**)& cairo_font_options_set_hint_style},
+	{ "cairo_font_options_get_hint_style",  cast(void**)& cairo_font_options_get_hint_style},
+	{ "cairo_font_options_set_hint_metrics",  cast(void**)& cairo_font_options_set_hint_metrics},
+	{ "cairo_font_options_get_hint_metrics",  cast(void**)& cairo_font_options_get_hint_metrics},
+	{ "cairo_surface_create_similar",  cast(void**)& cairo_surface_create_similar},
+	{ "cairo_surface_destroy",  cast(void**)& cairo_surface_destroy},
+	{ "cairo_surface_finish",  cast(void**)& cairo_surface_finish},
+	{ "cairo_surface_flush",  cast(void**)& cairo_surface_flush},
+	{ "cairo_surface_get_font_options",  cast(void**)& cairo_surface_get_font_options},
+	{ "cairo_surface_get_content",  cast(void**)& cairo_surface_get_content},
+	{ "cairo_surface_set_user_data",  cast(void**)& cairo_surface_set_user_data},
+	{ "cairo_surface_get_user_data",  cast(void**)& cairo_surface_get_user_data},
+	{ "cairo_surface_mark_dirty",  cast(void**)& cairo_surface_mark_dirty},
+	{ "cairo_surface_mark_dirty_rectangle",  cast(void**)& cairo_surface_mark_dirty_rectangle},
+	{ "cairo_surface_reference",  cast(void**)& cairo_surface_reference},
+	{ "cairo_surface_set_device_offset",  cast(void**)& cairo_surface_set_device_offset},
+	{ "cairo_surface_get_device_offset",  cast(void**)& cairo_surface_get_device_offset},
+	{ "cairo_surface_set_fallback_resolution",  cast(void**)& cairo_surface_set_fallback_resolution},
+	{ "cairo_surface_status",  cast(void**)& cairo_surface_status},
+	{ "cairo_surface_get_type",  cast(void**)& cairo_surface_get_type},
+	{ "cairo_image_surface_create",  cast(void**)& cairo_image_surface_create},
+	{ "cairo_image_surface_create_for_data",  cast(void**)& cairo_image_surface_create_for_data},
+	{ "cairo_image_surface_get_data",  cast(void**)& cairo_image_surface_get_data},
+	{ "cairo_image_surface_get_format",  cast(void**)& cairo_image_surface_get_format},
+	{ "cairo_image_surface_get_width",  cast(void**)& cairo_image_surface_get_width},
+	{ "cairo_image_surface_get_height",  cast(void**)& cairo_image_surface_get_height},
+	{ "cairo_image_surface_get_stride",  cast(void**)& cairo_image_surface_get_stride},
+	{ "cairo_matrix_init",  cast(void**)& cairo_matrix_init},
+	{ "cairo_matrix_init_identity",  cast(void**)& cairo_matrix_init_identity},
+	{ "cairo_matrix_init_translate",  cast(void**)& cairo_matrix_init_translate},
+	{ "cairo_matrix_init_scale",  cast(void**)& cairo_matrix_init_scale},
+	{ "cairo_matrix_init_rotate",  cast(void**)& cairo_matrix_init_rotate},
+	{ "cairo_matrix_translate",  cast(void**)& cairo_matrix_translate},
+	{ "cairo_matrix_scale",  cast(void**)& cairo_matrix_scale},
+	{ "cairo_matrix_rotate",  cast(void**)& cairo_matrix_rotate},
+	{ "cairo_matrix_invert",  cast(void**)& cairo_matrix_invert},
+	{ "cairo_matrix_multiply",  cast(void**)& cairo_matrix_multiply},
+	{ "cairo_matrix_transform_distance",  cast(void**)& cairo_matrix_transform_distance},
+	{ "cairo_matrix_transform_point",  cast(void**)& cairo_matrix_transform_point},
+	{ "cairo_status_to_string",  cast(void**)& cairo_status_to_string},
+	{ "cairo_debug_reset_static_data",  cast(void**)& cairo_debug_reset_static_data},
+	{ "cairo_version",  cast(void**)& cairo_version},
+	{ "cairo_version_string",  cast(void**)& cairo_version_string},
+
+];

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/cairotypes.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,548 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.cairotypes;
+
+public import dwt.internal.gtk.c.glibtypes;
+
+/******************************************************************************
+
+******************************************************************************/
+
+private alias void* HDC;
+
+//struct Display;	// to support XLib surfaces
+//struct Visual;	// to support XLib surfaces
+//struct Screen;	// to support XLib surfaces
+
+//private alias void* Drawable;
+//private alias void* Pixmap;
+//public alias bool cairo_bool_t;
+
+alias ubyte uchar;
+
+/**
+ * typedef int cairo_bool_t;
+ * cairo_bool_t is used for boolean values. Returns of type
+ * cairo_bool_t will always be either 0 or 1, but testing against
+ * these values explicitly is not encouraged; just use the
+ * value as a boolean condition.
+ */
+public alias int cairo_bool_t;
+/**
+ * Specifies the type of antialiasing to do when rendering text or shapes.
+ * CAIRO_ANTIALIAS_DEFAULT
+ */
+public enum cairo_antialias_t
+{
+	DEFAULT,
+	NONE,
+	GRAY,
+	SUBPIXEL
+}
+/**
+ * cairo_fill_rule_t is used to select how paths are filled. For both
+ * fill rules, whether or not a point is included in the fill is
+ * determined by taking a ray from that point to infinity and looking
+ * at intersections with the path. The ray can be in any direction,
+ * as long as it doesn't pass through the end point of a segment
+ * or have a tricky intersection such as intersecting tangent to the path.
+ * (Note that filling is not actually implemented in this way. This
+ * is just a description of the rule that is applied.)
+ * New entries may be added in future versions.
+ * CAIRO_FILL_RULE_WINDING
+ */
+public enum cairo_fill_rule_t
+{
+	WINDING,
+	EVEN_ODD
+}
+/**
+ * enumeration for style of line-endings
+ * CAIRO_LINE_CAP_BUTT
+ */
+public enum cairo_line_cap_t
+{
+	BUTT,
+	ROUND,
+	SQUARE
+}
+public enum cairo_line_join_t
+{
+	MITER,
+	ROUND,
+	BEVEL
+}
+public enum cairo_operator_t
+{
+	CLEAR,
+	SOURCE,
+	OVER,
+	IN,
+	OUT,
+	ATOP,
+	DEST,
+	DEST_OVER,
+	DEST_IN,
+	DEST_OUT,
+	DEST_ATOP,
+	XOR,
+	ADD,
+	SATURATE
+}
+public enum cairo_path_data_type_t
+{
+	MOVE_TO,
+	LINE_TO,
+	CURVE_TO,
+	CLOSE_PATH
+}
+public enum cairo_font_slant_t
+{
+	NORMAL,
+	ITALIC,
+	OBLIQUE
+}
+public enum cairo_font_weight_t
+{
+	NORMAL,
+	BOLD
+}
+/**
+ * cairo_extend_t is used to describe how the area outside
+ * of a pattern will be drawn.
+ * New entries may be added in future versions.
+ * CAIRO_EXTEND_NONE
+ */
+public enum cairo_extend_t
+{
+	NONE,
+	REPEAT,
+	REFLECT,
+	PAD
+}
+public enum cairo_filter_t
+{
+	FAST,
+	GOOD,
+	BEST,
+	NEAREST,
+	BILINEAR,
+	GAUSSIAN
+}
+/**
+ * cairo_pattern_type_t is used to describe the type of a given pattern.
+ * The type of a pattern is determined by the function used to create
+ * it. The cairo_pattern_create_rgb() and cairo_pattern_create_rgba()
+ * functions create SOLID patterns. The remaining
+ * cairo_pattern_create functions map to pattern types in obvious
+ * ways.
+ * The pattern type can be queried with cairo_pattern_get_type()
+ * Most cairo_pattern functions can be called with a pattern of any
+ * type, (though trying to change the extend or filter for a solid
+ * pattern will have no effect). A notable exception is
+ * cairo_pattern_add_color_stop_rgb() and
+ * cairo_pattern_add_color_stop_rgba() which must only be called with
+ * gradient patterns (either LINEAR or RADIAL). Otherwise the pattern
+ * will be shutdown and put into an error state.
+ * New entries may be added in future versions.
+ * CAIRO_PATTERN_TYPE_SOLID
+ */
+public enum cairo_pattern_type_t
+{
+	SOLID,
+	SURFACE,
+	LINEAR,
+	RADIAL
+}
+/**
+ * cairo_font_type_t is used to describe the type of a given font
+ * face or scaled font. The font types are also known as "font
+ * backends" within cairo.
+ * The type of a font face is determined by the function used to
+ * create it, which will generally be of the form
+ * cairo_type_font_face_create. The font face type can be queried
+ * with cairo_font_face_get_type()
+ * The various cairo_font_face functions can be used with a font face
+ * of any type.
+ * The type of a scaled font is determined by the type of the font
+ * face passed to cairo_scaled_font_create. The scaled font type can
+ * be queried with cairo_scaled_font_get_type()
+ * The various cairo_scaled_font functions can be used with scaled
+ * fonts of any type, but some font backends also provide
+ * type-specific functions that must only be called with a scaled font
+ * of the appropriate type. These functions have names that begin with
+ * cairo_type_scaled_font such as cairo_ft_scaled_font_lock_face.
+ * The behavior of calling a type-specific function with a scaled font
+ * of the wrong type is undefined.
+ * New entries may be added in future versions.
+ * CAIRO_FONT_TYPE_TOY
+ */
+public enum cairo_font_type_t
+{
+	TOY,
+	FT,
+	WIN32,
+	ATSUI
+}
+/**
+ * The subpixel order specifies the order of color elements within
+ * each pixel on the display device when rendering with an
+ * antialiasing mode of CAIRO_ANTIALIAS_SUBPIXEL.
+ * CAIRO_SUBPIXEL_ORDER_DEFAULT
+ */
+public enum cairo_subpixel_order_t
+{
+	DEFAULT,
+	RGB,
+	BGR,
+	VRGB,
+	VBGR
+}
+/**
+ * Specifies the type of hinting to do on font outlines. Hinting
+ * is the process of fitting outlines to the pixel grid in order
+ * to improve the appearance of the result. Since hinting outlines
+ * involves distorting them, it also reduces the faithfulness
+ * to the original outline shapes. Not all of the outline hinting
+ * styles are supported by all font backends.
+ * New entries may be added in future versions.
+ * CAIRO_HINT_STYLE_DEFAULT
+ */
+public enum cairo_hint_style_t
+{
+	DEFAULT,
+	NONE,
+	SLIGHT,
+	MEDIUM,
+	FULL
+}
+/**
+ * Specifies whether to hint font metrics; hinting font metrics
+ * means quantizing them so that they are integer values in
+ * device space. Doing this improves the consistency of
+ * letter and line spacing, however it also means that text
+ * will be laid out differently at different zoom factors.
+ * CAIRO_HINT_METRICS_DEFAULT
+ */
+public enum cairo_hint_metrics_t
+{
+	DEFAULT,
+	OFF,
+	ON
+}
+/**
+ * cairo_content_t is used to describe the content that a surface will
+ * contain, whether color information, alpha information (translucence
+ * vs. opacity), or both.
+ * Note: The large values here are designed to keep cairo_content_t
+ * values distinct from cairo_format_t values so that the
+ * implementation can detect the error if users confuse the two types.
+ * CAIRO_CONTENT_COLOR
+ */
+public enum cairo_content_t
+{
+	COLOR = 0x1000,
+	ALPHA = 0x2000,
+	COLOR_ALPHA = 0x3000
+}
+/**
+ * cairo_surface_type_t is used to describe the type of a given
+ * surface. The surface types are also known as "backends" or "surface
+ * backends" within cairo.
+ * The type of a surface is determined by the function used to create
+ * it, which will generally be of the form cairo_type_surface_create,
+ * (though see cairo_surface_create_similar as well).
+ * The surface type can be queried with cairo_surface_get_type()
+ * The various cairo_surface functions can be used with surfaces of
+ * any type, but some backends also provide type-specific functions
+ * that must only be called with a surface of the appropriate
+ * type. These functions have names that begin with
+ * cairo_type_surface such as cairo_image_surface_get_width().
+ * The behavior of calling a type-specific function with a surface of
+ * the wrong type is undefined.
+ * New entries may be added in future versions.
+ * CAIRO_SURFACE_TYPE_IMAGE
+ */
+public enum cairo_surface_type_t
+{
+	IMAGE,
+	PDF,
+	PS,
+	XLIB,
+	XCB,
+	GLITZ,
+	QUARTZ,
+	WIN32,
+	BEOS,
+	DIRECTFB,
+	SVG
+}
+/**
+ * cairo_format_t is used to identify the memory format of
+ * image data.
+ * New entries may be added in future versions.
+ * CAIRO_FORMAT_ARGB32
+ */
+public enum cairo_format_t
+{
+	ARGB32,
+	RGB24,
+	A8,
+	A1,
+	RGB16_565
+}
+/**
+ * cairo_status_t is used to indicate errors that can occur when
+ * using Cairo. In some cases it is returned directly by functions.
+ * but when using cairo_t, the last error, if any, is stored in
+ * the context and can be retrieved with cairo_status().
+ * New entries may be added in future versions. Use cairo_status_to_string()
+ * to get a human-readable representation of an error message.
+ * CAIRO_STATUS_SUCCESS
+ */
+public enum cairo_status_t
+{
+	SUCCESS = 0,
+	NO_MEMORY,
+	INVALID_RESTORE,
+	INVALID_POP_GROUP,
+	NO_CURRENT_POINT,
+	INVALID_MATRIX,
+	INVALID_STATUS,
+	NULL_POINTER,
+	INVALID_STRING,
+	INVALID_PATH_DATA,
+	READ_ERROR,
+	WRITE_ERROR,
+	SURFACE_FINISHED,
+	SURFACE_TYPE_MISMATCH,
+	PATTERN_TYPE_MISMATCH,
+	INVALID_CONTENT,
+	INVALID_FORMAT,
+	INVALID_VISUAL,
+	FILE_NOT_FOUND,
+	INVALID_DASH,
+	INVALID_DSC_COMMENT
+}
+
+/**
+ * Main Gtk struct.
+ * A cairo_t contains the current state of the rendering device,
+ * including coordinates of yet to be drawn shapes.
+ */
+public struct cairo_t{}
+
+
+/**
+ * A data structure for holding a path. This data structure serves as
+ * the return value for cairo_copy_path() and
+ * cairo_copy_path_flat() as well the input value for
+ * cairo_append_path().
+ * See cairo_path_data_t for hints on how to iterate over the
+ * actual data within the path.
+ * The num_data member gives the number of elements in the data
+ * array. This number is larger than the number of independent path
+ * portions (defined in cairo_path_data_type_t), since the data
+ * includes both headers and coordinates for each portion.
+ * cairo_status_tstatus;
+ */
+public struct cairo_path_t{}
+// cairo_status_t status;
+// cairo-Paths.html
+// cairo_path_data_t *data;
+// cairo-Paths.html
+// int numData;
+// cairo-Paths.html
+
+
+/**
+ * The cairo_glyph_t structure holds information about a single glyph
+ * when drawing or measuring text. A font is (in simple terms) a
+ * collection of shapes used to draw text. A glyph is one of these
+ * shapes. There can be multiple glyphs for a single character
+ * (alternates to be used in different contexts, for example), or a
+ * glyph can be a ligature of multiple
+ * characters. Cairo doesn't expose any way of converting input text
+ * into glyphs, so in order to use the Cairo interfaces that take
+ * arrays of glyphs, you must directly access the appropriate
+ * underlying font system.
+ * Note that the offsets given by x and y are not cumulative. When
+ * drawing or measuring text, each glyph is individually positioned
+ * with respect to the overall origin
+ * unsignedlongindex;
+ */
+public struct cairo_glyph_t{}
+// unsigned long index;
+// cairo-Text.html
+// double x;
+// cairo-Text.html
+// double y;
+// cairo-Text.html
+
+
+/**
+ * Main Gtk struct.
+ */
+public struct cairo_pattern_t{}
+
+
+/**
+ * Main Gtk struct.
+ * A cairo_font_face_t specifies all aspects of a font other
+ * than the size or font matrix (a font matrix is used to distort
+ * a font by sheering it or scaling it unequally in the two
+ * directions) . A font face can be set on a cairo_t by using
+ * cairo_set_font_face(); the size and font matrix are set with
+ * cairo_set_font_size() and cairo_set_font_matrix().
+ */
+public struct cairo_font_face_t{}
+
+
+/**
+ * Main Gtk struct.
+ * A cairo_scaled_font_t is a font scaled to a particular size and device
+ * resolution. A cairo_scaled_font_t is most useful for low-level font
+ * usage where a library or application wants to cache a reference
+ * to a scaled font to speed up the computation of metrics.
+ */
+public struct cairo_scaled_font_t{}
+
+
+/**
+ * The cairo_font_extents_t structure stores metric information for
+ * a font. Values are given in the current user-space coordinate
+ * system.
+ * Because font metrics are in user-space coordinates, they are
+ * mostly, but not entirely, independent of the current transformation
+ * matrix. If you call cairo_scale(cr, 2.0, 2.0),
+ * text will be drawn twice as big, but the reported text extents will
+ * not be doubled. They will change slightly due to hinting (so you
+ * can't assume that metrics are independent of the transformation
+ * matrix), but otherwise will remain unchanged.
+ * doubleascent;
+ */
+public struct cairo_font_extents_t{}
+// double ascent;
+// cairo-Scaled-Fonts.html
+// double descent;
+// cairo-Scaled-Fonts.html
+// double height;
+// cairo-Scaled-Fonts.html
+// double maxXAdvance;
+// cairo-Scaled-Fonts.html
+// double maxYAdvance;
+// cairo-Scaled-Fonts.html
+
+
+/**
+ * The cairo_text_extents_t structure stores the extents of a single
+ * glyph or a string of glyphs in user-space coordinates. Because text
+ * extents are in user-space coordinates, they are mostly, but not
+ * entirely, independent of the current transformation matrix. If you call
+ * cairo_scale(cr, 2.0, 2.0), text will
+ * be drawn twice as big, but the reported text extents will not be
+ * doubled. They will change slightly due to hinting (so you can't
+ * assume that metrics are independent of the transformation matrix),
+ * but otherwise will remain unchanged.
+ * doublex_bearing;
+ */
+public struct cairo_text_extents_t{}
+// double xBearing;
+// cairo-Scaled-Fonts.html
+// double yBearing;
+// cairo-Scaled-Fonts.html
+// double width;
+// cairo-Scaled-Fonts.html
+// double height;
+// cairo-Scaled-Fonts.html
+// double xAdvance;
+// cairo-Scaled-Fonts.html
+// double yAdvance;
+// cairo-Scaled-Fonts.html
+
+
+/**
+ * Main Gtk struct.
+ */
+public struct cairo_font_options_t{}
+
+
+/**
+ * Main Gtk struct.
+ * A cairo_surface_t represents an image, either as the destination
+ * of a drawing operation or as source when drawing onto another
+ * surface. There are different subtypes of cairo_surface_t for
+ * different drawing backends; for example, cairo_image_surface_create()
+ * creates a bitmap image in memory.
+ * Memory management of cairo_surface_t is done with
+ * cairo_surface_reference() and cairo_surface_destroy().
+ */
+public struct cairo_surface_t{}
+
+
+/**
+ * Main Gtk struct.
+ * A cairo_matrix_t holds an affine transformation, such as a scale,
+ * rotation, shear, or a combination of those. The transformation of
+ * a point (x, y) is given by:
+ */
+public struct cairo_matrix_t{}
+// double xx; double yx;
+// cairo-cairo-matrix-t.html
+// double xy; double yy;
+// cairo-cairo-matrix-t.html
+// double x0; double y0;
+// cairo-cairo-matrix-t.html
+
+
+/**
+ * cairo_user_data_key_t is used for attaching user data to cairo
+ * data structures. The actual contents of the struct is never used,
+ * and there is no need to initialize the object; only the unique
+ * address of a cairo_data_key_t object is used. Typically, you
+ * would just use the address of a static cairo_data_key_t object.
+ * intunused;
+ */
+public struct cairo_user_data_key_t{}
+// int unused;
+// cairo-Types.html
+
+
+/*
+ * major:
+ * minor:
+ * micro:
+ */
+// TODO
+// #define CAIRO_VERSION_ENCODE(major, minor, micro)
+
+/*
+ * cairo_destroy_func_t the type of function which is called when a
+ * data element is destroyed. It is passed the pointer to the data
+ * element and should free any memory and resources allocated for it.
+ * data:
+ *  The data element being destroyed.
+ */
+// void (*cairo_destroy_func_t) (void *data);
+public typedef extern(C) void  function (void*) cairo_destroy_func_t;
+
+// skipped union cairo_path_data_t
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/gdk.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,1368 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.gdk;
+
+private import dwt.internal.gtk.c.gdktypes;
+private import dwt.internal.gtk.c.cairotypes;
+private import dwt.internal.gtk.runtime.Loader;
+
+/******************************************************************************
+
+******************************************************************************/
+
+private Linker gdkLinker;
+
+/******************************************************************************
+
+******************************************************************************/
+
+static this()
+{
+    gdkLinker = new Linker( getLibraryPath ~ importLibs[LIBRARY.GDK], 
+                            getLibraryPath ~ importLibs[LIBRARY.GDKPIXBUF] );
+    gdkLinker.link( gdkLinks );
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+static ~this()
+{
+    delete gdkLinker;
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+extern(C) 
+{	
+	// gdk.Gdk
+	
+	void function(gint* argc, gchar*** argv)gdk_init;
+	gboolean function(gint* argc, gchar*** argv)gdk_init_check;
+	void function(gint* argc, gchar*** argv)gdk_parse_args;
+	gchar* function()gdk_get_display_arg_name;
+	gchar* function()gdk_set_locale;
+	void function(gchar* smClientId)gdk_set_sm_client_id;
+	void function(gint errorCode)gdk_exit;
+	void function()gdk_notify_startup_complete;
+	void function(gchar* startupId)gdk_notify_startup_complete_with_id;
+	char* function()gdk_get_program_class;
+	void function(char* programClass)gdk_set_program_class;
+	gchar* function()gdk_get_display;
+	void function()gdk_flush;
+	gint function()gdk_screen_width;
+	gint function()gdk_screen_height;
+	gint function()gdk_screen_width_mm;
+	gint function()gdk_screen_height_mm;
+	GdkGrabStatus function(GdkWindow* window, gboolean ownerEvents, GdkEventMask eventMask, GdkWindow* confineTo, GdkCursor* cursor, guint32 time)gdk_pointer_grab;
+	void function(guint32 time)gdk_pointer_ungrab;
+	gboolean function()gdk_pointer_is_grabbed;
+	void function(guint msec)gdk_set_double_click_time;
+	GdkGrabStatus function(GdkWindow* window, gboolean ownerEvents, guint32 time)gdk_keyboard_grab;
+	void function(guint32 time)gdk_keyboard_ungrab;
+	void function()gdk_beep;
+	gboolean function()gdk_get_use_xshm;
+	void function(gboolean useXshm)gdk_set_use_xshm;
+	void function()gdk_error_trap_push;
+	gint function()gdk_error_trap_pop;
+	
+	// gdk.Display
+	
+	GdkDisplay* function(gchar* displayName)gdk_display_open;
+	GdkDisplay* function()gdk_display_get_default;
+	gchar* function(GdkDisplay* display)gdk_display_get_name;
+	gint function(GdkDisplay* display)gdk_display_get_n_screens;
+	GdkScreen* function(GdkDisplay* display, gint screenNum)gdk_display_get_screen;
+	GdkScreen* function(GdkDisplay* display)gdk_display_get_default_screen;
+	void function(GdkDisplay* display, guint32 time)gdk_display_pointer_ungrab;
+	void function(GdkDisplay* display, guint32 time)gdk_display_keyboard_ungrab;
+	gboolean function(GdkDisplay* display)gdk_display_pointer_is_grabbed;
+	void function(GdkDisplay* display)gdk_display_beep;
+	void function(GdkDisplay* display)gdk_display_sync;
+	void function(GdkDisplay* display)gdk_display_flush;
+	void function(GdkDisplay* display)gdk_display_close;
+	GList* function(GdkDisplay* display)gdk_display_list_devices;
+	GdkEvent* function(GdkDisplay* display)gdk_display_get_event;
+	GdkEvent* function(GdkDisplay* display)gdk_display_peek_event;
+	void function(GdkDisplay* display, GdkEvent* event)gdk_display_put_event;
+	void function(GdkDisplay* display, GdkAtom messageType, GdkFilterFunc func, gpointer data)gdk_display_add_client_message_filter;
+	void function(GdkDisplay* display, guint msec)gdk_display_set_double_click_time;
+	void function(GdkDisplay* display, guint distance)gdk_display_set_double_click_distance;
+	void function(GdkDisplay* display, GdkScreen** screen, gint* x, gint* y, GdkModifierType* mask)gdk_display_get_pointer;
+	GdkWindow* function(GdkDisplay* display, gint* winX, gint* winY)gdk_display_get_window_at_pointer;
+	GdkDisplayPointerHooks* function(GdkDisplay* display, GdkDisplayPointerHooks* newHooks)gdk_display_set_pointer_hooks;
+	void function(GdkDisplay* display, GdkScreen* screen, gint x, gint y)gdk_display_warp_pointer;
+	gboolean function(GdkDisplay* display)gdk_display_supports_cursor_color;
+	gboolean function(GdkDisplay* display)gdk_display_supports_cursor_alpha;
+	guint function(GdkDisplay* display)gdk_display_get_default_cursor_size;
+	void function(GdkDisplay* display, guint* width, guint* height)gdk_display_get_maximal_cursor_size;
+	GdkWindow* function(GdkDisplay* display)gdk_display_get_default_group;
+	gboolean function(GdkDisplay* display)gdk_display_supports_selection_notification;
+	gboolean function(GdkDisplay* display, GdkAtom selection)gdk_display_request_selection_notification;
+	gboolean function(GdkDisplay* display)gdk_display_supports_clipboard_persistence;
+	void function(GdkDisplay* display, GdkWindow* clipboardWindow, guint32 time, GdkAtom* targets, gint nTargets)gdk_display_store_clipboard;
+	gboolean function(GdkDisplay* display)gdk_display_supports_shapes;
+	gboolean function(GdkDisplay* display)gdk_display_supports_input_shapes;
+	gboolean function(GdkDisplay* display)gdk_display_supports_composite;
+	
+	// gdk.DisplayManager
+	
+	GdkDisplayManager* function()gdk_display_manager_get;
+	GdkDisplay* function(GdkDisplayManager* displayManager)gdk_display_manager_get_default_display;
+	void function(GdkDisplayManager* displayManager, GdkDisplay* display)gdk_display_manager_set_default_display;
+	GSList* function(GdkDisplayManager* displayManager)gdk_display_manager_list_displays;
+	GdkDevice* function(GdkDisplay* display)gdk_display_get_core_pointer;
+	
+	// gdk.Screen
+	
+	GdkScreen* function()gdk_screen_get_default;
+	GdkColormap* function(GdkScreen* screen)gdk_screen_get_default_colormap;
+	void function(GdkScreen* screen, GdkColormap* colormap)gdk_screen_set_default_colormap;
+	GdkColormap* function(GdkScreen* screen)gdk_screen_get_system_colormap;
+	GdkVisual* function(GdkScreen* screen)gdk_screen_get_system_visual;
+	GdkColormap* function(GdkScreen* screen)gdk_screen_get_rgb_colormap;
+	GdkVisual* function(GdkScreen* screen)gdk_screen_get_rgb_visual;
+	GdkColormap* function(GdkScreen* screen)gdk_screen_get_rgba_colormap;
+	GdkVisual* function(GdkScreen* screen)gdk_screen_get_rgba_visual;
+	gboolean function(GdkScreen* screen)gdk_screen_is_composited;
+	GdkWindow* function(GdkScreen* screen)gdk_screen_get_root_window;
+	GdkDisplay* function(GdkScreen* screen)gdk_screen_get_display;
+	gint function(GdkScreen* screen)gdk_screen_get_number;
+	gint function(GdkScreen* screen)gdk_screen_get_width;
+	gint function(GdkScreen* screen)gdk_screen_get_height;
+	gint function(GdkScreen* screen)gdk_screen_get_width_mm;
+	gint function(GdkScreen* screen)gdk_screen_get_height_mm;
+	GList* function(GdkScreen* screen)gdk_screen_list_visuals;
+	GList* function(GdkScreen* screen)gdk_screen_get_toplevel_windows;
+	gchar* function(GdkScreen* screen)gdk_screen_make_display_name;
+	gint function(GdkScreen* screen)gdk_screen_get_n_monitors;
+	void function(GdkScreen* screen, gint monitorNum, GdkRectangle* dest)gdk_screen_get_monitor_geometry;
+	gint function(GdkScreen* screen, gint x, gint y)gdk_screen_get_monitor_at_point;
+	gint function(GdkScreen* screen, GdkWindow* window)gdk_screen_get_monitor_at_window;
+	void function(GdkScreen* screen, GdkEvent* event)gdk_screen_broadcast_client_message;
+	gboolean function(GdkScreen* screen, gchar* name, GValue* value)gdk_screen_get_setting;
+	cairo_font_options_t* function(GdkScreen* screen)gdk_screen_get_font_options;
+	void function(GdkScreen* screen, cairo_font_options_t* options)gdk_screen_set_font_options;
+	gdouble function(GdkScreen* screen)gdk_screen_get_resolution;
+	void function(GdkScreen* screen, gdouble dpi)gdk_screen_set_resolution;
+	GdkWindow* function(GdkScreen* screen)gdk_screen_get_active_window;
+	GList* function(GdkScreen* screen)gdk_screen_get_window_stack;
+	gboolean function(GdkScreen* screen, gchar* workingDirectory, gchar** argv, gchar** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, gpointer userData, gint* childPid, GError** error)gdk_spawn_on_screen;
+	gboolean function(GdkScreen* screen, gchar* workingDirectory, gchar** argv, gchar** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, gpointer userData, gint* childPid, gint* standardInput, gint* standardOutput, gint* standardError, GError** error)gdk_spawn_on_screen_with_pipes;
+	gboolean function(GdkScreen* screen, gchar* commandLine, GError** error)gdk_spawn_command_line_on_screen;
+	
+	// gdk.Rectangle
+	
+	gboolean function(GdkRectangle* src1, GdkRectangle* src2, GdkRectangle* dest)gdk_rectangle_intersect;
+	void function(GdkRectangle* src1, GdkRectangle* src2, GdkRectangle* dest)gdk_rectangle_union;
+	
+	// gdk.Region
+	
+	GdkRegion* function()gdk_region_new;
+	GdkRegion* function(GdkPoint* points, gint npoints, GdkFillRule fillRule)gdk_region_polygon;
+	GdkRegion* function(GdkRegion* region)gdk_region_copy;
+	GdkRegion* function(GdkRectangle* rectangle)gdk_region_rectangle;
+	void function(GdkRegion* region)gdk_region_destroy;
+	void function(GdkRegion* region, GdkRectangle* rectangle)gdk_region_get_clipbox;
+	void function(GdkRegion* region, GdkRectangle** rectangles, gint* nRectangles)gdk_region_get_rectangles;
+	gboolean function(GdkRegion* region)gdk_region_empty;
+	gboolean function(GdkRegion* region1, GdkRegion* region2)gdk_region_equal;
+	gboolean function(GdkRegion* region, int x, int y)gdk_region_point_in;
+	GdkOverlapType function(GdkRegion* region, GdkRectangle* rectangle)gdk_region_rect_in;
+	void function(GdkRegion* region, gint dx, gint dy)gdk_region_offset;
+	void function(GdkRegion* region, gint dx, gint dy)gdk_region_shrink;
+	void function(GdkRegion* region, GdkRectangle* rect)gdk_region_union_with_rect;
+	void function(GdkRegion* source1, GdkRegion* source2)gdk_region_intersect;
+	void function(GdkRegion* source1, GdkRegion* source2)gdk_region_union;
+	void function(GdkRegion* source1, GdkRegion* source2)gdk_region_subtract;
+	void function(GdkRegion* source1, GdkRegion* source2)gdk_region_xor;
+	void function(GdkRegion* region, GdkSpan* spans, int nSpans, gboolean sorted, GdkSpanFunc funct, gpointer data)gdk_region_spans_intersect_foreach;
+	
+	// gdk.GC
+	
+	GdkGC* function(GdkDrawable* drawable)gdk_gc_new;
+	GdkGC* function(GdkDrawable* drawable, GdkGCValues* values, GdkGCValuesMask valuesMask)gdk_gc_new_with_values;
+	GdkScreen* function(GdkGC* gc)gdk_gc_get_screen;
+	GdkGC* function(GdkGC* gc)gdk_gc_ref;
+	void function(GdkGC* gc)gdk_gc_unref;
+	void function(GdkGC* gc, GdkGCValues* values, GdkGCValuesMask valuesMask)gdk_gc_set_values;
+	void function(GdkGC* gc, GdkGCValues* values)gdk_gc_get_values;
+	void function(GdkGC* gc, GdkColor* color)gdk_gc_set_foreground;
+	void function(GdkGC* gc, GdkColor* color)gdk_gc_set_background;
+	void function(GdkGC* gc, GdkColor* color)gdk_gc_set_rgb_fg_color;
+	void function(GdkGC* gc, GdkColor* color)gdk_gc_set_rgb_bg_color;
+	void function(GdkGC* gc, GdkFont* font)gdk_gc_set_font;
+	void function(GdkGC* gc, GdkFunction funct)gdk_gc_set_function;
+	void function(GdkGC* gc, GdkFill fill)gdk_gc_set_fill;
+	void function(GdkGC* gc, GdkPixmap* tile)gdk_gc_set_tile;
+	void function(GdkGC* gc, GdkPixmap* stipple)gdk_gc_set_stipple;
+	void function(GdkGC* gc, gint x, gint y)gdk_gc_set_ts_origin;
+	void function(GdkGC* gc, gint x, gint y)gdk_gc_set_clip_origin;
+	void function(GdkGC* gc, GdkBitmap* mask)gdk_gc_set_clip_mask;
+	void function(GdkGC* gc, GdkRectangle* rectangle)gdk_gc_set_clip_rectangle;
+	void function(GdkGC* gc, GdkRegion* region)gdk_gc_set_clip_region;
+	void function(GdkGC* gc, GdkSubwindowMode mode)gdk_gc_set_subwindow;
+	void function(GdkGC* gc, gboolean exposures)gdk_gc_set_exposures;
+	void function(GdkGC* gc, gint lineWidth, GdkLineStyle lineStyle, GdkCapStyle capStyle, GdkJoinStyle joinStyle)gdk_gc_set_line_attributes;
+	void function(GdkGC* gc, gint dashOffset, gint8[] dashList, gint n)gdk_gc_set_dashes;
+	void function(GdkGC* dstGc, GdkGC* srcGc)gdk_gc_copy;
+	void function(GdkGC* gc, GdkColormap* colormap)gdk_gc_set_colormap;
+	GdkColormap* function(GdkGC* gc)gdk_gc_get_colormap;
+	void function(GdkGC* gc, gint xOffset, gint yOffset)gdk_gc_offset;
+	
+	// gdk.Drawable
+	
+	GdkDrawable* function(GdkDrawable* drawable)gdk_drawable_ref;
+	void function(GdkDrawable* drawable)gdk_drawable_unref;
+	void function(GdkDrawable* drawable, gchar* key, gpointer data, GDestroyNotify destroyFunc)gdk_drawable_set_data;
+	gpointer function(GdkDrawable* drawable, gchar* key)gdk_drawable_get_data;
+	GdkDisplay* function(GdkDrawable* drawable)gdk_drawable_get_display;
+	GdkScreen* function(GdkDrawable* drawable)gdk_drawable_get_screen;
+	GdkVisual* function(GdkDrawable* drawable)gdk_drawable_get_visual;
+	void function(GdkDrawable* drawable, GdkColormap* colormap)gdk_drawable_set_colormap;
+	GdkColormap* function(GdkDrawable* drawable)gdk_drawable_get_colormap;
+	gint function(GdkDrawable* drawable)gdk_drawable_get_depth;
+	void function(GdkDrawable* drawable, gint* width, gint* height)gdk_drawable_get_size;
+	GdkRegion* function(GdkDrawable* drawable)gdk_drawable_get_clip_region;
+	GdkRegion* function(GdkDrawable* drawable)gdk_drawable_get_visible_region;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y)gdk_draw_point;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkPoint* points, gint npoints)gdk_draw_points;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x1_, gint y1_, gint x2_, gint y2_)gdk_draw_line;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkPoint* points, gint npoints)gdk_draw_lines;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkPixbuf* pixbuf, gint srcX, gint srcY, gint destX, gint destY, gint width, gint height, GdkRgbDither dither, gint xDither, gint yDither)gdk_draw_pixbuf;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkSegment* segs, gint nsegs)gdk_draw_segments;
+	void function(GdkDrawable* drawable, GdkGC* gc, gboolean filled, gint x, gint y, gint width, gint height)gdk_draw_rectangle;
+	void function(GdkDrawable* drawable, GdkGC* gc, gboolean filled, gint x, gint y, gint width, gint height, gint angle1, gint angle2)gdk_draw_arc;
+	void function(GdkDrawable* drawable, GdkGC* gc, gboolean filled, GdkPoint* points, gint npoints)gdk_draw_polygon;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkTrapezoid* trapezoids, gint nTrapezoids)gdk_draw_trapezoids;
+	void function(GdkDrawable* drawable, GdkGC* gc, PangoFont* font, gint x, gint y, PangoGlyphString* glyphs)gdk_draw_glyphs;
+	void function(GdkDrawable* drawable, GdkGC* gc, PangoMatrix* matrix, PangoFont* font, gint x, gint y, PangoGlyphString* glyphs)gdk_draw_glyphs_transformed;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, PangoLayoutLine* line)gdk_draw_layout_line;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, PangoLayoutLine* line, GdkColor* foreground, GdkColor* background)gdk_draw_layout_line_with_colors;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, PangoLayout* layout)gdk_draw_layout;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, PangoLayout* layout, GdkColor* foreground, GdkColor* background)gdk_draw_layout_with_colors;
+	void function(GdkDrawable* drawable, GdkFont* font, GdkGC* gc, gint x, gint y, gchar* string)gdk_draw_string;
+	void function(GdkDrawable* drawable, GdkFont* font, GdkGC* gc, gint x, gint y, gchar* text, gint textLength)gdk_draw_text;
+	void function(GdkDrawable* drawable, GdkFont* font, GdkGC* gc, gint x, gint y, GdkWChar* text, gint textLength)gdk_draw_text_wc;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkDrawable* src, gint xsrc, gint ysrc, gint xdest, gint ydest, gint width, gint height)gdk_draw_drawable;
+	void function(GdkDrawable* drawable, GdkGC* gc, GdkImage* image, gint xsrc, gint ysrc, gint xdest, gint ydest, gint width, gint height)gdk_draw_image;
+	GdkImage* function(GdkDrawable* drawable, gint x, gint y, gint width, gint height)gdk_drawable_get_image;
+	GdkImage* function(GdkDrawable* drawable, GdkImage* image, gint srcX, gint srcY, gint destX, gint destY, gint width, gint height)gdk_drawable_copy_to_image;
+	
+	// gdk.Pixmap
+	
+	GdkPixmap* function(GdkDrawable* drawable, gint width, gint height, gint depth)gdk_pixmap_new;
+	GdkPixmap* function(GdkDrawable* drawable, gchar* data, gint width, gint height, gint depth, GdkColor* fg, GdkColor* bg)gdk_pixmap_create_from_data;
+	GdkPixmap* function(GdkDrawable* drawable, GdkBitmap** mask, GdkColor* transparentColor, gchar* filename)gdk_pixmap_create_from_xpm;
+	GdkPixmap* function(GdkDrawable* drawable, GdkColormap* colormap, GdkBitmap** mask, GdkColor* transparentColor, gchar* filename)gdk_pixmap_colormap_create_from_xpm;
+	GdkPixmap* function(GdkDrawable* drawable, GdkBitmap** mask, GdkColor* transparentColor, gchar** data)gdk_pixmap_create_from_xpm_d;
+	GdkPixmap* function(GdkDrawable* drawable, GdkColormap* colormap, GdkBitmap** mask, GdkColor* transparentColor, gchar** data)gdk_pixmap_colormap_create_from_xpm_d;
+	
+	// gdk.Bitmap
+	
+	GdkBitmap* function(GdkDrawable* drawable, gchar* data, gint width, gint height)gdk_bitmap_create_from_data;
+	
+	// gdk.RGB
+	
+	void function()gdk_rgb_init;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* rgbBuf, gint rowstride)gdk_draw_rgb_image;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* rgbBuf, gint rowstride, gint xdith, gint ydith)gdk_draw_rgb_image_dithalign;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* buf, gint rowstride, GdkRgbCmap* cmap)gdk_draw_indexed_image;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* buf, gint rowstride)gdk_draw_gray_image;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* buf, gint rowstride)gdk_draw_rgb_32_image;
+	void function(GdkDrawable* drawable, GdkGC* gc, gint x, gint y, gint width, gint height, GdkRgbDither dith, guchar* buf, gint rowstride, gint xdith, gint ydith)gdk_draw_rgb_32_image_dithalign;
+	GdkRgbCmap* function(guint32* colors, gint nColors)gdk_rgb_cmap_new;
+	void function(GdkRgbCmap* cmap)gdk_rgb_cmap_free;
+	void function(GdkGC* gc, guint32 rgb)gdk_rgb_gc_set_foreground;
+	void function(GdkGC* gc, guint32 rgb)gdk_rgb_gc_set_background;
+	gulong function(guint32 rgb)gdk_rgb_xpixel_from_rgb;
+	void function(GdkColormap* colormap, GdkColor* color)gdk_rgb_find_color;
+	void function(gboolean install)gdk_rgb_set_install;
+	void function(gint minColors)gdk_rgb_set_min_colors;
+	GdkVisual* function()gdk_rgb_get_visual;
+	GdkColormap* function()gdk_rgb_get_colormap;
+	gboolean function()gdk_rgb_ditherable;
+	gboolean function(GdkColormap* cmap)gdk_rgb_colormap_ditherable;
+	void function(gboolean verbose)gdk_rgb_set_verbose;
+	
+	// gdk.ImageGdk
+	
+	GdkImage* function(GdkImageType type, GdkVisual* visual, gint width, gint height)gdk_image_new;
+	GdkImage* function(GdkVisual* visual, gpointer data, gint width, gint height)gdk_image_new_bitmap;
+	GdkImage* function(GdkDrawable* drawable, gint x, gint y, gint width, gint height)gdk_image_get;
+	GdkImage* function(GdkImage* image)gdk_image_ref;
+	void function(GdkImage* image)gdk_image_unref;
+	GdkColormap* function(GdkImage* image)gdk_image_get_colormap;
+	void function(GdkImage* image, GdkColormap* colormap)gdk_image_set_colormap;
+	void function(GdkImage* image, gint x, gint y, guint32 pixel)gdk_image_put_pixel;
+	guint32 function(GdkImage* image, gint x, gint y)gdk_image_get_pixel;
+	
+	// gdk.Pixbuf
+	
+	void function(GdkPixbuf* pixbuf, GdkBitmap* bitmap, int srcX, int srcY, int destX, int destY, int width, int height, int alphaThreshold)gdk_pixbuf_render_threshold_alpha;
+	void function(GdkPixbuf* pixbuf, GdkDrawable* drawable, GdkGC* gc, int srcX, int srcY, int destX, int destY, int width, int height, GdkRgbDither dither, int xDither, int yDither)gdk_pixbuf_render_to_drawable;
+	void function(GdkPixbuf* pixbuf, GdkDrawable* drawable, int srcX, int srcY, int destX, int destY, int width, int height, GdkPixbufAlphaMode alphaMode, int alphaThreshold, GdkRgbDither dither, int xDither, int yDither)gdk_pixbuf_render_to_drawable_alpha;
+	void function(GdkPixbuf* pixbuf, GdkPixmap** pixmapReturn, GdkBitmap** maskReturn, int alphaThreshold)gdk_pixbuf_render_pixmap_and_mask;
+	void function(GdkPixbuf* pixbuf, GdkColormap* colormap, GdkPixmap** pixmapReturn, GdkBitmap** maskReturn, int alphaThreshold)gdk_pixbuf_render_pixmap_and_mask_for_colormap;
+	GdkPixbuf* function(GdkPixbuf* dest, GdkDrawable* src, GdkColormap* cmap, int srcX, int srcY, int destX, int destY, int width, int height)gdk_pixbuf_get_from_drawable;
+	GdkPixbuf* function(GdkPixbuf* dest, GdkImage* src, GdkColormap* cmap, int srcX, int srcY, int destX, int destY, int width, int height)gdk_pixbuf_get_from_image;
+	GType function()gdk_pixbuf_get_type;
+	GdkPixbuf* function(guchar* data, GdkColorspace colorspace, gboolean hasAlpha, int bitsPerSample, int width, int height, int rowstride, GdkPixbufDestroyNotify destroyFn, gpointer destroyFnData)gdk_pixbuf_new_from_data;
+	GdkPixbuf* function(char** data)gdk_pixbuf_new_from_xpm_data;
+	GdkPixbuf* function(gint dataLength, guint8* data, gboolean copyPixels, GError** error)gdk_pixbuf_new_from_inline;
+	GdkPixbuf* function(GdkPixbuf* srcPixbuf, int srcX, int srcY, int width, int height)gdk_pixbuf_new_subpixbuf;
+	GdkPixbuf* function(GdkPixbuf* pixbuf)gdk_pixbuf_copy;
+	GdkColorspace function(GdkPixbuf* pixbuf)gdk_pixbuf_get_colorspace;
+	int function(GdkPixbuf* pixbuf)gdk_pixbuf_get_n_channels;
+	gboolean function(GdkPixbuf* pixbuf)gdk_pixbuf_get_has_alpha;
+	int function(GdkPixbuf* pixbuf)gdk_pixbuf_get_bits_per_sample;
+	guchar* function(GdkPixbuf* pixbuf)gdk_pixbuf_get_pixels;
+	int function(GdkPixbuf* pixbuf)gdk_pixbuf_get_width;
+	int function(GdkPixbuf* pixbuf)gdk_pixbuf_get_height;
+	int function(GdkPixbuf* pixbuf)gdk_pixbuf_get_rowstride;
+	gchar* function(GdkPixbuf* pixbuf, gchar* key)gdk_pixbuf_get_option;
+	GdkPixbuf* function(char* filename, GError** error)gdk_pixbuf_new_from_file;
+	GdkPixbuf* function(char* filename, int width, int height, GError** error)gdk_pixbuf_new_from_file_at_size;
+	GdkPixbuf* function(char* filename, int width, int height, gboolean preserveAspectRatio, GError** error)gdk_pixbuf_new_from_file_at_scale;
+	gboolean function(GdkPixbuf* pixbuf, char* filename, char* type, char** optionKeys, char** optionValues, GError** error)gdk_pixbuf_savev;
+	gboolean function(GdkPixbuf* pixbuf, char* filename, char* type, GError** error, ... )gdk_pixbuf_save;
+	gboolean function(GdkPixbuf* pixbuf, GdkPixbufSaveFunc saveFunc, gpointer userData, char* type, GError** error, ... )gdk_pixbuf_save_to_callback;
+	gboolean function(GdkPixbuf* pixbuf, GdkPixbufSaveFunc saveFunc, gpointer userData, char* type, char** optionKeys, char** optionValues, GError** error)gdk_pixbuf_save_to_callbackv;
+	gboolean function(GdkPixbuf* pixbuf, gchar** buffer, gsize* bufferSize, char* type, GError** error, ... )gdk_pixbuf_save_to_buffer;
+	gboolean function(GdkPixbuf* pixbuf, gchar** buffer, gsize* bufferSize, char* type, char** optionKeys, char** optionValues, GError** error)gdk_pixbuf_save_to_bufferv;
+	GdkPixbuf* function(GdkPixbuf* src, int destWidth, int destHeight, GdkInterpType interpType)gdk_pixbuf_scale_simple;
+	void function(GdkPixbuf* src, GdkPixbuf* dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType)gdk_pixbuf_scale;
+	GdkPixbuf* function(GdkPixbuf* src, int destWidth, int destHeight, GdkInterpType interpType, int overallAlpha, int checkSize, guint32 color1, guint32 color2)gdk_pixbuf_composite_color_simple;
+	void function(GdkPixbuf* src, GdkPixbuf* dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType, int overallAlpha)gdk_pixbuf_composite;
+	void function(GdkPixbuf* src, GdkPixbuf* dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType, int overallAlpha, int checkX, int checkY, int checkSize, guint32 color1, guint32 color2)gdk_pixbuf_composite_color;
+	GdkPixbuf* function(GdkPixbuf* src, GdkPixbufRotation angle)gdk_pixbuf_rotate_simple;
+	GdkPixbuf* function(GdkPixbuf* src, gboolean horizontal)gdk_pixbuf_flip;
+	GdkPixbuf* function(GdkPixbuf* pixbuf, gboolean substituteColor, guchar r, guchar g, guchar b)gdk_pixbuf_add_alpha;
+	void function(GdkPixbuf* srcPixbuf, int srcX, int srcY, int width, int height, GdkPixbuf* destPixbuf, int destX, int destY)gdk_pixbuf_copy_area;
+	void function(GdkPixbuf* src, GdkPixbuf* dest, gfloat saturation, gboolean pixelate)gdk_pixbuf_saturate_and_pixelate;
+	GdkPixbuf* function(GdkPixbuf* src)gdk_pixbuf_apply_embedded_orientation;
+	void function(GdkPixbuf* pixbuf, guint32 pixel)gdk_pixbuf_fill;
+	
+	// gdk.Colormap
+	
+	GdkColormap* function(GdkVisual* visual, gboolean allocate)gdk_colormap_new;
+	GdkColormap* function(GdkColormap* cmap)gdk_colormap_ref;
+	void function(GdkColormap* cmap)gdk_colormap_unref;
+	GdkColormap* function()gdk_colormap_get_system;
+	gint function()gdk_colormap_get_system_size;
+	void function(GdkColormap* colormap, gint ncolors)gdk_colormap_change;
+	gint function(GdkColormap* colormap, GdkColor* colors, gint ncolors, gboolean writeable, gboolean bestMatch, gboolean* success)gdk_colormap_alloc_colors;
+	gboolean function(GdkColormap* colormap, GdkColor* color, gboolean writeable, gboolean bestMatch)gdk_colormap_alloc_color;
+	void function(GdkColormap* colormap, GdkColor* colors, gint ncolors)gdk_colormap_free_colors;
+	void function(GdkColormap* colormap, gulong pixel, GdkColor* result)gdk_colormap_query_color;
+	GdkVisual* function(GdkColormap* colormap)gdk_colormap_get_visual;
+	GdkScreen* function(GdkColormap* cmap)gdk_colormap_get_screen;
+	void function(GdkColormap* colormap, GdkColor* colors, gint ncolors)gdk_colors_store;
+	gint function(GdkColormap* colormap, gboolean contiguous, gulong* planes, gint nplanes, gulong* pixels, gint npixels)gdk_colors_alloc;
+	void function(GdkColormap* colormap, gulong* pixels, gint npixels, gulong planes)gdk_colors_free;
+	
+	// gdk.Color
+	
+	GdkColor* function(GdkColor* color)gdk_color_copy;
+	void function(GdkColor* color)gdk_color_free;
+	gint function(GdkColormap* colormap, GdkColor* color)gdk_color_white;
+	gint function(GdkColormap* colormap, GdkColor* color)gdk_color_black;
+	gboolean function(gchar* spec, GdkColor* color)gdk_color_parse;
+	gint function(GdkColormap* colormap, GdkColor* color)gdk_color_alloc;
+	gint function(GdkColormap* colormap, GdkColor* color)gdk_color_change;
+	gboolean function(GdkColor* colora, GdkColor* colorb)gdk_color_equal;
+	guint function(GdkColor* colora)gdk_color_hash;
+	gchar* function(GdkColor* color)gdk_color_to_string;
+	
+	// gdk.Visual
+	
+	void function(gint** depths, gint* count)gdk_query_depths;
+	void function(GdkVisualType** visualTypes, gint* count)gdk_query_visual_types;
+	GList* function()gdk_list_visuals;
+	gint function()gdk_visual_get_best_depth;
+	GdkVisualType function()gdk_visual_get_best_type;
+	GdkVisual* function()gdk_visual_get_system;
+	GdkVisual* function()gdk_visual_get_best;
+	GdkVisual* function(gint depth)gdk_visual_get_best_with_depth;
+	GdkVisual* function(GdkVisualType visualType)gdk_visual_get_best_with_type;
+	GdkVisual* function(gint depth, GdkVisualType visualType)gdk_visual_get_best_with_both;
+	GdkScreen* function(GdkVisual* visual)gdk_visual_get_screen;
+	
+	// gdk.Font
+	
+	GdkFont* function(gchar* fontName)gdk_font_load;
+	GdkFont* function(GdkDisplay* display, gchar* fontName)gdk_font_load_for_display;
+	GdkFont* function(gchar* fontsetName)gdk_fontset_load;
+	GdkFont* function(GdkDisplay* display, gchar* fontsetName)gdk_fontset_load_for_display;
+	GdkFont* function(PangoFontDescription* fontDesc)gdk_font_from_description;
+	GdkFont* function(GdkDisplay* display, PangoFontDescription* fontDesc)gdk_font_from_description_for_display;
+	GdkDisplay* function(GdkFont* font)gdk_font_get_display;
+	GdkFont* function(GdkFont* font)gdk_font_ref;
+	void function(GdkFont* font)gdk_font_unref;
+	gint function(GdkFont* font)gdk_font_id;
+	gboolean function(GdkFont* fonta, GdkFont* fontb)gdk_font_equal;
+	void function(GdkFont* font, gchar* string, gint* lbearing, gint* rbearing, gint* width, gint* ascent, gint* descent)gdk_string_extents;
+	void function(GdkFont* font, gchar* text, gint textLength, gint* lbearing, gint* rbearing, gint* width, gint* ascent, gint* descent)gdk_text_extents;
+	void function(GdkFont* font, GdkWChar* text, gint textLength, gint* lbearing, gint* rbearing, gint* width, gint* ascent, gint* descent)gdk_text_extents_wc;
+	gint function(GdkFont* font, gchar* string)gdk_string_width;
+	gint function(GdkFont* font, gchar* text, gint textLength)gdk_text_width;
+	gint function(GdkFont* font, GdkWChar* text, gint textLength)gdk_text_width_wc;
+	gint function(GdkFont* font, gchar character)gdk_char_width;
+	gint function(GdkFont* font, GdkWChar character)gdk_char_width_wc;
+	gint function(GdkFont* font, gchar* string)gdk_string_measure;
+	gint function(GdkFont* font, gchar* text, gint textLength)gdk_text_measure;
+	gint function(GdkFont* font, gchar character)gdk_char_measure;
+	gint function(GdkFont* font, gchar* string)gdk_string_height;
+	gint function(GdkFont* font, gchar* text, gint textLength)gdk_text_height;
+	gint function(GdkFont* font, gchar character)gdk_char_height;
+	gchar* function(GdkWChar* src)gdk_wcstombs;
+	gint function(GdkWChar* dest, gchar* src, gint destMax)gdk_mbstowcs;
+	
+	// gdk.Cursor
+	
+	GdkCursor* function(GdkCursorType cursorType)gdk_cursor_new;
+	GdkCursor* function(GdkPixmap* source, GdkPixmap* mask, GdkColor* fg, GdkColor* bg, gint x, gint y)gdk_cursor_new_from_pixmap;
+	GdkCursor* function(GdkDisplay* display, GdkPixbuf* pixbuf, gint x, gint y)gdk_cursor_new_from_pixbuf;
+	GdkCursor* function(GdkDisplay* display, gchar* name)gdk_cursor_new_from_name;
+	GdkCursor* function(GdkDisplay* display, GdkCursorType cursorType)gdk_cursor_new_for_display;
+	GdkDisplay* function(GdkCursor* cursor)gdk_cursor_get_display;
+	GdkPixbuf* function(GdkCursor* cursor)gdk_cursor_get_image;
+	GdkCursor* function(GdkCursor* cursor)gdk_cursor_ref;
+	void function(GdkCursor* cursor)gdk_cursor_unref;
+	
+	// gdk.Window
+	
+	GdkWindow* function(GdkWindow* parent, GdkWindowAttr* attributes, gint attributesMask)gdk_window_new;
+	void function(GdkWindow* window)gdk_window_destroy;
+	GdkWindowType function(GdkWindow* window)gdk_window_get_window_type;
+	GdkWindow* function(gint* winX, gint* winY)gdk_window_at_pointer;
+	void function(GdkWindow* window)gdk_window_show;
+	void function(GdkWindow* window)gdk_window_show_unraised;
+	void function(GdkWindow* window)gdk_window_hide;
+	gboolean function(GdkWindow* window)gdk_window_is_visible;
+	gboolean function(GdkWindow* window)gdk_window_is_viewable;
+	GdkWindowState function(GdkWindow* window)gdk_window_get_state;
+	void function(GdkWindow* window)gdk_window_withdraw;
+	void function(GdkWindow* window)gdk_window_iconify;
+	void function(GdkWindow* window)gdk_window_deiconify;
+	void function(GdkWindow* window)gdk_window_stick;
+	void function(GdkWindow* window)gdk_window_unstick;
+	void function(GdkWindow* window)gdk_window_maximize;
+	void function(GdkWindow* window)gdk_window_unmaximize;
+	void function(GdkWindow* window)gdk_window_fullscreen;
+	void function(GdkWindow* window)gdk_window_unfullscreen;
+	void function(GdkWindow* window, gboolean setting)gdk_window_set_keep_above;
+	void function(GdkWindow* window, gboolean setting)gdk_window_set_keep_below;
+	void function(GdkWindow* window, gdouble opacity)gdk_window_set_opacity;
+	void function(GdkWindow* window, gboolean composited)gdk_window_set_composited;
+	void function(GdkWindow* window, gint x, gint y)gdk_window_move;
+	void function(GdkWindow* window, gint width, gint height)gdk_window_resize;
+	void function(GdkWindow* window, gint x, gint y, gint width, gint height)gdk_window_move_resize;
+	void function(GdkWindow* window, gint dx, gint dy)gdk_window_scroll;
+	void function(GdkWindow* window, GdkRegion* region, gint dx, gint dy)gdk_window_move_region;
+	void function(GdkWindow* window, GdkWindow* newParent, gint x, gint y)gdk_window_reparent;
+	void function(GdkWindow* window)gdk_window_clear;
+	void function(GdkWindow* window, gint x, gint y, gint width, gint height)gdk_window_clear_area;
+	void function(GdkWindow* window, gint x, gint y, gint width, gint height)gdk_window_clear_area_e;
+	void function(GdkWindow* window)gdk_window_raise;
+	void function(GdkWindow* window)gdk_window_lower;
+	void function(GdkWindow* window, guint32 timestamp)gdk_window_focus;
+	void function(GdkWindow* window)gdk_window_register_dnd;
+	void function(GdkWindow* window, GdkWindowEdge edge, gint button, gint rootX, gint rootY, guint32 timestamp)gdk_window_begin_resize_drag;
+	void function(GdkWindow* window, gint button, gint rootX, gint rootY, guint32 timestamp)gdk_window_begin_move_drag;
+	void function(GdkGeometry* geometry, guint flags, gint width, gint height, gint* newWidth, gint* newHeight)gdk_window_constrain_size;
+	void function(GdkWindow* window)gdk_window_beep;
+	void function(GdkWindow* window, GdkRectangle* rectangle)gdk_window_begin_paint_rect;
+	void function(GdkWindow* window, GdkRegion* region)gdk_window_begin_paint_region;
+	void function(GdkWindow* window)gdk_window_end_paint;
+	void function(GdkWindow* window, GdkRectangle* rect, gboolean invalidateChildren)gdk_window_invalidate_rect;
+	void function(GdkWindow* window, GdkRegion* region, gboolean invalidateChildren)gdk_window_invalidate_region;
+	GdkRegion* function(GdkWindow* window)gdk_window_get_update_area;
+	void function(GdkWindow* window)gdk_window_freeze_updates;
+	void function(GdkWindow* window)gdk_window_thaw_updates;
+	void function()gdk_window_process_all_updates;
+	void function(GdkWindow* window, gboolean updateChildren)gdk_window_process_updates;
+	void function(gboolean setting)gdk_window_set_debug_updates;
+	void function(GdkWindow* window, GdkDrawable** realDrawable, gint* xOffset, gint* yOffset)gdk_window_get_internal_paint_info;
+	void function(GdkWindow* window)gdk_window_enable_synchronized_configure;
+	void function(GdkWindow* window)gdk_window_configure_finished;
+	void function(GdkWindow* window, gpointer userData)gdk_window_set_user_data;
+	void function(GdkWindow* window, gboolean overrideRedirect)gdk_window_set_override_redirect;
+	void function(GdkWindow* window, gboolean acceptFocus)gdk_window_set_accept_focus;
+	void function(GdkWindow* window, gboolean focusOnMap)gdk_window_set_focus_on_map;
+	void function(GdkWindow* window, GdkFilterFunc funct, gpointer data)gdk_window_add_filter;
+	void function(GdkWindow* window, GdkFilterFunc funct, gpointer data)gdk_window_remove_filter;
+	void function(GdkWindow* window, GdkBitmap* mask, gint x, gint y)gdk_window_shape_combine_mask;
+	void function(GdkWindow* window, GdkRegion* shapeRegion, gint offsetX, gint offsetY)gdk_window_shape_combine_region;
+	void function(GdkWindow* window)gdk_window_set_child_shapes;
+	void function(GdkWindow* window)gdk_window_merge_child_shapes;
+	void function(GdkWindow* window, GdkBitmap* mask, gint x, gint y)gdk_window_input_shape_combine_mask;
+	void function(GdkWindow* window, GdkRegion* shapeRegion, gint offsetX, gint offsetY)gdk_window_input_shape_combine_region;
+	void function(GdkWindow* window)gdk_window_set_child_input_shapes;
+	void function(GdkWindow* window)gdk_window_merge_child_input_shapes;
+	gboolean function(GdkWindow* window, gboolean useStatic)gdk_window_set_static_gravities;
+	void function(GdkWindow* window, gint x, gint y, gint minWidth, gint minHeight, gint maxWidth, gint maxHeight, gint flags)gdk_window_set_hints;
+	void function(GdkWindow* window, gchar* title)gdk_window_set_title;
+	void function(GdkWindow* window, GdkColor* color)gdk_window_set_background;
+	void function(GdkWindow* window, GdkPixmap* pixmap, gboolean parentRelative)gdk_window_set_back_pixmap;
+	void function(GdkWindow* window, GdkCursor* cursor)gdk_window_set_cursor;
+	void function(GdkWindow* window, gpointer* data)gdk_window_get_user_data;
+	void function(GdkWindow* window, gint* x, gint* y, gint* width, gint* height, gint* depth)gdk_window_get_geometry;
+	void function(GdkWindow* window, GdkGeometry* geometry, GdkWindowHints geomMask)gdk_window_set_geometry_hints;
+	void function(GdkWindow* window, GList* pixbufs)gdk_window_set_icon_list;
+	void function(GdkWindow* window, gboolean modal)gdk_window_set_modal_hint;
+	void function(GdkWindow* window, GdkWindowTypeHint hint)gdk_window_set_type_hint;
+	GdkWindowTypeHint function(GdkWindow* window)gdk_window_get_type_hint;
+	void function(GdkWindow* window, gboolean skipsTaskbar)gdk_window_set_skip_taskbar_hint;
+	void function(GdkWindow* window, gboolean skipsPager)gdk_window_set_skip_pager_hint;
+	void function(GdkWindow* window, gboolean urgent)gdk_window_set_urgency_hint;
+	void function(GdkWindow* window, gint* x, gint* y)gdk_window_get_position;
+	void function(GdkWindow* window, gint* x, gint* y)gdk_window_get_root_origin;
+	void function(GdkWindow* window, GdkRectangle* rect)gdk_window_get_frame_extents;
+	gint function(GdkWindow* window, gint* x, gint* y)gdk_window_get_origin;
+	gboolean function(GdkWindow* window, gint* x, gint* y)gdk_window_get_deskrelative_origin;
+	GdkWindow* function(GdkWindow* window, gint* x, gint* y, GdkModifierType* mask)gdk_window_get_pointer;
+	GdkWindow* function(GdkWindow* window)gdk_window_get_parent;
+	GdkWindow* function(GdkWindow* window)gdk_window_get_toplevel;
+	GList* function(GdkWindow* window)gdk_window_get_children;
+	GList* function(GdkWindow* window)gdk_window_peek_children;
+	GdkEventMask function(GdkWindow* window)gdk_window_get_events;
+	void function(GdkWindow* window, GdkEventMask eventMask)gdk_window_set_events;
+	void function(GdkWindow* window, GdkWindow* iconWindow, GdkPixmap* pixmap, GdkBitmap* mask)gdk_window_set_icon;
+	void function(GdkWindow* window, gchar* name)gdk_window_set_icon_name;
+	void function(GdkWindow* window, GdkWindow* parent)gdk_window_set_transient_for;
+	void function(GdkWindow* window, gchar* role)gdk_window_set_role;
+	void function(GdkWindow* window, gchar* startupId)gdk_window_set_startup_id;
+	void function(GdkWindow* window, GdkWindow* leader)gdk_window_set_group;
+	GdkWindow* function(GdkWindow* window)gdk_window_get_group;
+	void function(GdkWindow* window, GdkWMDecoration decorations)gdk_window_set_decorations;
+	gboolean function(GdkWindow* window, GdkWMDecoration* decorations)gdk_window_get_decorations;
+	void function(GdkWindow* window, GdkWMFunction functions)gdk_window_set_functions;
+	GList* function()gdk_window_get_toplevels;
+	GdkWindow* function()gdk_get_default_root_window;
+	GdkPointerHooks* function(GdkPointerHooks* newHooks)gdk_set_pointer_hooks;
+	
+	// gdk.Event
+	
+	gboolean function()gdk_events_pending;
+	GdkEvent* function()gdk_event_peek;
+	GdkEvent* function()gdk_event_get;
+	GdkEvent* function(GdkWindow* window)gdk_event_get_graphics_expose;
+	void function(GdkEvent* event)gdk_event_put;
+	GdkEvent* function(GdkEventType type)gdk_event_new;
+	GdkEvent* function(GdkEvent* event)gdk_event_copy;
+	void function(GdkEvent* event)gdk_event_free;
+	guint32 function(GdkEvent* event)gdk_event_get_time;
+	gboolean function(GdkEvent* event, GdkModifierType* state)gdk_event_get_state;
+	gboolean function(GdkEvent* event, GdkAxisUse axisUse, gdouble* value)gdk_event_get_axis;
+	gboolean function(GdkEvent* event, gdouble* xWin, gdouble* yWin)gdk_event_get_coords;
+	gboolean function(GdkEvent* event, gdouble* xRoot, gdouble* yRoot)gdk_event_get_root_coords;
+	void function(GdkEventMotion* event)gdk_event_request_motions;
+	void function(GdkEventFunc func, gpointer data, GDestroyNotify notify)gdk_event_handler_set;
+	gboolean function(GdkEvent* event, GdkNativeWindow winid)gdk_event_send_client_message;
+	gboolean function(GdkDisplay* display, GdkEvent* event, GdkNativeWindow winid)gdk_event_send_client_message_for_display;
+	void function(GdkEvent* event)gdk_event_send_clientmessage_toall;
+	void function(GdkAtom messageType, GdkFilterFunc func, gpointer data)gdk_add_client_message_filter;
+	gboolean function()gdk_get_show_events;
+	void function(gboolean showEvents)gdk_set_show_events;
+	void function(GdkEvent* event, GdkScreen* screen)gdk_event_set_screen;
+	GdkScreen* function(GdkEvent* event)gdk_event_get_screen;
+	gboolean function(gchar* name, GValue* value)gdk_setting_get;
+	
+	// gdk.
+	
+	
+	// gdk.Keymap
+	
+	GdkKeymap* function()gdk_keymap_get_default;
+	GdkKeymap* function(GdkDisplay* display)gdk_keymap_get_for_display;
+	guint function(GdkKeymap* keymap, GdkKeymapKey* key)gdk_keymap_lookup_key;
+	gboolean function(GdkKeymap* keymap, guint hardwareKeycode, GdkModifierType state, gint group, guint* keyval, gint* effectiveGroup, gint* level, GdkModifierType* consumedModifiers)gdk_keymap_translate_keyboard_state;
+	gboolean function(GdkKeymap* keymap, guint keyval, GdkKeymapKey** keys, gint* nKeys)gdk_keymap_get_entries_for_keyval;
+	gboolean function(GdkKeymap* keymap, guint hardwareKeycode, GdkKeymapKey** keys, guint** keyvals, gint* nEntries)gdk_keymap_get_entries_for_keycode;
+	PangoDirection function(GdkKeymap* keymap)gdk_keymap_get_direction;
+	gboolean function(GdkKeymap* keymap)gdk_keymap_have_bidi_layouts;
+	gchar* function(guint keyval)gdk_keyval_name;
+	guint function(gchar* keyvalName)gdk_keyval_from_name;
+	void function(guint symbol, guint* lower, guint* upper)gdk_keyval_convert_case;
+	guint function(guint keyval)gdk_keyval_to_upper;
+	guint function(guint keyval)gdk_keyval_to_lower;
+	gboolean function(guint keyval)gdk_keyval_is_upper;
+	gboolean function(guint keyval)gdk_keyval_is_lower;
+	guint32 function(guint keyval)gdk_keyval_to_unicode;
+	guint function(guint32 wc)gdk_unicode_to_keyval;
+	
+	// gdk.Selection
+	
+	gboolean function(GdkWindow* owner, GdkAtom selection, guint32 time, gboolean sendEvent)gdk_selection_owner_set;
+	gboolean function(GdkDisplay* display, GdkWindow* owner, GdkAtom selection, guint32 time, gboolean sendEvent)gdk_selection_owner_set_for_display;
+	GdkWindow* function(GdkAtom selection)gdk_selection_owner_get;
+	GdkWindow* function(GdkDisplay* display, GdkAtom selection)gdk_selection_owner_get_for_display;
+	void function(GdkWindow* requestor, GdkAtom selection, GdkAtom target, guint32 time)gdk_selection_convert;
+	gboolean function(GdkWindow* requestor, guchar** data, GdkAtom* propType, gint* propFormat)gdk_selection_property_get;
+	void function(guint32 requestor, GdkAtom selection, GdkAtom target, GdkAtom property, guint32 time)gdk_selection_send_notify;
+	void function(GdkDisplay* display, guint32 requestor, GdkAtom selection, GdkAtom target, GdkAtom property, guint32 time)gdk_selection_send_notify_for_display;
+	
+	// gdk.DragContext
+	
+	GdkAtom function(GdkDragContext* context)gdk_drag_get_selection;
+	void function(GdkDragContext* context, guint32 time)gdk_drag_abort;
+	void function(GdkDragContext* context, gboolean ok, guint32 time)gdk_drop_reply;
+	GdkDragContext* function()gdk_drag_context_new;
+	void function(GdkDragContext* context, guint32 time)gdk_drag_drop;
+	void function(GdkDragContext* context, GdkWindow* dragWindow, gint xRoot, gint yRoot, GdkWindow** destWindow, GdkDragProtocol* protocol)gdk_drag_find_window;
+	void function(GdkDragContext* context, GdkWindow* dragWindow, GdkScreen* screen, gint xRoot, gint yRoot, GdkWindow** destWindow, GdkDragProtocol* protocol)gdk_drag_find_window_for_screen;
+	void function(GdkDragContext* context)gdk_drag_context_ref;
+	GdkDragContext* function(GdkWindow* window, GList* targets)gdk_drag_begin;
+	gboolean function(GdkDragContext* context, GdkWindow* destWindow, GdkDragProtocol protocol, gint xRoot, gint yRoot, GdkDragAction suggestedAction, GdkDragAction possibleActions, guint32 time)gdk_drag_motion;
+	void function(GdkDragContext* context, gboolean success, guint32 time)gdk_drop_finish;
+	guint32 function(guint32 xid, GdkDragProtocol* protocol)gdk_drag_get_protocol;
+	guint32 function(GdkDisplay* display, guint32 xid, GdkDragProtocol* protocol)gdk_drag_get_protocol_for_display;
+	void function(GdkDragContext* context)gdk_drag_context_unref;
+	void function(GdkDragContext* context, GdkDragAction action, guint32 time)gdk_drag_status;
+	gboolean function(GdkDragContext* context)gdk_drag_drop_succeeded;
+	
+	// gdk.
+	
+	void function()gdk_threads_init;
+	void function()gdk_threads_enter;
+	void function()gdk_threads_leave;
+	void function(GCallback enterFn, GCallback leaveFn)gdk_threads_set_lock_functions;
+	guint function(GSourceFunc funct, gpointer data)gdk_threads_add_idle;
+	guint function(gint priority, GSourceFunc funct, gpointer data, GDestroyNotify notify)gdk_threads_add_idle_full;
+	guint function(guint interval, GSourceFunc funct, gpointer data)gdk_threads_add_timeout;
+	guint function(gint priority, guint interval, GSourceFunc funct, gpointer data, GDestroyNotify notify)gdk_threads_add_timeout_full;
+	
+	// gdk.Input
+	
+	gint function(gint source, GdkInputCondition condition, GdkInputFunction funct, gpointer data, GdkDestroyNotify destroy)gdk_input_add_full;
+	gint function(gint source, GdkInputCondition condition, GdkInputFunction funct, gpointer data)gdk_input_add;
+	void function(gint tag)gdk_input_remove;
+	
+	// gdk.Device
+	
+	GList* function()gdk_devices_list;
+	void function(GdkDevice* device, GdkInputSource source)gdk_device_set_source;
+	gboolean function(GdkDevice* device, GdkInputMode mode)gdk_device_set_mode;
+	void function(GdkDevice* device, guint index, guint keyval, GdkModifierType modifiers)gdk_device_set_key;
+	void function(GdkDevice* device, guint index, GdkAxisUse use)gdk_device_set_axis_use;
+	GdkDevice* function()gdk_device_get_core_pointer;
+	void function(GdkDevice* device, GdkWindow* window, gdouble* axes, GdkModifierType* mask)gdk_device_get_state;
+	gboolean function(GdkDevice* device, GdkWindow* window, guint32 start, guint32 stop, GdkTimeCoord*** events, gint* nEvents)gdk_device_get_history;
+	void function(GdkTimeCoord** events, gint nEvents)gdk_device_free_history;
+	gboolean function(GdkDevice* device, gdouble* axes, GdkAxisUse use, gdouble* value)gdk_device_get_axis;
+	void function(GdkWindow* window, gint mask, GdkExtensionMode mode)gdk_input_set_extension_events;
+	
+	// gdk.X11
+/+ Manually disabled. Won't compile, yet.
+	GdkVisual* function(VisualID xvisualid)gdkx_visual_get;
+	GdkColormap* function(Colormap xcolormap)gdkx_colormap_get;
+	GdkPixmap* function(GdkNativeWindow anid)gdk_pixmap_foreign_new;
+	GdkPixmap* function(GdkDisplay* display, GdkNativeWindow anid)gdk_pixmap_foreign_new_for_display;
+	GdkPixmap* function(GdkScreen* screen, GdkNativeWindow anid, gint width, gint height, gint depth)gdk_pixmap_foreign_new_for_screen;
+	GdkWindow* function(GdkNativeWindow anid)gdk_window_foreign_new;
+	GdkWindow* function(GdkDisplay* display, GdkNativeWindow anid)gdk_window_foreign_new_for_display;
+	gpointer function(XID xid)gdk_xid_table_lookup;
+	gpointer function(GdkDisplay* display, XID xid)gdk_xid_table_lookup_for_display;
+	GdkWindow* function(GdkNativeWindow anid)gdk_window_lookup;
+	GdkWindow* function(GdkDisplay* display, GdkNativeWindow anid)gdk_window_lookup_for_display;
+	GdkPixmap* function(GdkNativeWindow anid)gdk_pixmap_lookup;
+	GdkPixmap* function(GdkDisplay* display, GdkNativeWindow anid)gdk_pixmap_lookup_for_display;
+	GdkDisplay* function(Display* xdisplay)gdk_x11_lookup_xdisplay;
+	guint32 function(GdkWindow* window)gdk_x11_get_server_time;
+	gboolean function(GdkAtom property)gdk_net_wm_supports;
+	gboolean function(GdkScreen* screen, GdkAtom property)gdk_x11_screen_supports_net_wm_hint;
+	char* function(GdkScreen* screen)gdk_x11_screen_get_window_manager_name;
+	GdkVisual* function(GdkScreen* screen, VisualID xvisualid)gdk_x11_screen_lookup_visual;
+	void function(GdkWindow* window, guint32 timestamp)gdk_x11_window_set_user_time;
+	void function(GdkWindow* window)gdk_x11_window_move_to_current_desktop;
+	guint32 function(GdkDisplay* display)gdk_x11_display_get_user_time;
+	GdkColormap* function(GdkVisual* visual, Colormap xcolormap)gdk_x11_colormap_foreign_new;
+	Colormap function(GdkColormap* colormap)gdk_x11_colormap_get_xcolormap;
+	Display* function(GdkColormap* colormap)gdk_x11_colormap_get_xdisplay;
+	Cursor function(GdkCursor* cursor)gdk_x11_cursor_get_xcursor;
+	Display* function(GdkCursor* cursor)gdk_x11_cursor_get_xdisplay;
+	void function(GdkDisplay* display, char* messageType, ... )gdk_x11_display_broadcast_startup_message;
+	gchar* function(GdkDisplay* display)gdk_x11_display_get_startup_notification_id;
+	Display* function(GdkDisplay* display)gdk_x11_display_get_xdisplay;
+	void function(GdkDisplay* display)gdk_x11_display_grab;
+	void function(GdkDisplay* display)gdk_x11_display_ungrab;
+	void function(GdkDisplay* display, gchar* theme, gint size)gdk_x11_display_set_cursor_theme;
+	void function(GdkDisplay* display, gint eventBase, gint nEvents)gdk_x11_register_standard_event_type;
+	Display* function(GdkDrawable* drawable)gdk_x11_drawable_get_xdisplay;
+        +/
+	XID function(GdkDrawable* drawable)gdk_x11_drawable_get_xid;
+        /+
+	char* function(GdkFont* font)gdk_x11_font_get_name;
+	Display* function(GdkFont* font)gdk_x11_font_get_xdisplay;
+	gpointer function(GdkFont* font)gdk_x11_font_get_xfont;
+	Display* function(GdkGC* gc)gdk_x11_gc_get_xdisplay;
+	GC function(GdkGC* gc)gdk_x11_gc_get_xgc;
+	Window function()gdk_x11_get_default_root_xwindow;
+	gint function()gdk_x11_get_default_screen;
+	Display* function()gdk_x11_get_default_xdisplay;
+	void function()gdk_x11_grab_server;
+	Display* function(GdkImage* image)gdk_x11_image_get_xdisplay;
+	XImage* function(GdkImage* image)gdk_x11_image_get_ximage;
+	int function(GdkScreen* screen)gdk_x11_screen_get_screen_number;
+	Screen* function(GdkScreen* screen)gdk_x11_screen_get_xscreen;
+	void function()gdk_x11_ungrab_server;
+	Visual* function(GdkVisual* visual)gdk_x11_visual_get_xvisual;
+	Atom function(GdkAtom atom)gdk_x11_atom_to_xatom;
+	Atom function(GdkDisplay* display, GdkAtom atom)gdk_x11_atom_to_xatom_for_display;
+	GdkAtom function(Atom xatom)gdk_x11_xatom_to_atom;
+	GdkAtom function(GdkDisplay* display, Atom xatom)gdk_x11_xatom_to_atom_for_display;
+	Atom function(gchar* atomName)gdk_x11_get_xatom_by_name;
+	Atom function(GdkDisplay* display, gchar* atomName)gdk_x11_get_xatom_by_name_for_display;
+	gchar* function(Atom xatom)gdk_x11_get_xatom_name;
+	gchar* function(GdkDisplay* display, Atom xatom)gdk_x11_get_xatom_name_for_display;
+        +/
+	
+	// gdk.
+	
+	cairo_t* function(GdkDrawable* drawable)gdk_cairo_create;
+	void function(cairo_t* cr, GdkColor* color)gdk_cairo_set_source_color;
+	void function(cairo_t* cr, GdkPixbuf* pixbuf, double pixbufX, double pixbufY)gdk_cairo_set_source_pixbuf;
+	void function(cairo_t* cr, GdkPixmap* pixmap, double pixmapX, double pixmapY)gdk_cairo_set_source_pixmap;
+	void function(cairo_t* cr, GdkRectangle* rectangle)gdk_cairo_rectangle;
+	void function(cairo_t* cr, GdkRegion* region)gdk_cairo_region;
+
+
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+Symbol[] gdkLinks = 
+[
+
+	{ "gdk_init",  cast(void**)& gdk_init},
+	{ "gdk_init_check",  cast(void**)& gdk_init_check},
+	{ "gdk_parse_args",  cast(void**)& gdk_parse_args},
+	{ "gdk_get_display_arg_name",  cast(void**)& gdk_get_display_arg_name},
+	{ "gdk_set_locale",  cast(void**)& gdk_set_locale},
+	{ "gdk_set_sm_client_id",  cast(void**)& gdk_set_sm_client_id},
+	{ "gdk_exit",  cast(void**)& gdk_exit},
+	{ "gdk_notify_startup_complete",  cast(void**)& gdk_notify_startup_complete},
+	{ "gdk_notify_startup_complete_with_id",  cast(void**)& gdk_notify_startup_complete_with_id},
+	{ "gdk_get_program_class",  cast(void**)& gdk_get_program_class},
+	{ "gdk_set_program_class",  cast(void**)& gdk_set_program_class},
+	{ "gdk_get_display",  cast(void**)& gdk_get_display},
+	{ "gdk_flush",  cast(void**)& gdk_flush},
+	{ "gdk_screen_width",  cast(void**)& gdk_screen_width},
+	{ "gdk_screen_height",  cast(void**)& gdk_screen_height},
+	{ "gdk_screen_width_mm",  cast(void**)& gdk_screen_width_mm},
+	{ "gdk_screen_height_mm",  cast(void**)& gdk_screen_height_mm},
+	{ "gdk_pointer_grab",  cast(void**)& gdk_pointer_grab},
+	{ "gdk_pointer_ungrab",  cast(void**)& gdk_pointer_ungrab},
+	{ "gdk_pointer_is_grabbed",  cast(void**)& gdk_pointer_is_grabbed},
+	{ "gdk_set_double_click_time",  cast(void**)& gdk_set_double_click_time},
+	{ "gdk_keyboard_grab",  cast(void**)& gdk_keyboard_grab},
+	{ "gdk_keyboard_ungrab",  cast(void**)& gdk_keyboard_ungrab},
+	{ "gdk_beep",  cast(void**)& gdk_beep},
+	{ "gdk_get_use_xshm",  cast(void**)& gdk_get_use_xshm},
+	{ "gdk_set_use_xshm",  cast(void**)& gdk_set_use_xshm},
+	{ "gdk_error_trap_push",  cast(void**)& gdk_error_trap_push},
+	{ "gdk_error_trap_pop",  cast(void**)& gdk_error_trap_pop},
+	{ "gdk_display_open",  cast(void**)& gdk_display_open},
+	{ "gdk_display_get_default",  cast(void**)& gdk_display_get_default},
+	{ "gdk_display_get_name",  cast(void**)& gdk_display_get_name},
+	{ "gdk_display_get_n_screens",  cast(void**)& gdk_display_get_n_screens},
+	{ "gdk_display_get_screen",  cast(void**)& gdk_display_get_screen},
+	{ "gdk_display_get_default_screen",  cast(void**)& gdk_display_get_default_screen},
+	{ "gdk_display_pointer_ungrab",  cast(void**)& gdk_display_pointer_ungrab},
+	{ "gdk_display_keyboard_ungrab",  cast(void**)& gdk_display_keyboard_ungrab},
+	{ "gdk_display_pointer_is_grabbed",  cast(void**)& gdk_display_pointer_is_grabbed},
+	{ "gdk_display_beep",  cast(void**)& gdk_display_beep},
+	{ "gdk_display_sync",  cast(void**)& gdk_display_sync},
+	{ "gdk_display_flush",  cast(void**)& gdk_display_flush},
+	{ "gdk_display_close",  cast(void**)& gdk_display_close},
+	{ "gdk_display_list_devices",  cast(void**)& gdk_display_list_devices},
+	{ "gdk_display_get_event",  cast(void**)& gdk_display_get_event},
+	{ "gdk_display_peek_event",  cast(void**)& gdk_display_peek_event},
+	{ "gdk_display_put_event",  cast(void**)& gdk_display_put_event},
+	{ "gdk_display_add_client_message_filter",  cast(void**)& gdk_display_add_client_message_filter},
+	{ "gdk_display_set_double_click_time",  cast(void**)& gdk_display_set_double_click_time},
+	{ "gdk_display_set_double_click_distance",  cast(void**)& gdk_display_set_double_click_distance},
+	{ "gdk_display_get_pointer",  cast(void**)& gdk_display_get_pointer},
+	{ "gdk_display_get_window_at_pointer",  cast(void**)& gdk_display_get_window_at_pointer},
+	{ "gdk_display_set_pointer_hooks",  cast(void**)& gdk_display_set_pointer_hooks},
+	{ "gdk_display_warp_pointer",  cast(void**)& gdk_display_warp_pointer},
+	{ "gdk_display_supports_cursor_color",  cast(void**)& gdk_display_supports_cursor_color},
+	{ "gdk_display_supports_cursor_alpha",  cast(void**)& gdk_display_supports_cursor_alpha},
+	{ "gdk_display_get_default_cursor_size",  cast(void**)& gdk_display_get_default_cursor_size},
+	{ "gdk_display_get_maximal_cursor_size",  cast(void**)& gdk_display_get_maximal_cursor_size},
+	{ "gdk_display_get_default_group",  cast(void**)& gdk_display_get_default_group},
+	{ "gdk_display_supports_selection_notification",  cast(void**)& gdk_display_supports_selection_notification},
+	{ "gdk_display_request_selection_notification",  cast(void**)& gdk_display_request_selection_notification},
+	{ "gdk_display_supports_clipboard_persistence",  cast(void**)& gdk_display_supports_clipboard_persistence},
+	{ "gdk_display_store_clipboard",  cast(void**)& gdk_display_store_clipboard},
+	{ "gdk_display_supports_shapes",  cast(void**)& gdk_display_supports_shapes},
+	{ "gdk_display_supports_input_shapes",  cast(void**)& gdk_display_supports_input_shapes},
+	{ "gdk_display_supports_composite",  cast(void**)& gdk_display_supports_composite},
+	{ "gdk_display_manager_get",  cast(void**)& gdk_display_manager_get},
+	{ "gdk_display_manager_get_default_display",  cast(void**)& gdk_display_manager_get_default_display},
+	{ "gdk_display_manager_set_default_display",  cast(void**)& gdk_display_manager_set_default_display},
+	{ "gdk_display_manager_list_displays",  cast(void**)& gdk_display_manager_list_displays},
+	{ "gdk_display_get_core_pointer",  cast(void**)& gdk_display_get_core_pointer},
+	{ "gdk_screen_get_default",  cast(void**)& gdk_screen_get_default},
+	{ "gdk_screen_get_default_colormap",  cast(void**)& gdk_screen_get_default_colormap},
+	{ "gdk_screen_set_default_colormap",  cast(void**)& gdk_screen_set_default_colormap},
+	{ "gdk_screen_get_system_colormap",  cast(void**)& gdk_screen_get_system_colormap},
+	{ "gdk_screen_get_system_visual",  cast(void**)& gdk_screen_get_system_visual},
+	{ "gdk_screen_get_rgb_colormap",  cast(void**)& gdk_screen_get_rgb_colormap},
+	{ "gdk_screen_get_rgb_visual",  cast(void**)& gdk_screen_get_rgb_visual},
+	{ "gdk_screen_get_rgba_colormap",  cast(void**)& gdk_screen_get_rgba_colormap},
+	{ "gdk_screen_get_rgba_visual",  cast(void**)& gdk_screen_get_rgba_visual},
+	{ "gdk_screen_is_composited",  cast(void**)& gdk_screen_is_composited},
+	{ "gdk_screen_get_root_window",  cast(void**)& gdk_screen_get_root_window},
+	{ "gdk_screen_get_display",  cast(void**)& gdk_screen_get_display},
+	{ "gdk_screen_get_number",  cast(void**)& gdk_screen_get_number},
+	{ "gdk_screen_get_width",  cast(void**)& gdk_screen_get_width},
+	{ "gdk_screen_get_height",  cast(void**)& gdk_screen_get_height},
+	{ "gdk_screen_get_width_mm",  cast(void**)& gdk_screen_get_width_mm},
+	{ "gdk_screen_get_height_mm",  cast(void**)& gdk_screen_get_height_mm},
+	{ "gdk_screen_list_visuals",  cast(void**)& gdk_screen_list_visuals},
+	{ "gdk_screen_get_toplevel_windows",  cast(void**)& gdk_screen_get_toplevel_windows},
+	{ "gdk_screen_make_display_name",  cast(void**)& gdk_screen_make_display_name},
+	{ "gdk_screen_get_n_monitors",  cast(void**)& gdk_screen_get_n_monitors},
+	{ "gdk_screen_get_monitor_geometry",  cast(void**)& gdk_screen_get_monitor_geometry},
+	{ "gdk_screen_get_monitor_at_point",  cast(void**)& gdk_screen_get_monitor_at_point},
+	{ "gdk_screen_get_monitor_at_window",  cast(void**)& gdk_screen_get_monitor_at_window},
+	{ "gdk_screen_broadcast_client_message",  cast(void**)& gdk_screen_broadcast_client_message},
+	{ "gdk_screen_get_setting",  cast(void**)& gdk_screen_get_setting},
+	{ "gdk_screen_get_font_options",  cast(void**)& gdk_screen_get_font_options},
+	{ "gdk_screen_set_font_options",  cast(void**)& gdk_screen_set_font_options},
+	{ "gdk_screen_get_resolution",  cast(void**)& gdk_screen_get_resolution},
+	{ "gdk_screen_set_resolution",  cast(void**)& gdk_screen_set_resolution},
+	{ "gdk_screen_get_active_window",  cast(void**)& gdk_screen_get_active_window},
+	{ "gdk_screen_get_window_stack",  cast(void**)& gdk_screen_get_window_stack},
+	{ "gdk_spawn_on_screen",  cast(void**)& gdk_spawn_on_screen},
+	{ "gdk_spawn_on_screen_with_pipes",  cast(void**)& gdk_spawn_on_screen_with_pipes},
+	{ "gdk_spawn_command_line_on_screen",  cast(void**)& gdk_spawn_command_line_on_screen},
+	{ "gdk_rectangle_intersect",  cast(void**)& gdk_rectangle_intersect},
+	{ "gdk_rectangle_union",  cast(void**)& gdk_rectangle_union},
+	{ "gdk_region_new",  cast(void**)& gdk_region_new},
+	{ "gdk_region_polygon",  cast(void**)& gdk_region_polygon},
+	{ "gdk_region_copy",  cast(void**)& gdk_region_copy},
+	{ "gdk_region_rectangle",  cast(void**)& gdk_region_rectangle},
+	{ "gdk_region_destroy",  cast(void**)& gdk_region_destroy},
+	{ "gdk_region_get_clipbox",  cast(void**)& gdk_region_get_clipbox},
+	{ "gdk_region_get_rectangles",  cast(void**)& gdk_region_get_rectangles},
+	{ "gdk_region_empty",  cast(void**)& gdk_region_empty},
+	{ "gdk_region_equal",  cast(void**)& gdk_region_equal},
+	{ "gdk_region_point_in",  cast(void**)& gdk_region_point_in},
+	{ "gdk_region_rect_in",  cast(void**)& gdk_region_rect_in},
+	{ "gdk_region_offset",  cast(void**)& gdk_region_offset},
+	{ "gdk_region_shrink",  cast(void**)& gdk_region_shrink},
+	{ "gdk_region_union_with_rect",  cast(void**)& gdk_region_union_with_rect},
+	{ "gdk_region_intersect",  cast(void**)& gdk_region_intersect},
+	{ "gdk_region_union",  cast(void**)& gdk_region_union},
+	{ "gdk_region_subtract",  cast(void**)& gdk_region_subtract},
+	{ "gdk_region_xor",  cast(void**)& gdk_region_xor},
+	{ "gdk_region_spans_intersect_foreach",  cast(void**)& gdk_region_spans_intersect_foreach},
+	{ "gdk_gc_new",  cast(void**)& gdk_gc_new},
+	{ "gdk_gc_new_with_values",  cast(void**)& gdk_gc_new_with_values},
+	{ "gdk_gc_get_screen",  cast(void**)& gdk_gc_get_screen},
+	{ "gdk_gc_ref",  cast(void**)& gdk_gc_ref},
+	{ "gdk_gc_unref",  cast(void**)& gdk_gc_unref},
+	{ "gdk_gc_set_values",  cast(void**)& gdk_gc_set_values},
+	{ "gdk_gc_get_values",  cast(void**)& gdk_gc_get_values},
+	{ "gdk_gc_set_foreground",  cast(void**)& gdk_gc_set_foreground},
+	{ "gdk_gc_set_background",  cast(void**)& gdk_gc_set_background},
+	{ "gdk_gc_set_rgb_fg_color",  cast(void**)& gdk_gc_set_rgb_fg_color},
+	{ "gdk_gc_set_rgb_bg_color",  cast(void**)& gdk_gc_set_rgb_bg_color},
+	{ "gdk_gc_set_font",  cast(void**)& gdk_gc_set_font},
+	{ "gdk_gc_set_function",  cast(void**)& gdk_gc_set_function},
+	{ "gdk_gc_set_fill",  cast(void**)& gdk_gc_set_fill},
+	{ "gdk_gc_set_tile",  cast(void**)& gdk_gc_set_tile},
+	{ "gdk_gc_set_stipple",  cast(void**)& gdk_gc_set_stipple},
+	{ "gdk_gc_set_ts_origin",  cast(void**)& gdk_gc_set_ts_origin},
+	{ "gdk_gc_set_clip_origin",  cast(void**)& gdk_gc_set_clip_origin},
+	{ "gdk_gc_set_clip_mask",  cast(void**)& gdk_gc_set_clip_mask},
+	{ "gdk_gc_set_clip_rectangle",  cast(void**)& gdk_gc_set_clip_rectangle},
+	{ "gdk_gc_set_clip_region",  cast(void**)& gdk_gc_set_clip_region},
+	{ "gdk_gc_set_subwindow",  cast(void**)& gdk_gc_set_subwindow},
+	{ "gdk_gc_set_exposures",  cast(void**)& gdk_gc_set_exposures},
+	{ "gdk_gc_set_line_attributes",  cast(void**)& gdk_gc_set_line_attributes},
+	{ "gdk_gc_set_dashes",  cast(void**)& gdk_gc_set_dashes},
+	{ "gdk_gc_copy",  cast(void**)& gdk_gc_copy},
+	{ "gdk_gc_set_colormap",  cast(void**)& gdk_gc_set_colormap},
+	{ "gdk_gc_get_colormap",  cast(void**)& gdk_gc_get_colormap},
+	{ "gdk_gc_offset",  cast(void**)& gdk_gc_offset},
+	{ "gdk_drawable_ref",  cast(void**)& gdk_drawable_ref},
+	{ "gdk_drawable_unref",  cast(void**)& gdk_drawable_unref},
+	{ "gdk_drawable_set_data",  cast(void**)& gdk_drawable_set_data},
+	{ "gdk_drawable_get_data",  cast(void**)& gdk_drawable_get_data},
+	{ "gdk_drawable_get_display",  cast(void**)& gdk_drawable_get_display},
+	{ "gdk_drawable_get_screen",  cast(void**)& gdk_drawable_get_screen},
+	{ "gdk_drawable_get_visual",  cast(void**)& gdk_drawable_get_visual},
+	{ "gdk_drawable_set_colormap",  cast(void**)& gdk_drawable_set_colormap},
+	{ "gdk_drawable_get_colormap",  cast(void**)& gdk_drawable_get_colormap},
+	{ "gdk_drawable_get_depth",  cast(void**)& gdk_drawable_get_depth},
+	{ "gdk_drawable_get_size",  cast(void**)& gdk_drawable_get_size},
+	{ "gdk_drawable_get_clip_region",  cast(void**)& gdk_drawable_get_clip_region},
+	{ "gdk_drawable_get_visible_region",  cast(void**)& gdk_drawable_get_visible_region},
+	{ "gdk_draw_point",  cast(void**)& gdk_draw_point},
+	{ "gdk_draw_points",  cast(void**)& gdk_draw_points},
+	{ "gdk_draw_line",  cast(void**)& gdk_draw_line},
+	{ "gdk_draw_lines",  cast(void**)& gdk_draw_lines},
+	{ "gdk_draw_pixbuf",  cast(void**)& gdk_draw_pixbuf},
+	{ "gdk_draw_segments",  cast(void**)& gdk_draw_segments},
+	{ "gdk_draw_rectangle",  cast(void**)& gdk_draw_rectangle},
+	{ "gdk_draw_arc",  cast(void**)& gdk_draw_arc},
+	{ "gdk_draw_polygon",  cast(void**)& gdk_draw_polygon},
+	{ "gdk_draw_trapezoids",  cast(void**)& gdk_draw_trapezoids},
+	{ "gdk_draw_glyphs",  cast(void**)& gdk_draw_glyphs},
+	{ "gdk_draw_glyphs_transformed",  cast(void**)& gdk_draw_glyphs_transformed},
+	{ "gdk_draw_layout_line",  cast(void**)& gdk_draw_layout_line},
+	{ "gdk_draw_layout_line_with_colors",  cast(void**)& gdk_draw_layout_line_with_colors},
+	{ "gdk_draw_layout",  cast(void**)& gdk_draw_layout},
+	{ "gdk_draw_layout_with_colors",  cast(void**)& gdk_draw_layout_with_colors},
+	{ "gdk_draw_string",  cast(void**)& gdk_draw_string},
+	{ "gdk_draw_text",  cast(void**)& gdk_draw_text},
+	{ "gdk_draw_text_wc",  cast(void**)& gdk_draw_text_wc},
+	{ "gdk_draw_drawable",  cast(void**)& gdk_draw_drawable},
+	{ "gdk_draw_image",  cast(void**)& gdk_draw_image},
+	{ "gdk_drawable_get_image",  cast(void**)& gdk_drawable_get_image},
+	{ "gdk_drawable_copy_to_image",  cast(void**)& gdk_drawable_copy_to_image},
+	{ "gdk_pixmap_new",  cast(void**)& gdk_pixmap_new},
+	{ "gdk_pixmap_create_from_data",  cast(void**)& gdk_pixmap_create_from_data},
+	{ "gdk_pixmap_create_from_xpm",  cast(void**)& gdk_pixmap_create_from_xpm},
+	{ "gdk_pixmap_colormap_create_from_xpm",  cast(void**)& gdk_pixmap_colormap_create_from_xpm},
+	{ "gdk_pixmap_create_from_xpm_d",  cast(void**)& gdk_pixmap_create_from_xpm_d},
+	{ "gdk_pixmap_colormap_create_from_xpm_d",  cast(void**)& gdk_pixmap_colormap_create_from_xpm_d},
+	{ "gdk_bitmap_create_from_data",  cast(void**)& gdk_bitmap_create_from_data},
+	{ "gdk_rgb_init",  cast(void**)& gdk_rgb_init},
+	{ "gdk_draw_rgb_image",  cast(void**)& gdk_draw_rgb_image},
+	{ "gdk_draw_rgb_image_dithalign",  cast(void**)& gdk_draw_rgb_image_dithalign},
+	{ "gdk_draw_indexed_image",  cast(void**)& gdk_draw_indexed_image},
+	{ "gdk_draw_gray_image",  cast(void**)& gdk_draw_gray_image},
+	{ "gdk_draw_rgb_32_image",  cast(void**)& gdk_draw_rgb_32_image},
+	{ "gdk_draw_rgb_32_image_dithalign",  cast(void**)& gdk_draw_rgb_32_image_dithalign},
+	{ "gdk_rgb_cmap_new",  cast(void**)& gdk_rgb_cmap_new},
+	{ "gdk_rgb_cmap_free",  cast(void**)& gdk_rgb_cmap_free},
+	{ "gdk_rgb_gc_set_foreground",  cast(void**)& gdk_rgb_gc_set_foreground},
+	{ "gdk_rgb_gc_set_background",  cast(void**)& gdk_rgb_gc_set_background},
+	{ "gdk_rgb_xpixel_from_rgb",  cast(void**)& gdk_rgb_xpixel_from_rgb},
+	{ "gdk_rgb_find_color",  cast(void**)& gdk_rgb_find_color},
+	{ "gdk_rgb_set_install",  cast(void**)& gdk_rgb_set_install},
+	{ "gdk_rgb_set_min_colors",  cast(void**)& gdk_rgb_set_min_colors},
+	{ "gdk_rgb_get_visual",  cast(void**)& gdk_rgb_get_visual},
+	{ "gdk_rgb_get_colormap",  cast(void**)& gdk_rgb_get_colormap},
+	{ "gdk_rgb_ditherable",  cast(void**)& gdk_rgb_ditherable},
+	{ "gdk_rgb_colormap_ditherable",  cast(void**)& gdk_rgb_colormap_ditherable},
+	{ "gdk_rgb_set_verbose",  cast(void**)& gdk_rgb_set_verbose},
+	{ "gdk_image_new",  cast(void**)& gdk_image_new},
+	{ "gdk_image_new_bitmap",  cast(void**)& gdk_image_new_bitmap},
+	{ "gdk_image_get",  cast(void**)& gdk_image_get},
+	{ "gdk_image_ref",  cast(void**)& gdk_image_ref},
+	{ "gdk_image_unref",  cast(void**)& gdk_image_unref},
+	{ "gdk_image_get_colormap",  cast(void**)& gdk_image_get_colormap},
+	{ "gdk_image_set_colormap",  cast(void**)& gdk_image_set_colormap},
+	{ "gdk_image_put_pixel",  cast(void**)& gdk_image_put_pixel},
+	{ "gdk_image_get_pixel",  cast(void**)& gdk_image_get_pixel},
+	{ "gdk_pixbuf_render_threshold_alpha",  cast(void**)& gdk_pixbuf_render_threshold_alpha},
+	{ "gdk_pixbuf_render_to_drawable",  cast(void**)& gdk_pixbuf_render_to_drawable},
+	{ "gdk_pixbuf_render_to_drawable_alpha",  cast(void**)& gdk_pixbuf_render_to_drawable_alpha},
+	{ "gdk_pixbuf_render_pixmap_and_mask",  cast(void**)& gdk_pixbuf_render_pixmap_and_mask},
+	{ "gdk_pixbuf_render_pixmap_and_mask_for_colormap",  cast(void**)& gdk_pixbuf_render_pixmap_and_mask_for_colormap},
+	{ "gdk_pixbuf_get_from_drawable",  cast(void**)& gdk_pixbuf_get_from_drawable},
+	{ "gdk_pixbuf_get_from_image",  cast(void**)& gdk_pixbuf_get_from_image},
+	{ "gdk_pixbuf_get_type",  cast(void**)& gdk_pixbuf_get_type},
+	{ "gdk_pixbuf_new_from_data",  cast(void**)& gdk_pixbuf_new_from_data},
+	{ "gdk_pixbuf_new_from_xpm_data",  cast(void**)& gdk_pixbuf_new_from_xpm_data},
+	{ "gdk_pixbuf_new_from_inline",  cast(void**)& gdk_pixbuf_new_from_inline},
+	{ "gdk_pixbuf_new_subpixbuf",  cast(void**)& gdk_pixbuf_new_subpixbuf},
+	{ "gdk_pixbuf_copy",  cast(void**)& gdk_pixbuf_copy},
+	{ "gdk_pixbuf_get_colorspace",  cast(void**)& gdk_pixbuf_get_colorspace},
+	{ "gdk_pixbuf_get_n_channels",  cast(void**)& gdk_pixbuf_get_n_channels},
+	{ "gdk_pixbuf_get_has_alpha",  cast(void**)& gdk_pixbuf_get_has_alpha},
+	{ "gdk_pixbuf_get_bits_per_sample",  cast(void**)& gdk_pixbuf_get_bits_per_sample},
+	{ "gdk_pixbuf_get_pixels",  cast(void**)& gdk_pixbuf_get_pixels},
+	{ "gdk_pixbuf_get_width",  cast(void**)& gdk_pixbuf_get_width},
+	{ "gdk_pixbuf_get_height",  cast(void**)& gdk_pixbuf_get_height},
+	{ "gdk_pixbuf_get_rowstride",  cast(void**)& gdk_pixbuf_get_rowstride},
+	{ "gdk_pixbuf_get_option",  cast(void**)& gdk_pixbuf_get_option},
+	{ "gdk_pixbuf_new_from_file",  cast(void**)& gdk_pixbuf_new_from_file},
+	{ "gdk_pixbuf_new_from_file_at_size",  cast(void**)& gdk_pixbuf_new_from_file_at_size},
+	{ "gdk_pixbuf_new_from_file_at_scale",  cast(void**)& gdk_pixbuf_new_from_file_at_scale},
+	{ "gdk_pixbuf_savev",  cast(void**)& gdk_pixbuf_savev},
+	{ "gdk_pixbuf_save",  cast(void**)& gdk_pixbuf_save},
+	{ "gdk_pixbuf_save_to_callback",  cast(void**)& gdk_pixbuf_save_to_callback},
+	{ "gdk_pixbuf_save_to_callbackv",  cast(void**)& gdk_pixbuf_save_to_callbackv},
+	{ "gdk_pixbuf_save_to_buffer",  cast(void**)& gdk_pixbuf_save_to_buffer},
+	{ "gdk_pixbuf_save_to_bufferv",  cast(void**)& gdk_pixbuf_save_to_bufferv},
+	{ "gdk_pixbuf_scale_simple",  cast(void**)& gdk_pixbuf_scale_simple},
+	{ "gdk_pixbuf_scale",  cast(void**)& gdk_pixbuf_scale},
+	{ "gdk_pixbuf_composite_color_simple",  cast(void**)& gdk_pixbuf_composite_color_simple},
+	{ "gdk_pixbuf_composite",  cast(void**)& gdk_pixbuf_composite},
+	{ "gdk_pixbuf_composite_color",  cast(void**)& gdk_pixbuf_composite_color},
+	{ "gdk_pixbuf_rotate_simple",  cast(void**)& gdk_pixbuf_rotate_simple},
+	{ "gdk_pixbuf_flip",  cast(void**)& gdk_pixbuf_flip},
+	{ "gdk_pixbuf_add_alpha",  cast(void**)& gdk_pixbuf_add_alpha},
+	{ "gdk_pixbuf_copy_area",  cast(void**)& gdk_pixbuf_copy_area},
+	{ "gdk_pixbuf_saturate_and_pixelate",  cast(void**)& gdk_pixbuf_saturate_and_pixelate},
+	{ "gdk_pixbuf_apply_embedded_orientation",  cast(void**)& gdk_pixbuf_apply_embedded_orientation},
+	{ "gdk_pixbuf_fill",  cast(void**)& gdk_pixbuf_fill},
+	{ "gdk_colormap_new",  cast(void**)& gdk_colormap_new},
+	{ "gdk_colormap_ref",  cast(void**)& gdk_colormap_ref},
+	{ "gdk_colormap_unref",  cast(void**)& gdk_colormap_unref},
+	{ "gdk_colormap_get_system",  cast(void**)& gdk_colormap_get_system},
+	{ "gdk_colormap_get_system_size",  cast(void**)& gdk_colormap_get_system_size},
+	{ "gdk_colormap_change",  cast(void**)& gdk_colormap_change},
+	{ "gdk_colormap_alloc_colors",  cast(void**)& gdk_colormap_alloc_colors},
+	{ "gdk_colormap_alloc_color",  cast(void**)& gdk_colormap_alloc_color},
+	{ "gdk_colormap_free_colors",  cast(void**)& gdk_colormap_free_colors},
+	{ "gdk_colormap_query_color",  cast(void**)& gdk_colormap_query_color},
+	{ "gdk_colormap_get_visual",  cast(void**)& gdk_colormap_get_visual},
+	{ "gdk_colormap_get_screen",  cast(void**)& gdk_colormap_get_screen},
+	{ "gdk_colors_store",  cast(void**)& gdk_colors_store},
+	{ "gdk_colors_alloc",  cast(void**)& gdk_colors_alloc},
+	{ "gdk_colors_free",  cast(void**)& gdk_colors_free},
+	{ "gdk_color_copy",  cast(void**)& gdk_color_copy},
+	{ "gdk_color_free",  cast(void**)& gdk_color_free},
+	{ "gdk_color_white",  cast(void**)& gdk_color_white},
+	{ "gdk_color_black",  cast(void**)& gdk_color_black},
+	{ "gdk_color_parse",  cast(void**)& gdk_color_parse},
+	{ "gdk_color_alloc",  cast(void**)& gdk_color_alloc},
+	{ "gdk_color_change",  cast(void**)& gdk_color_change},
+	{ "gdk_color_equal",  cast(void**)& gdk_color_equal},
+	{ "gdk_color_hash",  cast(void**)& gdk_color_hash},
+	{ "gdk_color_to_string",  cast(void**)& gdk_color_to_string},
+	{ "gdk_query_depths",  cast(void**)& gdk_query_depths},
+	{ "gdk_query_visual_types",  cast(void**)& gdk_query_visual_types},
+	{ "gdk_list_visuals",  cast(void**)& gdk_list_visuals},
+	{ "gdk_visual_get_best_depth",  cast(void**)& gdk_visual_get_best_depth},
+	{ "gdk_visual_get_best_type",  cast(void**)& gdk_visual_get_best_type},
+	{ "gdk_visual_get_system",  cast(void**)& gdk_visual_get_system},
+	{ "gdk_visual_get_best",  cast(void**)& gdk_visual_get_best},
+	{ "gdk_visual_get_best_with_depth",  cast(void**)& gdk_visual_get_best_with_depth},
+	{ "gdk_visual_get_best_with_type",  cast(void**)& gdk_visual_get_best_with_type},
+	{ "gdk_visual_get_best_with_both",  cast(void**)& gdk_visual_get_best_with_both},
+	{ "gdk_visual_get_screen",  cast(void**)& gdk_visual_get_screen},
+	{ "gdk_font_load",  cast(void**)& gdk_font_load},
+	{ "gdk_font_load_for_display",  cast(void**)& gdk_font_load_for_display},
+	{ "gdk_fontset_load",  cast(void**)& gdk_fontset_load},
+	{ "gdk_fontset_load_for_display",  cast(void**)& gdk_fontset_load_for_display},
+	{ "gdk_font_from_description",  cast(void**)& gdk_font_from_description},
+	{ "gdk_font_from_description_for_display",  cast(void**)& gdk_font_from_description_for_display},
+	{ "gdk_font_get_display",  cast(void**)& gdk_font_get_display},
+	{ "gdk_font_ref",  cast(void**)& gdk_font_ref},
+	{ "gdk_font_unref",  cast(void**)& gdk_font_unref},
+	{ "gdk_font_id",  cast(void**)& gdk_font_id},
+	{ "gdk_font_equal",  cast(void**)& gdk_font_equal},
+	{ "gdk_string_extents",  cast(void**)& gdk_string_extents},
+	{ "gdk_text_extents",  cast(void**)& gdk_text_extents},
+	{ "gdk_text_extents_wc",  cast(void**)& gdk_text_extents_wc},
+	{ "gdk_string_width",  cast(void**)& gdk_string_width},
+	{ "gdk_text_width",  cast(void**)& gdk_text_width},
+	{ "gdk_text_width_wc",  cast(void**)& gdk_text_width_wc},
+	{ "gdk_char_width",  cast(void**)& gdk_char_width},
+	{ "gdk_char_width_wc",  cast(void**)& gdk_char_width_wc},
+	{ "gdk_string_measure",  cast(void**)& gdk_string_measure},
+	{ "gdk_text_measure",  cast(void**)& gdk_text_measure},
+	{ "gdk_char_measure",  cast(void**)& gdk_char_measure},
+	{ "gdk_string_height",  cast(void**)& gdk_string_height},
+	{ "gdk_text_height",  cast(void**)& gdk_text_height},
+	{ "gdk_char_height",  cast(void**)& gdk_char_height},
+	{ "gdk_wcstombs",  cast(void**)& gdk_wcstombs},
+	{ "gdk_mbstowcs",  cast(void**)& gdk_mbstowcs},
+	{ "gdk_cursor_new",  cast(void**)& gdk_cursor_new},
+	{ "gdk_cursor_new_from_pixmap",  cast(void**)& gdk_cursor_new_from_pixmap},
+	{ "gdk_cursor_new_from_pixbuf",  cast(void**)& gdk_cursor_new_from_pixbuf},
+	{ "gdk_cursor_new_from_name",  cast(void**)& gdk_cursor_new_from_name},
+	{ "gdk_cursor_new_for_display",  cast(void**)& gdk_cursor_new_for_display},
+	{ "gdk_cursor_get_display",  cast(void**)& gdk_cursor_get_display},
+	{ "gdk_cursor_get_image",  cast(void**)& gdk_cursor_get_image},
+	{ "gdk_cursor_ref",  cast(void**)& gdk_cursor_ref},
+	{ "gdk_cursor_unref",  cast(void**)& gdk_cursor_unref},
+	{ "gdk_window_new",  cast(void**)& gdk_window_new},
+	{ "gdk_window_destroy",  cast(void**)& gdk_window_destroy},
+	{ "gdk_window_get_window_type",  cast(void**)& gdk_window_get_window_type},
+	{ "gdk_window_at_pointer",  cast(void**)& gdk_window_at_pointer},
+	{ "gdk_window_show",  cast(void**)& gdk_window_show},
+	{ "gdk_window_show_unraised",  cast(void**)& gdk_window_show_unraised},
+	{ "gdk_window_hide",  cast(void**)& gdk_window_hide},
+	{ "gdk_window_is_visible",  cast(void**)& gdk_window_is_visible},
+	{ "gdk_window_is_viewable",  cast(void**)& gdk_window_is_viewable},
+	{ "gdk_window_get_state",  cast(void**)& gdk_window_get_state},
+	{ "gdk_window_withdraw",  cast(void**)& gdk_window_withdraw},
+	{ "gdk_window_iconify",  cast(void**)& gdk_window_iconify},
+	{ "gdk_window_deiconify",  cast(void**)& gdk_window_deiconify},
+	{ "gdk_window_stick",  cast(void**)& gdk_window_stick},
+	{ "gdk_window_unstick",  cast(void**)& gdk_window_unstick},
+	{ "gdk_window_maximize",  cast(void**)& gdk_window_maximize},
+	{ "gdk_window_unmaximize",  cast(void**)& gdk_window_unmaximize},
+	{ "gdk_window_fullscreen",  cast(void**)& gdk_window_fullscreen},
+	{ "gdk_window_unfullscreen",  cast(void**)& gdk_window_unfullscreen},
+	{ "gdk_window_set_keep_above",  cast(void**)& gdk_window_set_keep_above},
+	{ "gdk_window_set_keep_below",  cast(void**)& gdk_window_set_keep_below},
+	{ "gdk_window_set_opacity",  cast(void**)& gdk_window_set_opacity},
+	{ "gdk_window_set_composited",  cast(void**)& gdk_window_set_composited},
+	{ "gdk_window_move",  cast(void**)& gdk_window_move},
+	{ "gdk_window_resize",  cast(void**)& gdk_window_resize},
+	{ "gdk_window_move_resize",  cast(void**)& gdk_window_move_resize},
+	{ "gdk_window_scroll",  cast(void**)& gdk_window_scroll},
+	{ "gdk_window_move_region",  cast(void**)& gdk_window_move_region},
+	{ "gdk_window_reparent",  cast(void**)& gdk_window_reparent},
+	{ "gdk_window_clear",  cast(void**)& gdk_window_clear},
+	{ "gdk_window_clear_area",  cast(void**)& gdk_window_clear_area},
+	{ "gdk_window_clear_area_e",  cast(void**)& gdk_window_clear_area_e},
+	{ "gdk_window_raise",  cast(void**)& gdk_window_raise},
+	{ "gdk_window_lower",  cast(void**)& gdk_window_lower},
+	{ "gdk_window_focus",  cast(void**)& gdk_window_focus},
+	{ "gdk_window_register_dnd",  cast(void**)& gdk_window_register_dnd},
+	{ "gdk_window_begin_resize_drag",  cast(void**)& gdk_window_begin_resize_drag},
+	{ "gdk_window_begin_move_drag",  cast(void**)& gdk_window_begin_move_drag},
+	{ "gdk_window_constrain_size",  cast(void**)& gdk_window_constrain_size},
+	{ "gdk_window_beep",  cast(void**)& gdk_window_beep},
+	{ "gdk_window_begin_paint_rect",  cast(void**)& gdk_window_begin_paint_rect},
+	{ "gdk_window_begin_paint_region",  cast(void**)& gdk_window_begin_paint_region},
+	{ "gdk_window_end_paint",  cast(void**)& gdk_window_end_paint},
+	{ "gdk_window_invalidate_rect",  cast(void**)& gdk_window_invalidate_rect},
+	{ "gdk_window_invalidate_region",  cast(void**)& gdk_window_invalidate_region},
+	{ "gdk_window_get_update_area",  cast(void**)& gdk_window_get_update_area},
+	{ "gdk_window_freeze_updates",  cast(void**)& gdk_window_freeze_updates},
+	{ "gdk_window_thaw_updates",  cast(void**)& gdk_window_thaw_updates},
+	{ "gdk_window_process_all_updates",  cast(void**)& gdk_window_process_all_updates},
+	{ "gdk_window_process_updates",  cast(void**)& gdk_window_process_updates},
+	{ "gdk_window_set_debug_updates",  cast(void**)& gdk_window_set_debug_updates},
+	{ "gdk_window_get_internal_paint_info",  cast(void**)& gdk_window_get_internal_paint_info},
+	{ "gdk_window_enable_synchronized_configure",  cast(void**)& gdk_window_enable_synchronized_configure},
+	{ "gdk_window_configure_finished",  cast(void**)& gdk_window_configure_finished},
+	{ "gdk_window_set_user_data",  cast(void**)& gdk_window_set_user_data},
+	{ "gdk_window_set_override_redirect",  cast(void**)& gdk_window_set_override_redirect},
+	{ "gdk_window_set_accept_focus",  cast(void**)& gdk_window_set_accept_focus},
+	{ "gdk_window_set_focus_on_map",  cast(void**)& gdk_window_set_focus_on_map},
+	{ "gdk_window_add_filter",  cast(void**)& gdk_window_add_filter},
+	{ "gdk_window_remove_filter",  cast(void**)& gdk_window_remove_filter},
+	{ "gdk_window_shape_combine_mask",  cast(void**)& gdk_window_shape_combine_mask},
+	{ "gdk_window_shape_combine_region",  cast(void**)& gdk_window_shape_combine_region},
+	{ "gdk_window_set_child_shapes",  cast(void**)& gdk_window_set_child_shapes},
+	{ "gdk_window_merge_child_shapes",  cast(void**)& gdk_window_merge_child_shapes},
+	{ "gdk_window_input_shape_combine_mask",  cast(void**)& gdk_window_input_shape_combine_mask},
+	{ "gdk_window_input_shape_combine_region",  cast(void**)& gdk_window_input_shape_combine_region},
+	{ "gdk_window_set_child_input_shapes",  cast(void**)& gdk_window_set_child_input_shapes},
+	{ "gdk_window_merge_child_input_shapes",  cast(void**)& gdk_window_merge_child_input_shapes},
+	{ "gdk_window_set_static_gravities",  cast(void**)& gdk_window_set_static_gravities},
+	{ "gdk_window_set_hints",  cast(void**)& gdk_window_set_hints},
+	{ "gdk_window_set_title",  cast(void**)& gdk_window_set_title},
+	{ "gdk_window_set_background",  cast(void**)& gdk_window_set_background},
+	{ "gdk_window_set_back_pixmap",  cast(void**)& gdk_window_set_back_pixmap},
+	{ "gdk_window_set_cursor",  cast(void**)& gdk_window_set_cursor},
+	{ "gdk_window_get_user_data",  cast(void**)& gdk_window_get_user_data},
+	{ "gdk_window_get_geometry",  cast(void**)& gdk_window_get_geometry},
+	{ "gdk_window_set_geometry_hints",  cast(void**)& gdk_window_set_geometry_hints},
+	{ "gdk_window_set_icon_list",  cast(void**)& gdk_window_set_icon_list},
+	{ "gdk_window_set_modal_hint",  cast(void**)& gdk_window_set_modal_hint},
+	{ "gdk_window_set_type_hint",  cast(void**)& gdk_window_set_type_hint},
+	{ "gdk_window_get_type_hint",  cast(void**)& gdk_window_get_type_hint},
+	{ "gdk_window_set_skip_taskbar_hint",  cast(void**)& gdk_window_set_skip_taskbar_hint},
+	{ "gdk_window_set_skip_pager_hint",  cast(void**)& gdk_window_set_skip_pager_hint},
+	{ "gdk_window_set_urgency_hint",  cast(void**)& gdk_window_set_urgency_hint},
+	{ "gdk_window_get_position",  cast(void**)& gdk_window_get_position},
+	{ "gdk_window_get_root_origin",  cast(void**)& gdk_window_get_root_origin},
+	{ "gdk_window_get_frame_extents",  cast(void**)& gdk_window_get_frame_extents},
+	{ "gdk_window_get_origin",  cast(void**)& gdk_window_get_origin},
+	{ "gdk_window_get_deskrelative_origin",  cast(void**)& gdk_window_get_deskrelative_origin},
+	{ "gdk_window_get_pointer",  cast(void**)& gdk_window_get_pointer},
+	{ "gdk_window_get_parent",  cast(void**)& gdk_window_get_parent},
+	{ "gdk_window_get_toplevel",  cast(void**)& gdk_window_get_toplevel},
+	{ "gdk_window_get_children",  cast(void**)& gdk_window_get_children},
+	{ "gdk_window_peek_children",  cast(void**)& gdk_window_peek_children},
+	{ "gdk_window_get_events",  cast(void**)& gdk_window_get_events},
+	{ "gdk_window_set_events",  cast(void**)& gdk_window_set_events},
+	{ "gdk_window_set_icon",  cast(void**)& gdk_window_set_icon},
+	{ "gdk_window_set_icon_name",  cast(void**)& gdk_window_set_icon_name},
+	{ "gdk_window_set_transient_for",  cast(void**)& gdk_window_set_transient_for},
+	{ "gdk_window_set_role",  cast(void**)& gdk_window_set_role},
+	{ "gdk_window_set_startup_id",  cast(void**)& gdk_window_set_startup_id},
+	{ "gdk_window_set_group",  cast(void**)& gdk_window_set_group},
+	{ "gdk_window_get_group",  cast(void**)& gdk_window_get_group},
+	{ "gdk_window_set_decorations",  cast(void**)& gdk_window_set_decorations},
+	{ "gdk_window_get_decorations",  cast(void**)& gdk_window_get_decorations},
+	{ "gdk_window_set_functions",  cast(void**)& gdk_window_set_functions},
+	{ "gdk_window_get_toplevels",  cast(void**)& gdk_window_get_toplevels},
+	{ "gdk_get_default_root_window",  cast(void**)& gdk_get_default_root_window},
+	{ "gdk_set_pointer_hooks",  cast(void**)& gdk_set_pointer_hooks},
+	{ "gdk_events_pending",  cast(void**)& gdk_events_pending},
+	{ "gdk_event_peek",  cast(void**)& gdk_event_peek},
+	{ "gdk_event_get",  cast(void**)& gdk_event_get},
+	{ "gdk_event_get_graphics_expose",  cast(void**)& gdk_event_get_graphics_expose},
+	{ "gdk_event_put",  cast(void**)& gdk_event_put},
+	{ "gdk_event_new",  cast(void**)& gdk_event_new},
+	{ "gdk_event_copy",  cast(void**)& gdk_event_copy},
+	{ "gdk_event_free",  cast(void**)& gdk_event_free},
+	{ "gdk_event_get_time",  cast(void**)& gdk_event_get_time},
+	{ "gdk_event_get_state",  cast(void**)& gdk_event_get_state},
+	{ "gdk_event_get_axis",  cast(void**)& gdk_event_get_axis},
+	{ "gdk_event_get_coords",  cast(void**)& gdk_event_get_coords},
+	{ "gdk_event_get_root_coords",  cast(void**)& gdk_event_get_root_coords},
+	{ "gdk_event_request_motions",  cast(void**)& gdk_event_request_motions},
+	{ "gdk_event_handler_set",  cast(void**)& gdk_event_handler_set},
+	{ "gdk_event_send_client_message",  cast(void**)& gdk_event_send_client_message},
+	{ "gdk_event_send_client_message_for_display",  cast(void**)& gdk_event_send_client_message_for_display},
+	{ "gdk_event_send_clientmessage_toall",  cast(void**)& gdk_event_send_clientmessage_toall},
+	{ "gdk_add_client_message_filter",  cast(void**)& gdk_add_client_message_filter},
+	{ "gdk_get_show_events",  cast(void**)& gdk_get_show_events},
+	{ "gdk_set_show_events",  cast(void**)& gdk_set_show_events},
+	{ "gdk_event_set_screen",  cast(void**)& gdk_event_set_screen},
+	{ "gdk_event_get_screen",  cast(void**)& gdk_event_get_screen},
+	{ "gdk_setting_get",  cast(void**)& gdk_setting_get},
+	{ "gdk_keymap_get_default",  cast(void**)& gdk_keymap_get_default},
+	{ "gdk_keymap_get_for_display",  cast(void**)& gdk_keymap_get_for_display},
+	{ "gdk_keymap_lookup_key",  cast(void**)& gdk_keymap_lookup_key},
+	{ "gdk_keymap_translate_keyboard_state",  cast(void**)& gdk_keymap_translate_keyboard_state},
+	{ "gdk_keymap_get_entries_for_keyval",  cast(void**)& gdk_keymap_get_entries_for_keyval},
+	{ "gdk_keymap_get_entries_for_keycode",  cast(void**)& gdk_keymap_get_entries_for_keycode},
+	{ "gdk_keymap_get_direction",  cast(void**)& gdk_keymap_get_direction},
+	{ "gdk_keymap_have_bidi_layouts",  cast(void**)& gdk_keymap_have_bidi_layouts},
+	{ "gdk_keyval_name",  cast(void**)& gdk_keyval_name},
+	{ "gdk_keyval_from_name",  cast(void**)& gdk_keyval_from_name},
+	{ "gdk_keyval_convert_case",  cast(void**)& gdk_keyval_convert_case},
+	{ "gdk_keyval_to_upper",  cast(void**)& gdk_keyval_to_upper},
+	{ "gdk_keyval_to_lower",  cast(void**)& gdk_keyval_to_lower},
+	{ "gdk_keyval_is_upper",  cast(void**)& gdk_keyval_is_upper},
+	{ "gdk_keyval_is_lower",  cast(void**)& gdk_keyval_is_lower},
+	{ "gdk_keyval_to_unicode",  cast(void**)& gdk_keyval_to_unicode},
+	{ "gdk_unicode_to_keyval",  cast(void**)& gdk_unicode_to_keyval},
+	{ "gdk_selection_owner_set",  cast(void**)& gdk_selection_owner_set},
+	{ "gdk_selection_owner_set_for_display",  cast(void**)& gdk_selection_owner_set_for_display},
+	{ "gdk_selection_owner_get",  cast(void**)& gdk_selection_owner_get},
+	{ "gdk_selection_owner_get_for_display",  cast(void**)& gdk_selection_owner_get_for_display},
+	{ "gdk_selection_convert",  cast(void**)& gdk_selection_convert},
+	{ "gdk_selection_property_get",  cast(void**)& gdk_selection_property_get},
+	{ "gdk_selection_send_notify",  cast(void**)& gdk_selection_send_notify},
+	{ "gdk_selection_send_notify_for_display",  cast(void**)& gdk_selection_send_notify_for_display},
+	{ "gdk_drag_get_selection",  cast(void**)& gdk_drag_get_selection},
+	{ "gdk_drag_abort",  cast(void**)& gdk_drag_abort},
+	{ "gdk_drop_reply",  cast(void**)& gdk_drop_reply},
+	{ "gdk_drag_context_new",  cast(void**)& gdk_drag_context_new},
+	{ "gdk_drag_drop",  cast(void**)& gdk_drag_drop},
+	{ "gdk_drag_find_window",  cast(void**)& gdk_drag_find_window},
+	{ "gdk_drag_find_window_for_screen",  cast(void**)& gdk_drag_find_window_for_screen},
+	{ "gdk_drag_context_ref",  cast(void**)& gdk_drag_context_ref},
+	{ "gdk_drag_begin",  cast(void**)& gdk_drag_begin},
+	{ "gdk_drag_motion",  cast(void**)& gdk_drag_motion},
+	{ "gdk_drop_finish",  cast(void**)& gdk_drop_finish},
+	{ "gdk_drag_get_protocol",  cast(void**)& gdk_drag_get_protocol},
+	{ "gdk_drag_get_protocol_for_display",  cast(void**)& gdk_drag_get_protocol_for_display},
+	{ "gdk_drag_context_unref",  cast(void**)& gdk_drag_context_unref},
+	{ "gdk_drag_status",  cast(void**)& gdk_drag_status},
+	{ "gdk_drag_drop_succeeded",  cast(void**)& gdk_drag_drop_succeeded},
+	{ "gdk_threads_init",  cast(void**)& gdk_threads_init},
+	{ "gdk_threads_enter",  cast(void**)& gdk_threads_enter},
+	{ "gdk_threads_leave",  cast(void**)& gdk_threads_leave},
+	{ "gdk_threads_set_lock_functions",  cast(void**)& gdk_threads_set_lock_functions},
+	{ "gdk_threads_add_idle",  cast(void**)& gdk_threads_add_idle},
+	{ "gdk_threads_add_idle_full",  cast(void**)& gdk_threads_add_idle_full},
+	{ "gdk_threads_add_timeout",  cast(void**)& gdk_threads_add_timeout},
+	{ "gdk_threads_add_timeout_full",  cast(void**)& gdk_threads_add_timeout_full},
+	{ "gdk_input_add_full",  cast(void**)& gdk_input_add_full},
+	{ "gdk_input_add",  cast(void**)& gdk_input_add},
+	{ "gdk_input_remove",  cast(void**)& gdk_input_remove},
+	{ "gdk_devices_list",  cast(void**)& gdk_devices_list},
+	{ "gdk_device_set_source",  cast(void**)& gdk_device_set_source},
+	{ "gdk_device_set_mode",  cast(void**)& gdk_device_set_mode},
+	{ "gdk_device_set_key",  cast(void**)& gdk_device_set_key},
+	{ "gdk_device_set_axis_use",  cast(void**)& gdk_device_set_axis_use},
+	{ "gdk_device_get_core_pointer",  cast(void**)& gdk_device_get_core_pointer},
+	{ "gdk_device_get_state",  cast(void**)& gdk_device_get_state},
+	{ "gdk_device_get_history",  cast(void**)& gdk_device_get_history},
+	{ "gdk_device_free_history",  cast(void**)& gdk_device_free_history},
+	{ "gdk_device_get_axis",  cast(void**)& gdk_device_get_axis},
+	{ "gdk_input_set_extension_events",  cast(void**)& gdk_input_set_extension_events},
+        /+ Manually disabled. Won't compile, yet.
+	{ "gdkx_visual_get",  cast(void**)& gdkx_visual_get},
+	{ "gdkx_colormap_get",  cast(void**)& gdkx_colormap_get},
+	{ "gdk_pixmap_foreign_new",  cast(void**)& gdk_pixmap_foreign_new},
+	{ "gdk_pixmap_foreign_new_for_display",  cast(void**)& gdk_pixmap_foreign_new_for_display},
+	{ "gdk_pixmap_foreign_new_for_screen",  cast(void**)& gdk_pixmap_foreign_new_for_screen},
+	{ "gdk_window_foreign_new",  cast(void**)& gdk_window_foreign_new},
+	{ "gdk_window_foreign_new_for_display",  cast(void**)& gdk_window_foreign_new_for_display},
+	{ "gdk_xid_table_lookup",  cast(void**)& gdk_xid_table_lookup},
+	{ "gdk_xid_table_lookup_for_display",  cast(void**)& gdk_xid_table_lookup_for_display},
+	{ "gdk_window_lookup",  cast(void**)& gdk_window_lookup},
+	{ "gdk_window_lookup_for_display",  cast(void**)& gdk_window_lookup_for_display},
+	{ "gdk_pixmap_lookup",  cast(void**)& gdk_pixmap_lookup},
+	{ "gdk_pixmap_lookup_for_display",  cast(void**)& gdk_pixmap_lookup_for_display},
+	{ "gdk_x11_lookup_xdisplay",  cast(void**)& gdk_x11_lookup_xdisplay},
+	{ "gdk_x11_get_server_time",  cast(void**)& gdk_x11_get_server_time},
+	{ "gdk_net_wm_supports",  cast(void**)& gdk_net_wm_supports},
+	{ "gdk_x11_screen_supports_net_wm_hint",  cast(void**)& gdk_x11_screen_supports_net_wm_hint},
+	{ "gdk_x11_screen_get_window_manager_name",  cast(void**)& gdk_x11_screen_get_window_manager_name},
+	{ "gdk_x11_screen_lookup_visual",  cast(void**)& gdk_x11_screen_lookup_visual},
+	{ "gdk_x11_window_set_user_time",  cast(void**)& gdk_x11_window_set_user_time},
+	{ "gdk_x11_window_move_to_current_desktop",  cast(void**)& gdk_x11_window_move_to_current_desktop},
+	{ "gdk_x11_display_get_user_time",  cast(void**)& gdk_x11_display_get_user_time},
+	{ "gdk_x11_colormap_foreign_new",  cast(void**)& gdk_x11_colormap_foreign_new},
+	{ "gdk_x11_colormap_get_xcolormap",  cast(void**)& gdk_x11_colormap_get_xcolormap},
+	{ "gdk_x11_colormap_get_xdisplay",  cast(void**)& gdk_x11_colormap_get_xdisplay},
+	{ "gdk_x11_cursor_get_xcursor",  cast(void**)& gdk_x11_cursor_get_xcursor},
+	{ "gdk_x11_cursor_get_xdisplay",  cast(void**)& gdk_x11_cursor_get_xdisplay},
+	{ "gdk_x11_display_broadcast_startup_message",  cast(void**)& gdk_x11_display_broadcast_startup_message},
+	{ "gdk_x11_display_get_startup_notification_id",  cast(void**)& gdk_x11_display_get_startup_notification_id},
+	{ "gdk_x11_display_get_xdisplay",  cast(void**)& gdk_x11_display_get_xdisplay},
+	{ "gdk_x11_display_grab",  cast(void**)& gdk_x11_display_grab},
+	{ "gdk_x11_display_ungrab",  cast(void**)& gdk_x11_display_ungrab},
+	{ "gdk_x11_display_set_cursor_theme",  cast(void**)& gdk_x11_display_set_cursor_theme},
+	{ "gdk_x11_register_standard_event_type",  cast(void**)& gdk_x11_register_standard_event_type},
+	{ "gdk_x11_drawable_get_xdisplay",  cast(void**)& gdk_x11_drawable_get_xdisplay},
+        +/
+	{ "gdk_x11_drawable_get_xid",  cast(void**)& gdk_x11_drawable_get_xid},
+        /+
+	{ "gdk_x11_font_get_name",  cast(void**)& gdk_x11_font_get_name},
+	{ "gdk_x11_font_get_xdisplay",  cast(void**)& gdk_x11_font_get_xdisplay},
+	{ "gdk_x11_font_get_xfont",  cast(void**)& gdk_x11_font_get_xfont},
+	{ "gdk_x11_gc_get_xdisplay",  cast(void**)& gdk_x11_gc_get_xdisplay},
+	{ "gdk_x11_gc_get_xgc",  cast(void**)& gdk_x11_gc_get_xgc},
+	{ "gdk_x11_get_default_root_xwindow",  cast(void**)& gdk_x11_get_default_root_xwindow},
+	{ "gdk_x11_get_default_screen",  cast(void**)& gdk_x11_get_default_screen},
+	{ "gdk_x11_get_default_xdisplay",  cast(void**)& gdk_x11_get_default_xdisplay},
+	{ "gdk_x11_grab_server",  cast(void**)& gdk_x11_grab_server},
+	{ "gdk_x11_image_get_xdisplay",  cast(void**)& gdk_x11_image_get_xdisplay},
+	{ "gdk_x11_image_get_ximage",  cast(void**)& gdk_x11_image_get_ximage},
+	{ "gdk_x11_screen_get_screen_number",  cast(void**)& gdk_x11_screen_get_screen_number},
+	{ "gdk_x11_screen_get_xscreen",  cast(void**)& gdk_x11_screen_get_xscreen},
+	{ "gdk_x11_ungrab_server",  cast(void**)& gdk_x11_ungrab_server},
+	{ "gdk_x11_visual_get_xvisual",  cast(void**)& gdk_x11_visual_get_xvisual},
+	{ "gdk_x11_atom_to_xatom",  cast(void**)& gdk_x11_atom_to_xatom},
+	{ "gdk_x11_atom_to_xatom_for_display",  cast(void**)& gdk_x11_atom_to_xatom_for_display},
+	{ "gdk_x11_xatom_to_atom",  cast(void**)& gdk_x11_xatom_to_atom},
+	{ "gdk_x11_xatom_to_atom_for_display",  cast(void**)& gdk_x11_xatom_to_atom_for_display},
+	{ "gdk_x11_get_xatom_by_name",  cast(void**)& gdk_x11_get_xatom_by_name},
+	{ "gdk_x11_get_xatom_by_name_for_display",  cast(void**)& gdk_x11_get_xatom_by_name_for_display},
+	{ "gdk_x11_get_xatom_name",  cast(void**)& gdk_x11_get_xatom_name},
+	{ "gdk_x11_get_xatom_name_for_display",  cast(void**)& gdk_x11_get_xatom_name_for_display},
+        +/
+	{ "gdk_cairo_create",  cast(void**)& gdk_cairo_create},
+	{ "gdk_cairo_set_source_color",  cast(void**)& gdk_cairo_set_source_color},
+	{ "gdk_cairo_set_source_pixbuf",  cast(void**)& gdk_cairo_set_source_pixbuf},
+	{ "gdk_cairo_set_source_pixmap",  cast(void**)& gdk_cairo_set_source_pixmap},
+	{ "gdk_cairo_rectangle",  cast(void**)& gdk_cairo_rectangle},
+	{ "gdk_cairo_region",  cast(void**)& gdk_cairo_region},
+
+];

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/gdkpixbuf.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,158 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.gdkpixbuf;
+
+private import dwt.internal.gtk.c.gdkpixbuftypes;
+private import dwt.internal.gtk.runtime.Loader;
+
+/******************************************************************************
+
+******************************************************************************/
+
+private Linker gdkpixbufLinker;
+
+/******************************************************************************
+
+******************************************************************************/
+
+static this()
+{
+    gdkpixbufLinker = new Linker( getLibraryPath ~ importLibs[LIBRARY.GDKPIXBUF] );
+    gdkpixbufLinker.link( gdkpixbufLinks );
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+static ~this()
+{
+    delete gdkpixbufLinker;
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+extern(C) 
+{	
+	// gdkpixbuf.Pixdata
+	
+	gpointer function(GdkPixdata* pixdata, GdkPixbuf* pixbuf, gboolean useRle)gdk_pixdata_from_pixbuf;
+	GdkPixbuf* function(GdkPixdata* pixdata, gboolean copyPixels, GError** error)gdk_pixbuf_from_pixdata;
+	guint8* function(GdkPixdata* pixdata, guint* streamLengthP)gdk_pixdata_serialize;
+	gboolean function(GdkPixdata* pixdata, guint streamLength, guint8* stream, GError** error)gdk_pixdata_deserialize;
+	GString* function(GdkPixdata* pixdata, gchar* name, GdkPixdataDumpType dumpType)gdk_pixdata_to_csource;
+	
+	// gdkpixbuf.PixbufAnimation
+	
+	GdkPixbufAnimation* function(char* filename, GError** error)gdk_pixbuf_animation_new_from_file;
+	GdkPixbufAnimation* function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_ref;
+	void function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_unref;
+	int function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_get_width;
+	int function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_get_height;
+	GdkPixbufAnimationIter* function(GdkPixbufAnimation* animation, GTimeVal* startTime)gdk_pixbuf_animation_get_iter;
+	gboolean function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_is_static_image;
+	GdkPixbuf* function(GdkPixbufAnimation* animation)gdk_pixbuf_animation_get_static_image;
+	gboolean function(GdkPixbufAnimationIter* iter, GTimeVal* currentTime)gdk_pixbuf_animation_iter_advance;
+	int function(GdkPixbufAnimationIter* iter)gdk_pixbuf_animation_iter_get_delay_time;
+	gboolean function(GdkPixbufAnimationIter* iter)gdk_pixbuf_animation_iter_on_currently_loading_frame;
+	GdkPixbuf* function(GdkPixbufAnimationIter* iter)gdk_pixbuf_animation_iter_get_pixbuf;
+	GdkPixbufSimpleAnim* function(gint width, gint height, gfloat rate)gdk_pixbuf_simple_anim_new;
+	void function(GdkPixbufSimpleAnim* animation, GdkPixbuf* pixbuf)gdk_pixbuf_simple_anim_add_frame;
+	
+	// gdkpixbuf.PixbufLoader
+	
+	GdkPixbufLoader* function()gdk_pixbuf_loader_new;
+	GdkPixbufLoader* function(char* imageType, GError** error)gdk_pixbuf_loader_new_with_type;
+	GdkPixbufLoader* function(char* mimeType, GError** error)gdk_pixbuf_loader_new_with_mime_type;
+	GdkPixbufFormat* function(GdkPixbufLoader* loader)gdk_pixbuf_loader_get_format;
+	gboolean function(GdkPixbufLoader* loader, guchar* buf, gsize count, GError** error)gdk_pixbuf_loader_write;
+	void function(GdkPixbufLoader* loader, int width, int height)gdk_pixbuf_loader_set_size;
+	GdkPixbuf* function(GdkPixbufLoader* loader)gdk_pixbuf_loader_get_pixbuf;
+	GdkPixbufAnimation* function(GdkPixbufLoader* loader)gdk_pixbuf_loader_get_animation;
+	gboolean function(GdkPixbufLoader* loader, GError** error)gdk_pixbuf_loader_close;
+	
+	// gdkpixbuf.PixbufFormat
+	
+	gboolean function(GdkPixbuf* pixbuf, gchar* key, gchar* value)gdk_pixbuf_set_option;
+	GSList* function()gdk_pixbuf_get_formats;
+	gchar* function(GdkPixbufFormat* format)gdk_pixbuf_format_get_name;
+	gchar* function(GdkPixbufFormat* format)gdk_pixbuf_format_get_description;
+	gchar** function(GdkPixbufFormat* format)gdk_pixbuf_format_get_mime_types;
+	gchar** function(GdkPixbufFormat* format)gdk_pixbuf_format_get_extensions;
+	gboolean function(GdkPixbufFormat* format)gdk_pixbuf_format_is_writable;
+	gboolean function(GdkPixbufFormat* format)gdk_pixbuf_format_is_scalable;
+	gboolean function(GdkPixbufFormat* format)gdk_pixbuf_format_is_disabled;
+	void function(GdkPixbufFormat* format, gboolean disabled)gdk_pixbuf_format_set_disabled;
+	gchar* function(GdkPixbufFormat* format)gdk_pixbuf_format_get_license;
+	GdkPixbufFormat* function(gchar* filename, gint* width, gint* height)gdk_pixbuf_get_file_info;
+}
+
+/******************************************************************************
+
+******************************************************************************/
+
+Symbol[] gdkpixbufLinks = 
+[
+
+	{ "gdk_pixdata_from_pixbuf",  cast(void**)& gdk_pixdata_from_pixbuf},
+	{ "gdk_pixbuf_from_pixdata",  cast(void**)& gdk_pixbuf_from_pixdata},
+	{ "gdk_pixdata_serialize",  cast(void**)& gdk_pixdata_serialize},
+	{ "gdk_pixdata_deserialize",  cast(void**)& gdk_pixdata_deserialize},
+	{ "gdk_pixdata_to_csource",  cast(void**)& gdk_pixdata_to_csource},
+	{ "gdk_pixbuf_animation_new_from_file",  cast(void**)& gdk_pixbuf_animation_new_from_file},
+	{ "gdk_pixbuf_animation_ref",  cast(void**)& gdk_pixbuf_animation_ref},
+	{ "gdk_pixbuf_animation_unref",  cast(void**)& gdk_pixbuf_animation_unref},
+	{ "gdk_pixbuf_animation_get_width",  cast(void**)& gdk_pixbuf_animation_get_width},
+	{ "gdk_pixbuf_animation_get_height",  cast(void**)& gdk_pixbuf_animation_get_height},
+	{ "gdk_pixbuf_animation_get_iter",  cast(void**)& gdk_pixbuf_animation_get_iter},
+	{ "gdk_pixbuf_animation_is_static_image",  cast(void**)& gdk_pixbuf_animation_is_static_image},
+	{ "gdk_pixbuf_animation_get_static_image",  cast(void**)& gdk_pixbuf_animation_get_static_image},
+	{ "gdk_pixbuf_animation_iter_advance",  cast(void**)& gdk_pixbuf_animation_iter_advance},
+	{ "gdk_pixbuf_animation_iter_get_delay_time",  cast(void**)& gdk_pixbuf_animation_iter_get_delay_time},
+	{ "gdk_pixbuf_animation_iter_on_currently_loading_frame",  cast(void**)& gdk_pixbuf_animation_iter_on_currently_loading_frame},
+	{ "gdk_pixbuf_animation_iter_get_pixbuf",  cast(void**)& gdk_pixbuf_animation_iter_get_pixbuf},
+	{ "gdk_pixbuf_simple_anim_new",  cast(void**)& gdk_pixbuf_simple_anim_new},
+	{ "gdk_pixbuf_simple_anim_add_frame",  cast(void**)& gdk_pixbuf_simple_anim_add_frame},
+	{ "gdk_pixbuf_loader_new",  cast(void**)& gdk_pixbuf_loader_new},
+	{ "gdk_pixbuf_loader_new_with_type",  cast(void**)& gdk_pixbuf_loader_new_with_type},
+	{ "gdk_pixbuf_loader_new_with_mime_type",  cast(void**)& gdk_pixbuf_loader_new_with_mime_type},
+	{ "gdk_pixbuf_loader_get_format",  cast(void**)& gdk_pixbuf_loader_get_format},
+	{ "gdk_pixbuf_loader_write",  cast(void**)& gdk_pixbuf_loader_write},
+	{ "gdk_pixbuf_loader_set_size",  cast(void**)& gdk_pixbuf_loader_set_size},
+	{ "gdk_pixbuf_loader_get_pixbuf",  cast(void**)& gdk_pixbuf_loader_get_pixbuf},
+	{ "gdk_pixbuf_loader_get_animation",  cast(void**)& gdk_pixbuf_loader_get_animation},
+	{ "gdk_pixbuf_loader_close",  cast(void**)& gdk_pixbuf_loader_close},
+	{ "gdk_pixbuf_set_option",  cast(void**)& gdk_pixbuf_set_option},
+	{ "gdk_pixbuf_get_formats",  cast(void**)& gdk_pixbuf_get_formats},
+	{ "gdk_pixbuf_format_get_name",  cast(void**)& gdk_pixbuf_format_get_name},
+	{ "gdk_pixbuf_format_get_description",  cast(void**)& gdk_pixbuf_format_get_description},
+	{ "gdk_pixbuf_format_get_mime_types",  cast(void**)& gdk_pixbuf_format_get_mime_types},
+	{ "gdk_pixbuf_format_get_extensions",  cast(void**)& gdk_pixbuf_format_get_extensions},
+	{ "gdk_pixbuf_format_is_writable",  cast(void**)& gdk_pixbuf_format_is_writable},
+	{ "gdk_pixbuf_format_is_scalable",  cast(void**)& gdk_pixbuf_format_is_scalable},
+	{ "gdk_pixbuf_format_is_disabled",  cast(void**)& gdk_pixbuf_format_is_disabled},
+	{ "gdk_pixbuf_format_set_disabled",  cast(void**)& gdk_pixbuf_format_set_disabled},
+	{ "gdk_pixbuf_format_get_license",  cast(void**)& gdk_pixbuf_format_get_license},
+	{ "gdk_pixbuf_get_file_info",  cast(void**)& gdk_pixbuf_get_file_info},
+
+];

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dwt/internal/gtk/c/gdkpixbuftypes.d	Sat Jan 05 15:13:44 2008 -0800
@@ -0,0 +1,443 @@
+/******************************************************************************
+
+    This file is part of gtkD.
+
+    gtkD is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2.1 of the License, or
+    (at your option) any later version.
+ 
+    gtkD is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with gtkD; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+******************************************************************************/
+
+module dwt.internal.gtk.c.gdkpixbuftypes;
+
+public import dwt.internal.gtk.c.glibtypes;
+public import dwt.internal.gtk.c.gobjecttypes;
+public import dwt.internal.gtk.c.gdktypes;
+
+/******************************************************************************
+
+******************************************************************************/
+
+public alias void* AtkFocusHandler;
+public struct AtkStateSet;
+public struct AtkRectangle;
+
+/**
+ * An enumeration containing three sets of flags for a GdkPixdata struct:
+ * one for the used colorspace, one for the width of the samples and one
+ * for the encoding of the pixel data.
+ * GDK_PIXDATA_COLOR_TYPE_RGB
+ */
+public enum GdkPixdataType
+{
+	/+* colorspace + alpha +/
+	GDK_PIXDATA_COLOR_TYPE_RGB = 0x01,
+	GDK_PIXDATA_COLOR_TYPE_RGBA = 0x02,
+	GDK_PIXDATA_COLOR_TYPE_MASK = 0xff,
+	/+* width, support 8bits only currently +/
+	GDK_PIXDATA_SAMPLE_WIDTH_8 = 0x01 << 16,
+	GDK_PIXDATA_SAMPLE_WIDTH_MASK = 0x0f << 16,
+	/+* encoding +/
+	GDK_PIXDATA_ENCODING_RAW = 0x01 << 24,
+	GDK_PIXDATA_ENCODING_RLE = 0x02 << 24,
+	GDK_PIXDATA_ENCODING_MASK = 0x0f << 24
+}
+alias GdkPixdataType PixdataType;
+
+/**
+ * An enumeration which is used by gdk_pixdata_to_csource() to
+ * determine the form of C source to be generated. The three values
+ * GDK_PIXDATA_DUMP_PIXDATA_STREAM, GDK_PIXDATA_DUMP_PIXDATA_STRUCT
+ * and GDK_PIXDATA_DUMP_MACROS are mutually exclusive, as are
+ * GDK_PIXBUF_DUMP_GTYPES and GDK_PIXBUF_DUMP_CTYPES. The remaining
+ * elements are optional flags that can be freely added.
+ * GDK_PIXDATA_DUMP_PIXDATA_STREAM
+ */
+public enum GdkPixdataDumpType
+{
+	/+* type of source to save +/
+	GDK_PIXDATA_DUMP_PIXDATA_STREAM = 0,
+	GDK_PIXDATA_DUMP_PIXDATA_STRUCT = 1,
+	GDK_PIXDATA_DUMP_MACROS = 2,
+	/+* type of variables to use +/
+	GDK_PIXDATA_DUMP_GTYPES = 0,
+	GDK_PIXDATA_DUMP_CTYPES = 1 << 8,
+	GDK_PIXDATA_DUMP_STATIC = 1 << 9,
+	GDK_PIXDATA_DUMP_CONST = 1 << 10,
+	/+* save RLE decoder macro? +/
+	GDK_PIXDATA_DUMP_RLE_DECODER = 1 << 16
+}
+alias GdkPixdataDumpType PixdataDumpType;
+
+/**
+ * Flags which allow a module to specify further details about the supported
+ * operations.
+ * Since 2.2
+ */
+public enum GdkPixbufFormatFlags
+{
+	WRITABLE = 1 << 0,
+	SCALABLE = 1 << 1,
+	THREADSAFE = 1 << 2
+}
+alias GdkPixbufFormatFlags PixbufFormatFlags;
+
+
+/**
+ * Main Gtk struct.
+ * A GdkPixdata contains pixbuf information in a form suitable for
+ * serialization and streaming.
+ * guint32magic;
+ */
+public struct GdkPixdata{}
+// uint magic; /+* GDK_PIXBUF_MAGIC_NUMBER +/
+// gdk-pixbuf-inline.html
+// int length; /+* <1 to disable length checks, otherwise:
+// gdk-pixbuf-inline.html
+// * GDK_PIXDATA_HEADER_LENGTH + pixelData length
+// gdk-pixbuf-inline.html
+// +/
+// gdk-pixbuf-inline.html
+// uint pixdataType; /+* GdkPixdataType +/
+// gdk-pixbuf-inline.html
+// uint rowstride;
+// gdk-pixbuf-inline.html
+// uint width;
+// gdk-pixbuf-inline.html
+// uint height;
+// gdk-pixbuf-inline.html
+// byte *pixelData;
+// gdk-pixbuf-inline.html
+
+
+/**
+ * Main Gtk struct.
+ * And opaque struct representing an animation.
+ */
+public struct GdkPixbufAnimation{}
+
+
+/**
+ * And opaque struct representing an iterator which points to a
+ * certain position in an animation.
+ */
+public struct GdkPixbufAnimationIter{}
+
+
+/**
+ * An
+ */
+public struct GdkPixbufSimpleAnim{}
+
+
+/**
+ * Main Gtk struct.
+ * The GdkPixbufLoader struct contains only private
+ * fields.
+ */
+public struct GdkPixbufLoader{}
+
+
+/**
+ * Main Gtk struct.
+ * A GdkPixbufFormat contains information about the image format accepted by a
+ * module. Only modules should access the fields directly, applications should
+ * use the gdk_pixbuf_format_* functions.
+ * gchar*name;
+ * the name of the image format.
+ * GdkPixbufModulePattern*signature;
+ * the signature of the module.
+ * gchar*domain;
+ * the message domain for the description.
+ * gchar*description;
+ * a description of the image format.
+ * gchar**mime_types;
+ * a NULL-terminated array of MIME types for the image format.
+ * gchar**extensions;
+ * a NULL-terminated array of typical filename extensions for the
+ * image format.
+ * guint32flags;
+ * a combination of GdkPixbufFormatFlags.
+ * gbooleandisabled;
+ * a boolean determining whether the loader is disabled.
+ * gchar*license;
+ * a string containing license information, typically set to
+ */
+public struct GdkPixbufFormat{}
+// char *name;
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufModulePattern *signature;
+// gdk-pixbuf-Module-Interface.html
+// char *domain;
+// gdk-pixbuf-Module-Interface.html
+// char *description;
+// gdk-pixbuf-Module-Interface.html
+// char **mimeTypes;
+// gdk-pixbuf-Module-Interface.html
+// char **extensions;
+// gdk-pixbuf-Module-Interface.html
+// uint flags;
+// gdk-pixbuf-Module-Interface.html
+// int disabled;
+// gdk-pixbuf-Module-Interface.html
+// char *license;
+// gdk-pixbuf-Module-Interface.html
+
+
+/**
+ * The signature of a module is a set of prefixes. Prefixes are encoded as
+ * pairs of ordinary strings, where the second string, called the mask, if
+ * not NULL, must be of the same length as the first one and may contain
+ * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched,
+ * not matched, "don't-care"-bytes, zeros and non-zeros.
+ * Each prefix has an associated integer that describes the relevance of
+ * the prefix, with 0 meaning a mismatch and 100 a "perfect match".
+ * Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*',
+ * indicating an unanchored pattern that matches not only at the beginning,
+ * but also in the middle. Versions prior to 2.8 will interpret the '*'
+ * like an 'x'.
+ * The signature of a module is stored as an array of
+ * GdkPixbufModulePatterns. The array is terminated by a pattern
+ * where the prefix is NULL.
+ * GdkPixbufModulePattern *signature[] = {
+	 */
+public struct GdkPixbufModulePattern{}
+// char *prefix;
+// gdk-pixbuf-Module-Interface.html
+// char *mask;
+// gdk-pixbuf-Module-Interface.html
+// int relevance;
+// gdk-pixbuf-Module-Interface.html
+
+
+/**
+ * A GdkPixbufModule contains the necessary functions to load and save
+ * images in a certain file format.
+ * A GdkPixbufModule can be loaded dynamically from a GModule.
+ * Each loadable module must contain a GdkPixbufModuleFillVtableFunc function
+ * named fill_vtable, which will get called when the module
+ * is loaded and must set the function pointers of the GdkPixbufModule.
+ * char*module_name;
+ * the name of the module, usually the same as the
+ */
+public struct GdkPixbufModule{}
+// char *moduleName;
+// gdk-pixbuf-Module-Interface.html
+// char *modulePath;
+// gdk-pixbuf-Module-Interface.html
+// GModule *modul;
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufFormat *info;
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf *(* load) (FILE *f,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf *(* loadXpmData) ( char **data);
+// gdk-pixbuf-Module-Interface.html
+// /+* Incremental loading +/
+// gdk-pixbuf-Module-Interface.html
+// void* (* beginLoad) (GdkPixbufModuleSizeFunc sizeFunc,
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufModulePreparedFunc prepareFunc,
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufModuleUpdatedFunc updateFunc,
+// gdk-pixbuf-Module-Interface.html
+// void* userData,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// int (* stopLoad) (void* context,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// int (* loadIncrement) (void* context,
+// gdk-pixbuf-Module-Interface.html
+// char *buf,
+// gdk-pixbuf-Module-Interface.html
+// uint size,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// /+* Animation loading +/
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufAnimation *(* loadAnimation) (FILE *f,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// /+* Saving +/
+// gdk-pixbuf-Module-Interface.html
+// int (* save) (FILE *f,
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf *pixbuf,
+// gdk-pixbuf-Module-Interface.html
+// char **paramKeys,
+// gdk-pixbuf-Module-Interface.html
+// char **paramValues,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+// int (*saveToCallback) (GdkPixbufSaveFunc saveFunc,
+// gdk-pixbuf-Module-Interface.html
+// void* userData,
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf *pixbuf,
+// gdk-pixbuf-Module-Interface.html
+// char **optionKeys,
+// gdk-pixbuf-Module-Interface.html
+// char **optionValues,
+// gdk-pixbuf-Module-Interface.html
+// GError **error);
+// gdk-pixbuf-Module-Interface.html
+
+
+/**
+ * Modules supporting animations must derive a type from
+ * GdkPixbufAnimation, providing suitable implementations of the
+ * virtual functions.
+ * GObjectClassparent_class;
+ * the parent class
+ * is_static_image()
+ * returns whether the given animation is just a static image.
+ * get_static_image()
+ * returns a static image representing the given animation.
+ * get_size()
+ * fills width and height with the frame size of the animation.
+ * get_iter()
+ * returns an iterator for the given animation.
+ */
+public struct GdkPixbufAnimationClass{}
+// GObjectClass parentClass;
+// gdk-pixbuf-Module-Interface.html
+// int (*isStaticImage) (GdkPixbufAnimation *anim);
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf* (*getStaticImage) (GdkPixbufAnimation *anim);
+// gdk-pixbuf-Module-Interface.html
+// void (*getSize) (GdkPixbufAnimation *anim,
+// gdk-pixbuf-Module-Interface.html
+// int *width,
+// gdk-pixbuf-Module-Interface.html
+// int *height);
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbufAnimationIter* (*getIter) (GdkPixbufAnimation *anim,
+// gdk-pixbuf-Module-Interface.html
+// GTimeVal *startTime);
+// gdk-pixbuf-Module-Interface.html
+
+
+/**
+ * Modules supporting animations must derive a type from
+ * GdkPixbufAnimationIter, providing suitable implementations of the
+ * virtual functions.
+ * GObjectClassparent_class;
+ * the parent class
+ * get_delay_time()
+ * returns the time in milliseconds that the current frame
+ */
+public struct GdkPixbufAnimationIterClass{}
+// GObjectClass parentClass;
+// gdk-pixbuf-Module-Interface.html
+// int (*getDelayTime) (GdkPixbufAnimationIter *iter);
+// gdk-pixbuf-Module-Interface.html
+// GdkPixbuf* (*getPixbuf) (GdkPixbufAnimationIter *iter);
+// gdk-pixbuf-Module-Interface.html
+// int (*onCurrentlyLoadingFrame) (GdkPixbufAnimationIter *iter);
+// gdk-pixbuf-Module-Interface.html
+// int (*advance) (GdkPixbufAnimationIter *iter,
+// gdk-pixbuf-Module-Interface.html
+// GTimeVal *currentTime);
+// gdk-pixbuf-Module-Interface.html
+
+
+/*
+ * Defines the type of the function used to set the vtable of a
+ * GdkPixbufModule when it is loaded.
+ * module:
+ * a GdkPixbufModule.
+ * Since 2.2
+ */
+// void (*GdkPixbufModuleFillVtableFunc) (GdkPixbufModule *module);
+public typedef extern(C) void  function (GdkPixbufModule*) GdkPixbufModuleFillVtableFunc;
+
+/*
+ * Defines the type of the function used to fill a
+ * GdkPixbufFormat structure with information about a module.
+ * info:
+ * a GdkPixbufFormat.
+ * Since 2.2
+ */
+// void (*GdkPixbufModuleFillInfoFunc) (GdkPixbufFormat *info);
+public typedef extern(C) void  function (GdkPixbufFormat*) GdkPixbufModuleFillInfoFunc;
+
+/*
+ * Defines the type of the function that gets called once the size
+ * of the loaded image is known.
+ * The function is expected to set width and height to the desired
+ * size to which the image should be scaled. If a module has no efficient
+ * way to achieve the desired scaling during the loading of the image, it may
+ * either ignore the size request, or only approximate it -- gdk-pixbuf will
+ * then perform the required scaling on the completely loaded image.
+ * If the function sets width or height to zero, the module should interpret
+ * this as a hint that it will be closed soon and shouldn't allocate further
+ * resources. This convention is used to implement gdk_pixbuf_get_file_info()
+ * efficiently.
+ * width:
+ * pointer to a location containing the current image width
+ * height:
+ * pointer to a location containing the current image height
+ * user_data:
+ * the loader.
+ * Since 2.2
+ */
+// void (*GdkPixbufModuleSizeFunc) (gint *width,  gint *height,  gpointer user_data);
+public typedef extern(C) void  function (gint*, gint*, void*) GdkPixbufModuleSizeFunc;
+
+/*
+ * Defines the type of the function that gets called once the initial
+ * setup of pixbuf is done.
+ * GdkPixbufLoader uses a function of this type to emit the
+ * "area_prepared"
+ * signal.
+ * pixbuf:
+ * the GdkPixbuf that is currently being loaded.
+ * anim:
+ * if an animation is being loaded, the GdkPixbufAnimation, else NULL.
+ * user_data:
+ * the loader.
+ * Since 2.2
+ */
+// void (*GdkPixbufModulePreparedFunc) (GdkPixbuf *pixbuf,  GdkPixbufAnimation *anim,  gpointer user_data);
+public typedef extern(C) void  function (GdkPixbuf*, GdkPixbufAnimation*, void*) GdkPixbufModulePreparedFunc;
+
+/*
+ * Defines the type of the function that gets called every time a region
+ * of pixbuf is updated.
+ * GdkPixbufLoader uses a function of this type to emit the
+ * "area_updated"
+ * signal.
+ * pixbuf:
+ * the GdkPixbuf that is currently being loaded.
+ * x:
+ * the X origin of the updated area.
+ * y:
+ * the Y origin of the updated area.
+ * width:
+ * the width of the updated area.
+ * height:
+ * the height of the updated area.
+ * user_data:
+ * the loader.
+ * Since 2.2
+ */
+// void (*GdkPixbufModuleUpdatedFunc) (GdkPixbuf *pixbuf,  int x,  int y,  int width,  int height,  gpointer user_data);
+public typedef extern(C) void  function (GdkPixbuf*, int, int, int, int, void*) GdkPixbufModuleUpdatedFunc;