From: Jürg Billeter Date: Fri, 18 Aug 2006 08:49:06 +0000 (+0000) Subject: support base types for structs obey set keyword add SignalInvocationHint, X-Git-Tag: VALA_0_0_3~7 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=36c718fa8de1dad18e67bb876593386023316393;p=thirdparty%2Fvala.git support base types for structs obey set keyword add SignalInvocationHint, 2006-08-18 Jürg Billeter * vala/parser.y, vala/valastruct.vala: support base types for structs * vala/valainterfacewriter.vala: obey set keyword * vapi/glib-2.0.vala: add SignalInvocationHint, SignalEmissionHook, SignalFlags, ValueArray, Math, Timeout, and PtrArray * vapi/cairo.vala: initial cairo binding * vapi/pango.vala, vapi/atk.vala, vapi/gdk-2.0.vala, vapi/gtk+-2.0.vala: bindings generated from Pango 1.13.5, ATK 1.12.1, and GTK+ 2.10.1 * vapi/Makefile.am: update svn path=/trunk/; revision=102 --- diff --git a/vala/ChangeLog b/vala/ChangeLog index 775cbbe0a..d1c7e01c3 100644 --- a/vala/ChangeLog +++ b/vala/ChangeLog @@ -1,3 +1,14 @@ +2006-08-18 Jürg Billeter + + * vala/parser.y, vala/valastruct.vala: support base types for structs + * vala/valainterfacewriter.vala: obey set keyword + * vapi/glib-2.0.vala: add SignalInvocationHint, SignalEmissionHook, + SignalFlags, ValueArray, Math, Timeout, and PtrArray + * vapi/cairo.vala: initial cairo binding + * vapi/pango.vala, vapi/atk.vala, vapi/gdk-2.0.vala, vapi/gtk+-2.0.vala: + bindings generated from Pango 1.13.5, ATK 1.12.1, and GTK+ 2.10.1 + * vapi/Makefile.am: update + 2006-08-11 Raffaele Sandrini * vala/valasymbolresolver.vala, vala/valatypereference.vala, diff --git a/vala/vala/parser.y b/vala/vala/parser.y index 005d4c125..70e3addb6 100644 --- a/vala/vala/parser.y +++ b/vala/vala/parser.y @@ -2536,7 +2536,7 @@ struct_declaration ; struct_header - : comment opt_attributes opt_access_modifier STRUCT IDENTIFIER opt_name_specifier opt_type_parameter_list + : comment opt_attributes opt_access_modifier STRUCT IDENTIFIER opt_name_specifier opt_type_parameter_list opt_class_base { char *name = $5; @@ -2565,6 +2565,13 @@ struct_header if ($3 != 0) { VALA_DATA_TYPE($$)->access = $3; } + if ($8 != NULL) { + for (l = $8; l != NULL; l = l->next) { + vala_struct_add_base_type ($$, l->data); + g_object_unref (l->data); + } + g_list_free ($8); + } } ; diff --git a/vala/vala/valainterfacewriter.vala b/vala/vala/valainterfacewriter.vala index 0f030dac3..9fb8aed97 100644 --- a/vala/vala/valainterfacewriter.vala +++ b/vala/vala/valainterfacewriter.vala @@ -306,7 +306,7 @@ public class Vala.InterfaceWriter : CodeVisitor { write_string (" "); if (param.name == "callback" || param.name == "flags" || - param.name == "out") { + param.name == "out" || param.name == "set") { write_string ("@"); } write_identifier (param.name); diff --git a/vala/vala/valastruct.vala b/vala/vala/valastruct.vala index d8d30bf50..1dc270cbe 100644 --- a/vala/vala/valastruct.vala +++ b/vala/vala/valastruct.vala @@ -30,6 +30,8 @@ public class Vala.Struct : DataType { List constants; List fields; List methods; + + private List base_types; string cname; string dup_function; @@ -321,4 +323,22 @@ public class Vala.Struct : DataType { private void set_marshaller_type_name (string! name) { this.marshaller_type_name = name; } + + /** + * Adds the specified struct to the list of base types of this struct. + * + * @param type a class or interface reference + */ + public void add_base_type (TypeReference! type) { + base_types.append (type); + } + + /** + * Returns a copy of the base type list. + * + * @return list of base types + */ + public ref List get_base_types () { + return base_types.copy (); + } } diff --git a/vala/vapi/Makefile.am b/vala/vapi/Makefile.am index efeaaf23c..d74266bf3 100644 --- a/vala/vapi/Makefile.am +++ b/vala/vapi/Makefile.am @@ -6,9 +6,12 @@ vala-1.0.vala: ../ccode/ccode.vala ../vala/vala.vala cat $^ > $@ dist_vapi_DATA = \ + atk.vala \ + cairo.vala \ glib-2.0.vala \ - libxml-2.0.vala \ + gdk-2.0.vala \ gtk+-2.0.vala \ + libxml-2.0.vala \ pango.vala \ vala-1.0.vala \ $(NULL) diff --git a/vala/vapi/atk.vala b/vala/vapi/atk.vala new file mode 100644 index 000000000..374cd5dda --- /dev/null +++ b/vala/vapi/atk.vala @@ -0,0 +1,605 @@ +[CCode (cheader_filename = "packages/atk/atk.h")] +namespace Atk { + public class GObjectAccessible : Atk.Object { + public static Atk.Object for_object (GLib.Object obj); + public GLib.Object get_object (); + public GLib.Type get_type (); + } + public class Hyperlink : GLib.Object, Atk.Action { + public int get_end_index (); + public int get_n_anchors (); + public Atk.Object get_object (int i); + public int get_start_index (); + public GLib.Type get_type (); + public string get_uri (int i); + public bool is_inline (); + public bool is_selected_link (); + public bool is_valid (); + [NoAccessorMethod ()] + public weak bool selected_link { get; } + [NoAccessorMethod ()] + public weak int number_of_anchors { get; } + public weak int end_index { get; } + public weak int start_index { get; } + public signal void link_activated (); + } + public class NoOpObject : Atk.Object, Atk.Component, Atk.Action, Atk.EditableText, Atk.Image, Atk.Selection, Atk.Table, Atk.Text, Atk.Hypertext, Atk.Value { + public GLib.Type get_type (); + public construct (GLib.Object obj); + } + public class NoOpObjectFactory : Atk.ObjectFactory { + public GLib.Type get_type (); + public construct (); + } + public class Object : GLib.Object { + public bool add_relationship (Atk.RelationType relationship, Atk.Object target); + public uint connect_property_change_handler (Atk.PropertyChangeHandler handler); + public GLib.SList get_attributes (); + public string get_description (); + public int get_index_in_parent (); + public Atk.Layer get_layer (); + public int get_mdi_zorder (); + public int get_n_accessible_children (); + public string get_name (); + public Atk.Object get_parent (); + public Atk.Role get_role (); + public GLib.Type get_type (); + public void initialize (pointer data); + public void notify_state_change (Atk.State state, bool value); + public Atk.Object ref_accessible_child (int i); + public Atk.RelationSet ref_relation_set (); + public Atk.StateSet ref_state_set (); + public void remove_property_change_handler (uint handler_id); + public bool remove_relationship (Atk.RelationType relationship, Atk.Object target); + public void set_description (string description); + public void set_name (string name); + public void set_parent (Atk.Object parent); + public void set_role (Atk.Role role); + [NoAccessorMethod ()] + public weak string atk_object_name_property_name { get; set; } + [NoAccessorMethod ()] + public weak string atk_object_name_property_description { get; set; } + [NoAccessorMethod ()] + public weak Atk.Object atk_object_name_property_parent { get; set; } + [NoAccessorMethod ()] + public weak double atk_object_name_property_value { get; set; } + [NoAccessorMethod ()] + public weak int atk_object_name_property_role { get; set; } + [NoAccessorMethod ()] + public weak int atk_object_name_property_component_layer { get; } + [NoAccessorMethod ()] + public weak int atk_object_name_property_component_mdi_zorder { get; } + [NoAccessorMethod ()] + public weak string atk_object_name_property_table_caption { get; set; } + [NoAccessorMethod ()] + public weak Atk.Object atk_object_name_property_table_column_header { get; set; } + [NoAccessorMethod ()] + public weak string atk_object_name_property_table_column_description { get; set; } + [NoAccessorMethod ()] + public weak Atk.Object atk_object_name_property_table_row_header { get; set; } + [NoAccessorMethod ()] + public weak string atk_object_name_property_table_row_description { get; set; } + [NoAccessorMethod ()] + public weak Atk.Object atk_object_name_property_table_summary { get; set; } + [NoAccessorMethod ()] + public weak Atk.Object atk_object_name_property_table_caption_object { get; set; } + [NoAccessorMethod ()] + public weak int atk_object_name_property_hypertext_num_links { get; } + public signal void children_changed (uint change_index, pointer changed_child); + public signal void focus_event (bool focus_in); + public signal void property_change (Atk.PropertyValues values); + public signal void state_change (string name, bool state_set); + public signal void visible_data_changed (); + public signal void active_descendant_changed (pointer child); + } + public class ObjectFactory : GLib.Object { + public Atk.Object create_accessible (GLib.Object obj); + public GLib.Type get_accessible_type (); + public GLib.Type get_type (); + public void invalidate (); + } + public class Registry : GLib.Object { + public Atk.ObjectFactory get_factory (GLib.Type type); + public GLib.Type get_factory_type (GLib.Type type); + public GLib.Type get_type (); + public void set_factory_type (GLib.Type type, GLib.Type factory_type); + } + public class Relation : GLib.Object { + public void add_target (Atk.Object target); + public Atk.RelationType get_relation_type (); + public GLib.PtrArray get_target (); + public GLib.Type get_type (); + public construct (Atk.Object targets, int n_targets, Atk.RelationType relationship); + public static Atk.RelationType type_for_name (string name); + public static string type_get_name (Atk.RelationType type); + public static Atk.RelationType type_register (string name); + [NoAccessorMethod ()] + public weak Atk.RelationType relation_type { get; set; } + [NoAccessorMethod ()] + public weak GLib.ValueArray target { get; set; } + } + public class RelationSet : GLib.Object { + public void add (Atk.Relation relation); + public void add_relation_by_type (Atk.RelationType relationship, Atk.Object target); + public bool contains (Atk.RelationType relationship); + public int get_n_relations (); + public Atk.Relation get_relation (int i); + public Atk.Relation get_relation_by_type (Atk.RelationType relationship); + public GLib.Type get_type (); + public construct (); + public void remove (Atk.Relation relation); + } + public class StateSet : GLib.Object { + public bool add_state (Atk.StateType type); + public void add_states (Atk.StateType types, int n_types); + public Atk.StateSet and_sets (Atk.StateSet compare_set); + public void clear_states (); + public bool contains_state (Atk.StateType type); + public bool contains_states (Atk.StateType types, int n_types); + public GLib.Type get_type (); + public bool is_empty (); + public construct (); + public Atk.StateSet or_sets (Atk.StateSet compare_set); + public bool remove_state (Atk.StateType type); + public Atk.StateSet xor_sets (Atk.StateSet compare_set); + } + public class Util : GLib.Object { + public GLib.Type get_type (); + } + public interface Action { + public bool do_action (int i); + public string get_description (int i); + public string get_keybinding (int i); + public string get_localized_name (int i); + public int get_n_actions (); + public string get_name (int i); + public GLib.Type get_type (); + public bool set_description (int i, string desc); + } + public interface Component { + public uint add_focus_handler (Atk.FocusHandler handler); + public bool contains (int x, int y, Atk.CoordType coord_type); + public double get_alpha (); + public void get_extents (int x, int y, int width, int height, Atk.CoordType coord_type); + public Atk.Layer get_layer (); + public int get_mdi_zorder (); + public void get_position (int x, int y, Atk.CoordType coord_type); + public void get_size (int width, int height); + public GLib.Type get_type (); + public bool grab_focus (); + public Atk.Object ref_accessible_at_point (int x, int y, Atk.CoordType coord_type); + public void remove_focus_handler (uint handler_id); + public bool set_extents (int x, int y, int width, int height, Atk.CoordType coord_type); + public bool set_position (int x, int y, Atk.CoordType coord_type); + public bool set_size (int width, int height); + } + public interface Document { + public string get_attribute_value (string attribute_name); + public GLib.SList get_attributes (); + public pointer get_document (); + public string get_document_type (); + public string get_locale (); + public GLib.Type get_type (); + public bool set_attribute_value (string attribute_name, string attribute_value); + } + public interface EditableText { + public void copy_text (int start_pos, int end_pos); + public void cut_text (int start_pos, int end_pos); + public void delete_text (int start_pos, int end_pos); + public GLib.Type get_type (); + public void insert_text (string string, int length, int position); + public void paste_text (int position); + public bool set_run_attributes (GLib.SList attrib_set, int start_offset, int end_offset); + public void set_text_contents (string string); + } + public interface HyperlinkImpl { + public Atk.Hyperlink get_hyperlink (); + public GLib.Type get_type (); + } + public interface Hypertext { + public Atk.Hyperlink get_link (int link_index); + public int get_link_index (int char_index); + public int get_n_links (); + public GLib.Type get_type (); + } + public interface Image { + public string get_image_description (); + public string get_image_locale (); + public void get_image_position (int x, int y, Atk.CoordType coord_type); + public void get_image_size (int width, int height); + public GLib.Type get_type (); + public bool set_image_description (string description); + } + public interface Implementor { + public GLib.Type get_type (); + public Atk.Object ref_accessible (); + } + public interface Selection { + public bool add_selection (int i); + public bool clear_selection (); + public int get_selection_count (); + public GLib.Type get_type (); + public bool is_child_selected (int i); + public Atk.Object ref_selection (int i); + public bool remove_selection (int i); + public bool select_all_selection (); + } + public interface StreamableContent { + public string get_mime_type (int i); + public int get_n_mime_types (); + public GLib.IOChannel get_stream (string mime_type); + public GLib.Type get_type (); + public string get_uri (string mime_type); + } + public interface Table { + public bool add_column_selection (int column); + public bool add_row_selection (int row); + public Atk.Object get_caption (); + public int get_column_at_index (int index_); + public string get_column_description (int column); + public int get_column_extent_at (int row, int column); + public Atk.Object get_column_header (int column); + public int get_index_at (int row, int column); + public int get_n_columns (); + public int get_n_rows (); + public int get_row_at_index (int index_); + public string get_row_description (int row); + public int get_row_extent_at (int row, int column); + public Atk.Object get_row_header (int row); + public int get_selected_columns (int selected); + public int get_selected_rows (int selected); + public Atk.Object get_summary (); + public GLib.Type get_type (); + public bool is_column_selected (int column); + public bool is_row_selected (int row); + public bool is_selected (int row, int column); + public Atk.Object ref_at (int row, int column); + public bool remove_column_selection (int column); + public bool remove_row_selection (int row); + public void set_caption (Atk.Object caption); + public void set_column_description (int column, string description); + public void set_column_header (int column, Atk.Object header); + public void set_row_description (int row, string description); + public void set_row_header (int row, Atk.Object header); + public void set_summary (Atk.Object accessible); + } + public interface Text { + public bool add_selection (int start_offset, int end_offset); + public static Atk.TextAttribute attribute_for_name (string name); + public static string attribute_get_name (Atk.TextAttribute attr); + public static string attribute_get_value (Atk.TextAttribute attr, int index_); + public static Atk.TextAttribute attribute_register (string name); + public static void free_ranges (Atk.TextRange ranges); + public Atk.TextRange get_bounded_ranges (Atk.TextRectangle rect, Atk.CoordType coord_type, Atk.TextClipType x_clip_type, Atk.TextClipType y_clip_type); + public int get_caret_offset (); + public unichar get_character_at_offset (int offset); + public int get_character_count (); + public void get_character_extents (int offset, int x, int y, int width, int height, Atk.CoordType coords); + public GLib.SList get_default_attributes (); + public int get_n_selections (); + public int get_offset_at_point (int x, int y, Atk.CoordType coords); + public void get_range_extents (int start_offset, int end_offset, Atk.CoordType coord_type, Atk.TextRectangle rect); + public GLib.SList get_run_attributes (int offset, int start_offset, int end_offset); + public string get_selection (int selection_num, int start_offset, int end_offset); + public string get_text (int start_offset, int end_offset); + public string get_text_after_offset (int offset, Atk.TextBoundary boundary_type, int start_offset, int end_offset); + public string get_text_at_offset (int offset, Atk.TextBoundary boundary_type, int start_offset, int end_offset); + public string get_text_before_offset (int offset, Atk.TextBoundary boundary_type, int start_offset, int end_offset); + public GLib.Type get_type (); + public bool remove_selection (int selection_num); + public bool set_caret_offset (int offset); + public bool set_selection (int selection_num, int start_offset, int end_offset); + } + public interface Value { + public void get_current_value (GLib.Value value); + public void get_maximum_value (GLib.Value value); + public void get_minimum_increment (GLib.Value value); + public void get_minimum_value (GLib.Value value); + public GLib.Type get_type (); + public bool set_current_value (GLib.Value value); + } + [ReferenceType ()] + public struct Attribute { + public weak string name; + public weak string value; + public static void set_free (GLib.SList attrib_set); + } + [ReferenceType ()] + public struct KeyEventStruct { + public weak int type; + public weak uint state; + public weak uint keyval; + public weak int length; + public weak string string; + public weak ushort keycode; + public weak uint timestamp; + } + [ReferenceType ()] + public struct PropertyValues { + public weak string property_name; + public weak GLib.Value old_value; + public weak GLib.Value new_value; + } + public struct Rectangle { + public GLib.Type get_type (); + } + [ReferenceType ()] + public struct TextRange { + public weak Atk.TextRectangle bounds; + public weak int start_offset; + public weak int end_offset; + public weak string content; + } + [ReferenceType ()] + public struct TextRectangle { + public weak int x; + public weak int y; + public weak int width; + public weak int height; + } + [ReferenceType ()] + public struct Global { + public static uint _add_focus_tracker (Atk.EventListener focus_tracker); + public static uint _add_global_event_listener (GLib.SignalEmissionHook listener, string event_type); + public static uint _add_key_event_listener (Atk.KeySnoopFunc listener, pointer data); + public Atk.Registry _get_default_registry (); + public Atk.Object _get_focus_object (); + public Atk.Object _get_root (); + public string _get_toolkit_name (); + public string _get_toolkit_version (); + public static void _remove_focus_tracker (uint tracker_id); + public static void _remove_global_event_listener (uint listener_id); + public static void _remove_key_event_listener (uint listener_id); + public static Atk.Role _role_for_name (string name); + public static string _role_get_localized_name (Atk.Role role); + public static string _role_get_name (Atk.Role role); + public static Atk.Role _role_register (string name); + } + [ReferenceType ()] + public struct Focus { + public static void tracker_init (Atk.EventListenerInit init); + public static void tracker_notify (Atk.Object object); + } + [ReferenceType ()] + public struct State { + public static Atk.StateType type_for_name (string name); + public static string type_get_name (Atk.StateType type); + public static Atk.StateType type_register (string name); + } + [CCode (cprefix = "ATK_XY_")] + public enum CoordType { + SCREEN, + WINDOW, + } + [CCode (cprefix = "ATK_HYPERLINK_IS_")] + public enum HyperlinkStateFlags { + INLINE, + } + [CCode (cprefix = "ATK_KEY_EVENT_")] + public enum KeyEventType { + PRESS, + RELEASE, + LAST_DEFINED, + } + [CCode (cprefix = "ATK_LAYER_")] + public enum Layer { + INVALID, + BACKGROUND, + CANVAS, + WIDGET, + MDI, + POPUP, + OVERLAY, + WINDOW, + } + [CCode (cprefix = "ATK_RELATION_")] + public enum RelationType { + NULL, + 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, + } + [CCode (cprefix = "ATK_ROLE_")] + public enum Role { + INVALID, + 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, + } + [CCode (cprefix = "ATK_STATE_")] + public enum StateType { + 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, + } + [CCode (cprefix = "ATK_TEXT_ATTR_")] + public enum TextAttribute { + INVALID, + 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, + } + [CCode (cprefix = "ATK_TEXT_BOUNDARY_")] + public enum TextBoundary { + CHAR, + WORD_START, + WORD_END, + SENTENCE_START, + SENTENCE_END, + LINE_START, + LINE_END, + } + [CCode (cprefix = "ATK_TEXT_CLIP_")] + public enum TextClipType { + NONE, + MIN, + MAX, + BOTH, + } + public callback void EventListener (Atk.Object obj); + public callback void EventListenerInit (); + public callback void FocusHandler (Atk.Object arg1, bool arg2); + public callback bool Function (pointer data); + public callback int KeySnoopFunc (Atk.KeyEventStruct event, pointer func_data); + public callback void PropertyChangeHandler (Atk.Object arg1, Atk.PropertyValues arg2); +} diff --git a/vala/vapi/cairo.vala b/vala/vapi/cairo.vala new file mode 100644 index 000000000..c03c8f106 --- /dev/null +++ b/vala/vapi/cairo.vala @@ -0,0 +1,564 @@ +/* cairo.vala + * + * Copyright (C) 2006 Jürg Billeter + * + * This library 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 of the License, or (at your option) any later version. + + * This library 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 this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Author: + * Jürg Billeter + */ + +[CCode (cheader_filename = "cairo.h")] +namespace Cairo { + [ReferenceType (dup_function = "cairo_reference", free_function = "cairo_destroy")] + [CCode (cname = "cairo_t", cprefix = "cairo_", cheader_filename = "cairo.h")] + public struct Context { + [CCode (cname = "cairo_create")] + public construct (Surface target); + public Status status (); + public void save (); + public void restore (); + + public Surface get_target (); + public void push_group (); + public void push_group_with_content (Content content); + public ref Pattern pop_group (); + public void pop_group_to_source (); + public Surface get_group_target (); + + public void set_source_rgb (double red, double green, double blue); + public void set_source_rgba (double red, double green, double blue, double alpha); + public void set_source (Pattern source); + public void set_source_surface (Surface surface, double x, double y); + public Pattern get_source (); + + public void set_antialias (Antialias antialias); + public Antialias get_antialias (); + + public void set_dash (double[] dashes, int num_dashes, double offset); + + public void set_fill_rule (FillRule fill_rule); + public FillRule get_fill_rule (); + + public void set_line_cap (LineCap line_cap); + public LineCap get_line_cap (); + + public void set_line_join (LineJoin line_join); + public LineJoin get_line_join (); + + public void set_line_width (double width); + public double get_line_width (); + + public void set_miter_limit (double limit); + public double get_miter_limit (); + + public void set_operator (Operator op); + public Operator get_operator (); + + public void set_tolerance (double tolerance); + public double get_tolerance (); + + public void clip (); + public void clip_preserve (); + public void reset_clip (); + + public void fill (); + public void fill_preserve (); + public void fill_extents (ref double x1, ref double y1, ref double x2, ref double y2); + public bool in_fill (double x, double y); + + public void mask (Pattern pattern); + public void mask_surface (Surface surface, double surface_x, double surface_y); + + public void paint (); + public void paint_with_alpha (double alpha); + + public void stroke (); + public void stroke_preserve (); + public void stroke_extents (ref double x1, ref double y1, ref double x2, ref double y2); + public bool in_stroke (double x, double y); + + public void copy_page (); + public void show_page (); + + public ref Path copy_path (); + public ref Path copy_path_flat (); + + public void append_path (Path path); + + public void get_current_point (ref double x, ref double y); + + public void new_path (); + public void new_sub_path (); + public void close_path (); + + public void arc (double xc, double yc, double radius, double angle1, double angle2); + public void arc_negative (double xc, double yc, double radius, double angle1, double angle2); + + public void curve_to (double x1, double y1, double x2, double y2, double x3, double y3); + public void line_to (double x, double y); + public void move_to (double x, double y); + + public void rectangle (double x, double y, double width, double height); + + public void glyph_path (Glyph[] glyphs, int num_glyphs); + public void text_path (string! utf8); + + public void rel_curve_to (double dx1, double dy1, double dx2, double dy2, double dx3, double dy3); + public void rel_line_to (double dx, double dy); + public void rel_move_to (double dx, double dy); + + public void translate (double tx, double ty); + public void scale (double sx, double sy); + public void rotate (double angle); + public void transform (ref Matrix matrix); + public void identity_matrix (); + + public void user_to_device (ref double x, ref double y); + public void user_to_device_distance (ref double dx, ref double dy); + public void device_to_user (ref double x, ref double y); + public void device_to_user_distance (ref double dx, ref double dy); + + public void select_font_face (string! family, FontSlant slant, FontWeight weight); + public void set_font_size (double size); + public void set_font_matrix (ref Matrix! matrix); + public void get_font_matrix (ref Matrix matrix); + public void set_font_options (ref FontOptions! options); + public void get_font_options (ref FontOptions options); + + public void show_text (string! utf8); + public void show_glyphs (Glyph[] glyphs, int num_glyphs); + + public FontFace get_font_face (); + public void font_extents (ref FontExtents extents); + public void set_font_face (FontFace font_face); + public void set_scaled_font (ScaledFont! font); + public void text_extents (string! utf8, ref TextExtents extents); + public void glyph_extents (Glyph[] glyphs, int num_glyphs, ref TextExtents extents); + } + + public enum Antialias { + DEFAULT, + NONE, + GRAY, + SUBPIXEL + } + + public enum FillRule { + WINDING, + EVEN_ODD + } + + public enum LineCap { + BUTT, + ROUND, + SQUARE + } + + public enum LineJoin { + MITER, + ROUND, + BEVEL + } + + public enum Operator { + CLEAR, + SOURCE, + OVER, + IN, + OUT, + ATOP, + DEST, + DEST_OVER, + DEST_IN, + DEST_OUT, + DEST_ATOP, + XOR, + ADD, + SATURATE + } + + [ReferenceType (free_function = "cairo_path_destroy")] + [CCode (cname = "cairo_path_t")] + public struct Path { + public Status status; + public PathData[] data; + public int num_data; + } + + [CCode (cname = "cairo_path_data_t")] + public struct PathData { + public PathDataHeader header; + public PathDataPoint point; + } + + public struct PathDataHeader { + public PathDataType type; + public int length; + } + + public struct PathDataPoint { + public double x; + public double y; + } + + [CCode (cprefix = "CAIRO_PATH_")] + public enum PathDataType { + MOVE_TO, + LINE_TO, + CURVE_TO, + CLOSE_PATH + } + + [ReferenceType (dup_function = "cairo_pattern_reference", free_function = "cairo_pattern_destroy")] + [CCode (cname = "cairo_pattern_t")] + public struct Pattern { + public void add_color_stop_rgb (double offset, double red, double green, double blue); + public void add_color_stop_rgba (double offset, double red, double green, double blue, double alpha); + + [CCode (cname = "cairo_pattern_create_rgb")] + public construct rgb (double red, double green, double blue); + [CCode (cname = "cairo_pattern_create_rgba")] + public construct rgba (double red, double green, double blue, double alpha); + [CCode (cname = "cairo_pattern_create_for_surface")] + public construct for_surface (Surface! surface); + [CCode (cname = "cairo_pattern_create_linear")] + public construct linear (double x0, double y0, double x1, double y1); + [CCode (cname = "cairo_pattern_create_radial")] + public construct radial (double cx0, double cy0, double radius0, double cx1, double cy1, double radius1); + + public Status status (); + + public void set_extend (Extend extend); + public Extend get_extend (); + + public void set_filter (Filter filter); + public Filter get_filter (); + + public void set_matrix (ref Matrix matrix); + public void get_matrix (ref Matrix matrix); + + public PatternType get_type (); + } + + [CCode (cname = "cairo_extend_t")] + public enum Extend { + NONE, + REPEAT, + REFLECT, + PAD + } + + [CCode (cname = "cairo_filter_t")] + public enum Filter { + FAST, + GOOD, + BEST, + NEAREST, + BILINEAR, + GAUSSIAN + } + + [CCode (cname = "cairo_pattern_type_t")] + public enum PatternType { + SOLID, + SURFACE, + LINEAR, + RADIAL + } + + [ReferenceType ()] + [CCode (cname = "cairo_glyph_t")] + public struct Glyph { + } + + [CCode (cname = "cairo_font_slant_t")] + public enum FontSlant { + NORMAL, + ITALIC, + OBLIQUE + } + + [CCode (cname = "cairo_font_weight_t")] + public enum FontWeight { + NORMAL, + BOLD + } + + [ReferenceType (dup_function = "cairo_font_face_reference", free_function = "cairo_font_face_destroy")] + [CCode (cname = "cairo_font_face_t")] + public struct FontFace { + public Status status (); + public FontType get_type (); + } + + [CCode (cname = "cairo_font_type_t")] + public enum FontType { + TOY, + FT, + WIN32, + ATSUI + } + + [ReferenceType (dup_function = "cairo_scaled_font_reference", free_function = "cairo_scaled_font_destroy")] + [CCode (cname = "cairo_scaled_font_t")] + public struct ScaledFont { + [CCode (cname = "cairo_scaled_font_create")] + public construct (ref Matrix font_matrix, ref Matrix ctm, ref FontOptions options); + public Status status (); + public void extents (ref FontExtents extents); + public void text_extents (string! utf8, ref TextExtents extents); + public void glyph_extents (Glyph[] glyphs, int num_glyphs, ref TextExtents extents); + public FontFace get_font_face (); + public void get_font_options (ref FontOptions options); + public void get_font_matrix (ref Matrix font_matrix); + public void get_ctm (ref Matrix ctm); + public FontType get_type (); + } + + [CCode (cname = "cairo_font_extents_t")] + public struct FontExtents { + public double ascent; + public double descent; + public double height; + public double max_x_advance; + public double max_y_advance; + } + + [CCode (cname = "cairo_text_extents_t")] + public struct TextExtents { + public double x_bearing; + public double y_bearing; + public double width; + public double height; + public double x_advance; + public double y_advance; + } + + [ReferenceType (dup_function = "cairo_font_options_copy", free_function = "cairo_font_options_destroy")] + [CCode (cname = "cairo_font_options_t")] + public struct FontOptions { + [CCode (cname = "cairo_font_options_create")] + public construct (); + public Status status (); + public void merge (FontOptions other); + public ulong hash (); + public bool equal (FontOptions other); + public void set_antialias (Antialias antialias); + public Antialias get_antialias (); + public void set_subpixel_order (SubpixelOrder subpixel_order); + public SubpixelOrder get_subpixel_order (); + public void set_hint_style (HintStyle hint_style); + public HintStyle get_hint_style (); + public void set_hint_metrics (HintMetrics hint_metrics); + public HintMetrics get_hint_metrics (); + } + + [CCode (cname = "cairo_subpixel_order_t")] + public enum SubpixelOrder { + DEFAULT, + RGB, + BGR, + VRGB, + VBGR + } + + [CCode (cname = "cairo_hint_style_t")] + public enum HintStyle { + DEFAULT, + NONE, + SLIGHT, + MEDIUM, + FULL + } + + [CCode (cname = "cairo_hint_metrics_t")] + public enum HintMetrics { + DEFAULT, + OFF, + ON + } + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t", cheader_filename = "cairo.h")] + public struct Surface { + [CCode (cname = "cairo_surface_create_similar")] + public construct similar (Surface! other, Content content, int width, int height); + public void finish (); + public void flush (); + public void get_font_options (ref FontOptions options); + public Content get_content (); + public void mark_dirty (); + public void mark_dirty_rectangle (int x, int y, int width, int height); + public void set_device_offset (double x_offset, double y_offset); + public void get_device_offset (ref double x_offset, ref double y_offset); + public void set_fallback_resolution (double x_pixels_per_inch, double y_pixels_per_inch); + public Status status (); + public SurfaceType get_type (); + + public Status write_to_png (string! filename); + public Status write_to_png_stream (WriteFunc write_func, pointer closure); + } + + public enum Content { + COLOR, + ALPHA, + COLOR_ALPHA + } + + public enum SurfaceType { + IMAGE, + PDF, + PS, + XLIB, + XCB, + GLITZ, + QUARTZ, + WIN32, + BEOS, + DIRECTFB, + SVG + } + + public enum Format { + ARGB32, + RGB24, + A8, + A1, + RGB16_565 + } + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t")] + public struct ImageSurface : Surface { + [CCode (cname = "cairo_image_surface_create")] + public construct (Format format, int width, int height); + [CCode (cname = "cairo_image_surface_create_for_data")] + public construct for_data (uchar[] data, Format format, int width, int height, int stride); + public uchar[] get_data (); + public Format get_format (); + public int get_width (); + public int get_height (); + public int get_stride (); + + [CCode (cname = "cairo_image_surface_create_from_png")] + public construct from_png (string! filename); + [CCode (cname = "cairo_image_surface_create_from_png_stream")] + public construct from_png_stream (ReadFunc read_func, pointer closure); + } + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t", cheader_filename = "cairo-pdf.h")] + public struct PdfSurface : Surface { + [CCode (cname = "cairo_pdf_surface_create")] + public construct (string! filename, double width_in_points, double height_in_points); + [CCode (cname = "cairo_pdf_surface_create_for_stream")] + public construct for_stream (WriteFunc write_func, pointer closure, double width_in_points, double height_in_points); + public void set_size (double width_in_points, double height_in_points); + } + + public callback Status ReadFunc (pointer closure, uchar[] data, uint length); + public callback Status WriteFunc (pointer closure, uchar[] data, uint length); + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t", cheader_filename = "cairo-ps.h")] + public struct PsSurface : Surface { + [CCode (cname = "cairo_ps_surface_create")] + public construct (string! filename, double width_in_points, double height_in_points); + [CCode (cname = "cairo_ps_surface_create_for_stream")] + public construct for_stream (WriteFunc write_func, pointer closure, double width_in_points, double height_in_points); + public void set_size (double width_in_points, double height_in_points); + public void dsc_begin_setup (); + public void dsc_begin_page_setup (); + public void dsc_comment (string! comment); + } + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t", cheader_filename = "cairo-svg.h")] + public struct SvgSurface : Surface { + [CCode (cname = "cairo_svg_surface_create")] + public construct (string! filename, double width_in_points, double height_in_points); + [CCode (cname = "cairo_svg_surface_create_for_stream")] + public construct for_stream (WriteFunc write_func, pointer closure, double width_in_points, double height_in_points); + public void restrict_to_version (SvgVersion version); + public static void get_versions (out SvgVersion[] versions, ref int num_versions); + } + + [CCode (cname = "cairo_svg_version_t", cprefix = "CAIRO_SVG_")] + public enum SvgVersion { + VERSION_1_1, + VERSION_1_2 + } + + [ReferenceType (dup_function = "cairo_surface_reference", free_function = "cairo_surface_destroy")] + [CCode (cname = "cairo_surface_t", cheader_filename = "cairo-xlib.h")] + public struct XlibSurface : Surface { + [CCode (cname = "cairo_xlib_surface_create")] + public construct (pointer dpy, int drawable, pointer visual, int width, int height); + [CCode (cname = "cairo_xlib_surface_create_for_bitmap")] + public construct for_bitmap (pointer dpy, int bitmap, pointer screen, int width, int height); + public void set_size (int width, int height); + public pointer get_display (); + public pointer get_screen (); + public void set_drawable (int drawable, int width, int height); + public int get_drawable (); + public pointer get_visual (); + public int get_width (); + public int get_height (); + public int get_depth (); + } + + public struct Matrix { + public void init (double xx, double yx, double xy, double yy, double x0, double y0); + public void init_identity (); + public void init_translate (double tx, double ty); + public void init_scale (double sx, double sy); + public void init_rotate (double radians); + public void translate (double tx, double ty); + public void scale (double sx, double sy); + public void rotate (double radians); + public Status invert (); + public void multiply (ref Matrix a, ref Matrix b); + public void transform_distance (ref double dx, ref double dy); + public void transform_point (ref double x, ref double y); + } + + public enum Status { + SUCCESS, + 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 + } + + public int version (); + public string! version_string (); +} diff --git a/vala/vapi/gdk-2.0.vala b/vala/vapi/gdk-2.0.vala new file mode 100644 index 000000000..39916b770 --- /dev/null +++ b/vala/vapi/gdk-2.0.vala @@ -0,0 +1,1754 @@ +[CCode (cheader_filename = "gdk/gdk.h")] +namespace Gdk { + public class Colormap : GLib.Object { + public weak int size; + public weak Gdk.Color colors; + public bool alloc_color (Gdk.Color color, bool writeable, bool best_match); + public int alloc_colors (Gdk.Color colors, int ncolors, bool writeable, bool best_match, bool success); + public void free_colors (Gdk.Color colors, int ncolors); + public Gdk.Screen get_screen (); + public Gdk.Colormap get_system (); + public GLib.Type get_type (); + public Gdk.Visual get_visual (); + public construct (Gdk.Visual visual, bool allocate); + public void query_color (ulong pixel, Gdk.Color result); + } + public class Device : GLib.Object { + public static void free_history (Gdk.TimeCoord events, int n_events); + public bool get_axis (double axes, Gdk.AxisUse use, double value); + public Gdk.Device get_core_pointer (); + public bool get_history (Gdk.Window window, uint start, uint stop, Gdk.TimeCoord events, int n_events); + public void get_state (Gdk.Window window, double axes, Gdk.ModifierType mask); + public GLib.Type get_type (); + public void set_axis_use (uint index_, Gdk.AxisUse use); + public void set_key (uint index_, uint keyval, Gdk.ModifierType modifiers); + public bool set_mode (Gdk.InputMode mode); + public void set_source (Gdk.InputSource source); + } + public class Display : GLib.Object { + public void add_client_message_filter (Gdk.Atom message_type, Gdk.FilterFunc func, pointer data); + public void beep (); + public void close (); + public void flush (); + public Gdk.Device get_core_pointer (); + public Gdk.Display get_default (); + public uint get_default_cursor_size (); + public Gdk.Window get_default_group (); + public Gdk.Screen get_default_screen (); + public Gdk.Event get_event (); + public void get_maximal_cursor_size (uint width, uint height); + public int get_n_screens (); + public string get_name (); + public void get_pointer (Gdk.Screen screen, int x, int y, Gdk.ModifierType mask); + public Gdk.Screen get_screen (int screen_num); + public GLib.Type get_type (); + public Gdk.Window get_window_at_pointer (int win_x, int win_y); + public void keyboard_ungrab (uint time_); + public GLib.List list_devices (); + public static Gdk.Display open (string display_name); + public Gdk.Display open_default_libgtk_only (); + public Gdk.Event peek_event (); + public bool pointer_is_grabbed (); + public void pointer_ungrab (uint time_); + public void put_event (Gdk.Event event); + public bool request_selection_notification (Gdk.Atom selection); + public void set_double_click_distance (uint distance); + public void set_double_click_time (uint msec); + public Gdk.DisplayPointerHooks set_pointer_hooks (Gdk.DisplayPointerHooks new_hooks); + public void store_clipboard (Gdk.Window clipboard_window, uint time_, Gdk.Atom targets, int n_targets); + public bool supports_clipboard_persistence (); + public bool supports_cursor_alpha (); + public bool supports_cursor_color (); + public bool supports_input_shapes (); + public bool supports_selection_notification (); + public bool supports_shapes (); + public void sync (); + public void warp_pointer (Gdk.Screen screen, int x, int y); + public signal void closed (bool is_error); + } + public class DisplayManager : GLib.Object { + public Gdk.DisplayManager @get (); + public Gdk.Display get_default_display (); + public GLib.Type get_type (); + public GLib.SList list_displays (); + public void set_default_display (Gdk.Display display); + public weak Gdk.Display default_display { get; set; } + public signal void display_opened (Gdk.Display display); + } + public class DragContext : GLib.Object { + public weak Gdk.DragProtocol protocol; + public weak bool is_source; + public weak Gdk.Window source_window; + public weak Gdk.Window dest_window; + public weak GLib.List targets; + public weak Gdk.DragAction actions; + public weak Gdk.DragAction suggested_action; + public weak Gdk.DragAction action; + public weak uint start_time; + public GLib.Type get_type (); + public construct (); + } + public class Drawable : GLib.Object { + public void draw_arc (Gdk.GC gc, bool filled, int x, int y, int width, int height, int angle1, int angle2); + public void draw_drawable (Gdk.GC gc, Gdk.Drawable src, int xsrc, int ysrc, int xdest, int ydest, int width, int height); + public void draw_glyphs (Gdk.GC gc, Pango.Font font, int x, int y, Pango.GlyphString glyphs); + public void draw_glyphs_transformed (Gdk.GC gc, Pango.Matrix matrix, Pango.Font font, int x, int y, Pango.GlyphString glyphs); + public void draw_gray_image (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar buf, int rowstride); + public void draw_image (Gdk.GC gc, Gdk.Image image, int xsrc, int ysrc, int xdest, int ydest, int width, int height); + public void draw_indexed_image (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar buf, int rowstride, Gdk.RgbCmap cmap); + public void draw_layout (Gdk.GC gc, int x, int y, Pango.Layout layout); + public void draw_layout_line (Gdk.GC gc, int x, int y, Pango.LayoutLine line); + public void draw_layout_line_with_colors (Gdk.GC gc, int x, int y, Pango.LayoutLine line, Gdk.Color foreground, Gdk.Color background); + public void draw_layout_with_colors (Gdk.GC gc, int x, int y, Pango.Layout layout, Gdk.Color foreground, Gdk.Color background); + public void draw_line (Gdk.GC gc, int x1_, int y1_, int x2_, int y2_); + public void draw_lines (Gdk.GC gc, Gdk.Point points, int npoints); + public void draw_pixbuf (Gdk.GC gc, Gdk.Pixbuf pixbuf, int src_x, int src_y, int dest_x, int dest_y, int width, int height, Gdk.RgbDither dither, int x_dither, int y_dither); + public void draw_point (Gdk.GC gc, int x, int y); + public void draw_points (Gdk.GC gc, Gdk.Point points, int npoints); + public void draw_polygon (Gdk.GC gc, bool filled, Gdk.Point points, int npoints); + public void draw_rectangle (Gdk.GC gc, bool filled, int x, int y, int width, int height); + public void draw_rgb_32_image (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar buf, int rowstride); + public void draw_rgb_32_image_dithalign (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar buf, int rowstride, int xdith, int ydith); + public void draw_rgb_image (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar rgb_buf, int rowstride); + public void draw_rgb_image_dithalign (Gdk.GC gc, int x, int y, int width, int height, Gdk.RgbDither dith, uchar rgb_buf, int rowstride, int xdith, int ydith); + public void draw_segments (Gdk.GC gc, Gdk.Segment segs, int nsegs); + public void draw_trapezoids (Gdk.GC gc, Gdk.Trapezoid trapezoids, int n_trapezoids); + public Gdk.Image copy_to_image (Gdk.Image image, int src_x, int src_y, int dest_x, int dest_y, int width, int height); + public Gdk.Region get_clip_region (); + public Gdk.Colormap get_colormap (); + public int get_depth (); + public Gdk.Display get_display (); + public Gdk.Image get_image (int x, int y, int width, int height); + public Gdk.Screen get_screen (); + public void get_size (int width, int height); + public GLib.Type get_type (); + public Gdk.Region get_visible_region (); + public Gdk.Visual get_visual (); + public void set_colormap (Gdk.Colormap colormap); + } + public class GC : GLib.Object { + public void copy (Gdk.GC src_gc); + public Gdk.Colormap get_colormap (); + public Gdk.Screen get_screen (); + public GLib.Type get_type (); + public void get_values (Gdk.GCValues values); + public construct (Gdk.Drawable drawable); + public construct with_values (Gdk.Drawable drawable, Gdk.GCValues values, Gdk.GCValuesMask values_mask); + public void offset (int x_offset, int y_offset); + public void set_background (Gdk.Color color); + public void set_clip_mask (Gdk.Bitmap mask); + public void set_clip_origin (int x, int y); + public void set_clip_rectangle (Gdk.Rectangle rectangle); + public void set_clip_region (Gdk.Region region); + public void set_colormap (Gdk.Colormap colormap); + public void set_dashes (int dash_offset, char[] dash_list, int n); + public void set_exposures (bool exposures); + public void set_fill (Gdk.Fill fill); + public void set_foreground (Gdk.Color color); + public void set_function (Gdk.Function function); + public void set_line_attributes (int line_width, Gdk.LineStyle line_style, Gdk.CapStyle cap_style, Gdk.JoinStyle join_style); + public void set_rgb_bg_color (Gdk.Color color); + public void set_rgb_fg_color (Gdk.Color color); + public void set_stipple (Gdk.Pixmap stipple); + public void set_subwindow (Gdk.SubwindowMode mode); + public void set_tile (Gdk.Pixmap tile); + public void set_ts_origin (int x, int y); + public void set_values (Gdk.GCValues values, Gdk.GCValuesMask values_mask); + } + public class Image : GLib.Object { + public weak Gdk.ImageType type; + public weak Gdk.Visual visual; + public weak Gdk.ByteOrder byte_order; + public weak int width; + public weak int height; + public weak ushort depth; + public weak ushort bpp; + public weak ushort bpl; + public weak ushort bits_per_pixel; + public weak pointer mem; + public weak Gdk.Colormap colormap; + public Gdk.Colormap get_colormap (); + public uint get_pixel (int x, int y); + public GLib.Type get_type (); + public construct (Gdk.ImageType type, Gdk.Visual visual, int width, int height); + public void put_pixel (int x, int y, uint pixel); + public void set_colormap (Gdk.Colormap colormap); + } + public class Keymap : GLib.Object { + public Gdk.Keymap get_default (); + public Pango.Direction get_direction (); + public bool get_entries_for_keycode (uint hardware_keycode, Gdk.KeymapKey keys, uint keyvals, int n_entries); + public bool get_entries_for_keyval (uint keyval, Gdk.KeymapKey keys, int n_keys); + public static Gdk.Keymap get_for_display (Gdk.Display display); + public GLib.Type get_type (); + public uint lookup_key (Gdk.KeymapKey key); + public bool translate_keyboard_state (uint hardware_keycode, Gdk.ModifierType state, int group, uint keyval, int effective_group, int level, Gdk.ModifierType consumed_modifiers); + public signal void direction_changed (); + public signal void keys_changed (); + } + public class PangoRenderer : Pango.Renderer { + public static Pango.Renderer get_default (Gdk.Screen screen); + public GLib.Type get_type (); + public construct (Gdk.Screen screen); + public void set_drawable (Gdk.Drawable drawable); + public void set_gc (Gdk.GC gc); + public void set_override_color (Pango.RenderPart part, Gdk.Color color); + public void set_stipple (Pango.RenderPart part, Gdk.Bitmap stipple); + [NoAccessorMethod ()] + public weak Gdk.Screen screen { get; construct; } + } + public class Pixbuf : GLib.Object { + public Gdk.Pixbuf add_alpha (bool substitute_color, uchar r, uchar g, uchar b); + public void composite (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type, int overall_alpha); + public void composite_color (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, uint color1, uint color2); + public Gdk.Pixbuf composite_color_simple (int dest_width, int dest_height, Gdk.InterpType interp_type, int overall_alpha, int check_size, uint color1, uint color2); + public Gdk.Pixbuf copy (); + public void copy_area (int src_x, int src_y, int width, int height, Gdk.Pixbuf dest_pixbuf, int dest_x, int dest_y); + public GLib.Quark error_quark (); + public void fill (uint pixel); + public Gdk.Pixbuf flip (bool horizontal); + public static Gdk.Pixbuf from_pixdata (Gdk.Pixdata pixdata, bool copy_pixels, GLib.Error error); + public int get_bits_per_sample (); + public Gdk.Colorspace get_colorspace (); + public static Gdk.PixbufFormat get_file_info (string filename, int width, int height); + public GLib.SList get_formats (); + public Gdk.Pixbuf get_from_drawable (Gdk.Drawable src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); + public Gdk.Pixbuf get_from_image (Gdk.Image src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height); + public bool get_has_alpha (); + public int get_height (); + public int get_n_channels (); + public string get_option (string key); + public uchar get_pixels (); + public int get_rowstride (); + public GLib.Type get_type (); + public int get_width (); + public construct (Gdk.Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height); + public construct from_data (uchar data, Gdk.Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height, int rowstride, Gdk.PixbufDestroyNotify destroy_fn, pointer destroy_fn_data); + public construct from_file (string filename, GLib.Error error); + public construct from_file_at_scale (string filename, int width, int height, bool preserve_aspect_ratio, GLib.Error error); + public construct from_file_at_size (string filename, int width, int height, GLib.Error error); + public construct from_inline (int data_length, uchar data, bool copy_pixels, GLib.Error error); + public construct from_xpm_data (string data); + public construct subpixbuf (int src_x, int src_y, int width, int height); + public void render_pixmap_and_mask (Gdk.Pixmap pixmap_return, Gdk.Bitmap mask_return, int alpha_threshold); + public void render_pixmap_and_mask_for_colormap (Gdk.Colormap colormap, Gdk.Pixmap pixmap_return, Gdk.Bitmap mask_return, int alpha_threshold); + public void render_threshold_alpha (Gdk.Bitmap bitmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height, int alpha_threshold); + public Gdk.Pixbuf rotate_simple (Gdk.PixbufRotation angle); + public void saturate_and_pixelate (Gdk.Pixbuf dest, float saturation, bool pixelate); + public bool save (string filename, string type, GLib.Error error); + public bool save_to_buffer (string buffer, ulong buffer_size, string type, GLib.Error error); + public bool save_to_bufferv (string buffer, ulong buffer_size, string type, string option_keys, string option_values, GLib.Error error); + public bool save_to_callback (Gdk.PixbufSaveFunc save_func, pointer user_data, string type, GLib.Error error); + public bool save_to_callbackv (Gdk.PixbufSaveFunc save_func, pointer user_data, string type, string option_keys, string option_values, GLib.Error error); + public bool savev (string filename, string type, string option_keys, string option_values, GLib.Error error); + public void scale (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type); + public Gdk.Pixbuf scale_simple (int dest_width, int dest_height, Gdk.InterpType interp_type); + [NoAccessorMethod ()] + public weak int n_channels { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Colorspace colorspace { get; set; } + [NoAccessorMethod ()] + public weak bool has_alpha { get; set; } + [NoAccessorMethod ()] + public weak int bits_per_sample { get; set; } + [NoAccessorMethod ()] + public weak int width { get; set; } + [NoAccessorMethod ()] + public weak int height { get; set; } + [NoAccessorMethod ()] + public weak int rowstride { get; set; } + [NoAccessorMethod ()] + public weak pointer pixels { get; set; } + } + public class PixbufAnimation : GLib.Object { + public int get_height (); + public Gdk.PixbufAnimationIter get_iter (GLib.TimeVal start_time); + public Gdk.Pixbuf get_static_image (); + public GLib.Type get_type (); + public int get_width (); + public bool is_static_image (); + public construct from_file (string filename, GLib.Error error); + } + public class PixbufAnimationIter : GLib.Object { + public bool advance (GLib.TimeVal current_time); + public int get_delay_time (); + public Gdk.Pixbuf get_pixbuf (); + public GLib.Type get_type (); + public bool on_currently_loading_frame (); + } + public class PixbufAniAnim : Gdk.PixbufAnimation { + public GLib.Type get_type (); + } + public class PixbufAniAnimIter : Gdk.PixbufAnimationIter { + public GLib.Type get_type (); + } + public class PixbufGifAnim : Gdk.PixbufAnimation { + public void frame_composite (Gdk.PixbufFrame frame); + public GLib.Type get_type (); + } + public class PixbufGifAnimIter : Gdk.PixbufAnimationIter { + public GLib.Type get_type (); + } + public class PixbufLoader : GLib.Object { + public bool close (GLib.Error error); + public Gdk.PixbufAnimation get_animation (); + public Gdk.PixbufFormat get_format (); + public Gdk.Pixbuf get_pixbuf (); + public GLib.Type get_type (); + public construct (); + public construct with_mime_type (string mime_type, GLib.Error error); + public construct with_type (string image_type, GLib.Error error); + public void set_size (int width, int height); + public bool write (uchar buf, ulong count, GLib.Error error); + public signal void size_prepared (int width, int height); + public signal void area_prepared (); + public signal void area_updated (int x, int y, int width, int height); + public signal void closed (); + } + public class PixbufSimpleAnim : Gdk.PixbufAnimation { + public void add_frame (Gdk.Pixbuf pixbuf); + public GLib.Type get_type (); + public GLib.Type iter_get_type (); + public construct (int width, int height, float rate); + } + public class Pixmap : GLib.Object { + public static Gdk.Pixmap colormap_create_from_xpm (Gdk.Drawable drawable, Gdk.Colormap colormap, Gdk.Bitmap mask, Gdk.Color transparent_color, string filename); + public static Gdk.Pixmap colormap_create_from_xpm_d (Gdk.Drawable drawable, Gdk.Colormap colormap, Gdk.Bitmap mask, Gdk.Color transparent_color, string data); + public static Gdk.Pixmap create_from_data (Gdk.Drawable drawable, string data, int width, int height, int depth, Gdk.Color fg, Gdk.Color bg); + public static Gdk.Pixmap create_from_xpm (Gdk.Drawable drawable, Gdk.Bitmap mask, Gdk.Color transparent_color, string filename); + public static Gdk.Pixmap create_from_xpm_d (Gdk.Drawable drawable, Gdk.Bitmap mask, Gdk.Color transparent_color, string data); + public static Gdk.Pixmap foreign_new (pointer anid); + public static Gdk.Pixmap foreign_new_for_display (Gdk.Display display, pointer anid); + public static Gdk.Pixmap foreign_new_for_screen (Gdk.Screen screen, pointer anid, int width, int height, int depth); + public GLib.Type get_type (); + public static Gdk.Pixmap lookup (pointer anid); + public static Gdk.Pixmap lookup_for_display (Gdk.Display display, pointer anid); + public construct (Gdk.Drawable drawable, int width, int height, int depth); + } + public class Screen : GLib.Object { + public void broadcast_client_message (Gdk.Event event); + public Gdk.Window get_active_window (); + public Gdk.Screen get_default (); + public Gdk.Colormap get_default_colormap (); + public Gdk.Display get_display (); + public pointer get_font_options (); + public int get_height (); + public int get_height_mm (); + public int get_monitor_at_point (int x, int y); + public int get_monitor_at_window (Gdk.Window window); + public void get_monitor_geometry (int monitor_num, Gdk.Rectangle dest); + public int get_n_monitors (); + public int get_number (); + public double get_resolution (); + public Gdk.Colormap get_rgb_colormap (); + public Gdk.Visual get_rgb_visual (); + public Gdk.Colormap get_rgba_colormap (); + public Gdk.Visual get_rgba_visual (); + public Gdk.Window get_root_window (); + public bool get_setting (string name, GLib.Value value); + public Gdk.Colormap get_system_colormap (); + public Gdk.Visual get_system_visual (); + public GLib.List get_toplevel_windows (); + public GLib.Type get_type (); + public int get_width (); + public int get_width_mm (); + public GLib.List get_window_stack (); + public int height (); + public int height_mm (); + public bool is_composited (); + public GLib.List list_visuals (); + public string make_display_name (); + public void set_default_colormap (Gdk.Colormap colormap); + public void set_font_options (pointer options); + public void set_resolution (double dpi); + public int width (); + public int width_mm (); + public weak pointer font_options { get; set; } + public weak double resolution { get; set; } + public signal void size_changed (); + public signal void composited_changed (); + } + public class Visual : GLib.Object { + public Gdk.Visual get_best (); + public int get_best_depth (); + public Gdk.VisualType get_best_type (); + public static Gdk.Visual get_best_with_both (int depth, Gdk.VisualType visual_type); + public static Gdk.Visual get_best_with_depth (int depth); + public static Gdk.Visual get_best_with_type (Gdk.VisualType visual_type); + public Gdk.Screen get_screen (); + public Gdk.Visual get_system (); + public GLib.Type get_type (); + } + public class Window : Gdk.Drawable { + public void add_filter (Gdk.FilterFunc function, pointer data); + public static Gdk.Window at_pointer (int win_x, int win_y); + public void begin_move_drag (int button, int root_x, int root_y, uint timestamp); + public void begin_paint_rect (Gdk.Rectangle rectangle); + public void begin_paint_region (Gdk.Region region); + public void begin_resize_drag (Gdk.WindowEdge edge, int button, int root_x, int root_y, uint timestamp); + public void clear (); + public void clear_area (int x, int y, int width, int height); + public void clear_area_e (int x, int y, int width, int height); + public void configure_finished (); + public static void constrain_size (Gdk.Geometry geometry, uint @flags, int width, int height, int new_width, int new_height); + public void deiconify (); + public void destroy (); + public void enable_synchronized_configure (); + public void end_paint (); + public void focus (uint timestamp); + public static Gdk.Window foreign_new (pointer anid); + public static Gdk.Window foreign_new_for_display (Gdk.Display display, pointer anid); + public void freeze_updates (); + public void fullscreen (); + public GLib.List get_children (); + public bool get_decorations (Gdk.WMDecoration decorations); + public Gdk.EventMask get_events (); + public void get_frame_extents (Gdk.Rectangle rect); + public void get_geometry (int x, int y, int width, int height, int depth); + public Gdk.Window get_group (); + public void get_internal_paint_info (Gdk.Drawable real_drawable, int x_offset, int y_offset); + public int get_origin (int x, int y); + public Gdk.Window get_parent (); + public Gdk.Window get_pointer (int x, int y, Gdk.ModifierType mask); + public void get_position (int x, int y); + public void get_root_origin (int x, int y); + public Gdk.WindowState get_state (); + public Gdk.Window get_toplevel (); + public GLib.List get_toplevels (); + public Gdk.WindowTypeHint get_type_hint (); + public Gdk.Region get_update_area (); + public void get_user_data (pointer data); + public Gdk.WindowType get_window_type (); + public void hide (); + public void iconify (); + public void input_shape_combine_mask (Gdk.Bitmap mask, int x, int y); + public void input_shape_combine_region (Gdk.Region shape_region, int offset_x, int offset_y); + public void invalidate_maybe_recurse (Gdk.Region region, Gdk.invalidate_maybe_recurseChildFunc child_func, pointer user_data); + public void invalidate_rect (Gdk.Rectangle rect, bool invalidate_children); + public void invalidate_region (Gdk.Region region, bool invalidate_children); + public bool is_viewable (); + public bool is_visible (); + public static Gdk.Window lookup (pointer anid); + public static Gdk.Window lookup_for_display (Gdk.Display display, pointer anid); + public void lower (); + public void maximize (); + public void merge_child_input_shapes (); + public void merge_child_shapes (); + public void move (int x, int y); + public void move_region (Gdk.Region region, int dx, int dy); + public void move_resize (int x, int y, int width, int height); + public construct (Gdk.WindowAttr attributes, int attributes_mask); + public GLib.List peek_children (); + public void process_all_updates (); + public void process_updates (bool update_children); + public void raise (); + public void register_dnd (); + public void remove_filter (Gdk.FilterFunc function, pointer data); + public void reparent (Gdk.Window new_parent, int x, int y); + public void resize (int width, int height); + public void scroll (int dx, int dy); + public void set_accept_focus (bool accept_focus); + public void set_back_pixmap (Gdk.Pixmap pixmap, bool parent_relative); + public void set_background (Gdk.Color color); + public void set_child_input_shapes (); + public void set_child_shapes (); + public void set_cursor (Gdk.Cursor cursor); + public static void set_debug_updates (bool setting); + public void set_decorations (Gdk.WMDecoration decorations); + public void set_events (Gdk.EventMask event_mask); + public void set_focus_on_map (bool focus_on_map); + public void set_functions (Gdk.WMFunction functions); + public void set_geometry_hints (Gdk.Geometry geometry, Gdk.WindowHints geom_mask); + public void set_group (Gdk.Window leader); + public void set_icon (Gdk.Window icon_window, Gdk.Pixmap pixmap, Gdk.Bitmap mask); + public void set_icon_list (GLib.List pixbufs); + public void set_icon_name (string name); + public void set_keep_above (bool setting); + public void set_keep_below (bool setting); + public void set_modal_hint (bool modal); + public void set_override_redirect (bool override_redirect); + public void set_role (string role); + public void set_skip_pager_hint (bool skips_pager); + public void set_skip_taskbar_hint (bool skips_taskbar); + public bool set_static_gravities (bool use_static); + public void set_title (string title); + public void set_transient_for (Gdk.Window parent); + public void set_type_hint (Gdk.WindowTypeHint hint); + public void set_urgency_hint (bool urgent); + public void set_user_data (pointer user_data); + public void shape_combine_mask (Gdk.Bitmap mask, int x, int y); + public void shape_combine_region (Gdk.Region shape_region, int offset_x, int offset_y); + public void show (); + public void show_unraised (); + public void stick (); + public void thaw_updates (); + public void unfullscreen (); + public void unmaximize (); + public void unstick (); + public void withdraw (); + } + public class Bitmap { + public weak GLib.Object parent_instance; + public static Gdk.Bitmap create_from_data (Gdk.Drawable drawable, string data, int width, int height); + } + [ReferenceType ()] + public struct BRESINFO { + public weak int minor_axis; + public weak int d; + public weak int m; + public weak int m1; + public weak int incr1; + public weak int incr2; + } + [ReferenceType ()] + public struct EdgeTable { + public weak int ymax; + public weak int ymin; + public weak Gdk.ScanLineList scanlines; + } + [ReferenceType ()] + public struct EdgeTableEntry { + } + public struct Color { + public Gdk.Color copy (); + public bool equal (Gdk.Color colorb); + public void free (); + public GLib.Type get_type (); + public uint hash (); + public static bool parse (string spec, Gdk.Color color); + } + public struct Cursor { + public Gdk.Display get_display (); + public Gdk.Pixbuf get_image (); + public GLib.Type get_type (); + public construct (Gdk.CursorType cursor_type); + public construct for_display (Gdk.Display display, Gdk.CursorType cursor_type); + public construct from_name (Gdk.Display display, string name); + public construct from_pixbuf (Gdk.Display display, Gdk.Pixbuf pixbuf, int x, int y); + public construct from_pixmap (Gdk.Pixmap source, Gdk.Pixmap mask, Gdk.Color fg, Gdk.Color bg, int x, int y); + public Gdk.Cursor @ref (); + public void unref (); + } + [ReferenceType ()] + public struct DeviceAxis { + public weak Gdk.AxisUse use; + public weak double min; + public weak double max; + } + [ReferenceType ()] + public struct DeviceKey { + public weak uint keyval; + public weak Gdk.ModifierType modifiers; + } + [ReferenceType ()] + public struct DisplayPointerHooks { + } + [ReferenceType ()] + public struct EventAny { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + } + [ReferenceType ()] + public struct EventButton { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak uint time; + public weak double x; + public weak double y; + public weak double axes; + public weak uint state; + public weak uint button; + public weak Gdk.Device device; + public weak double x_root; + public weak double y_root; + } + [ReferenceType ()] + public struct EventClient { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.Atom message_type; + public weak ushort data_format; + public weak char b; + } + [ReferenceType ()] + public struct EventConfigure { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak int x; + public weak int y; + public weak int width; + public weak int height; + } + [ReferenceType ()] + public struct EventCrossing { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.Window subwindow; + public weak uint time; + public weak double x; + public weak double y; + public weak double x_root; + public weak double y_root; + public weak Gdk.CrossingMode mode; + public weak Gdk.NotifyType detail; + public weak bool focus; + public weak uint state; + } + [ReferenceType ()] + public struct EventDND { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.DragContext context; + public weak uint time; + public weak short x_root; + public weak short y_root; + } + [ReferenceType ()] + public struct EventExpose { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.Rectangle area; + public weak Gdk.Region region; + public weak int count; + } + [ReferenceType ()] + public struct EventFocus { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak short @in; + } + [ReferenceType ()] + public struct EventGrabBroken { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak bool keyboard; + public weak bool implicit; + public weak Gdk.Window grab_window; + } + [ReferenceType ()] + public struct EventKey { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak uint time; + public weak uint state; + public weak uint keyval; + public weak int length; + public weak string string; + public weak ushort hardware_keycode; + public weak uchar group; + public weak uint is_modifier; + } + [ReferenceType ()] + public struct EventMotion { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak uint time; + public weak double x; + public weak double y; + public weak double axes; + public weak uint state; + public weak short is_hint; + public weak Gdk.Device device; + public weak double x_root; + public weak double y_root; + } + [ReferenceType ()] + public struct EventNoExpose { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + } + [ReferenceType ()] + public struct EventOwnerChange { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak pointer owner; + public weak Gdk.OwnerChange reason; + public weak Gdk.Atom selection; + public weak uint time; + public weak uint selection_time; + } + [ReferenceType ()] + public struct EventProperty { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.Atom atom; + public weak uint time; + public weak uint state; + } + [ReferenceType ()] + public struct EventProximity { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak uint time; + public weak Gdk.Device device; + } + [ReferenceType ()] + public struct EventScroll { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak uint time; + public weak double x; + public weak double y; + public weak uint state; + public weak Gdk.ScrollDirection direction; + public weak Gdk.Device device; + public weak double x_root; + public weak double y_root; + } + [ReferenceType ()] + public struct EventSelection { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.Atom selection; + public weak Gdk.Atom target; + public weak Gdk.Atom property; + public weak uint time; + public weak pointer requestor; + } + [ReferenceType ()] + public struct EventSetting { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.SettingAction action; + public weak string name; + } + [ReferenceType ()] + public struct EventVisibility { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.VisibilityState state; + } + [ReferenceType ()] + public struct EventWindowState { + public weak Gdk.EventType type; + public weak Gdk.Window window; + public weak char send_event; + public weak Gdk.WindowState changed_mask; + public weak Gdk.WindowState new_window_state; + } + public struct Font { + } + [ReferenceType ()] + public struct GCValues { + public weak Gdk.Color foreground; + public weak Gdk.Color background; + public weak Gdk.Font font; + public weak Gdk.Function function; + public weak Gdk.Fill fill; + public weak Gdk.Pixmap tile; + public weak Gdk.Pixmap stipple; + public weak Gdk.Pixmap clip_mask; + public weak Gdk.SubwindowMode subwindow_mode; + public weak int ts_x_origin; + public weak int ts_y_origin; + public weak int clip_x_origin; + public weak int clip_y_origin; + public weak int graphics_exposures; + public weak int line_width; + public weak Gdk.LineStyle line_style; + public weak Gdk.CapStyle cap_style; + public weak Gdk.JoinStyle join_style; + } + [ReferenceType ()] + public struct Geometry { + public weak int min_width; + public weak int min_height; + public weak int max_width; + public weak int max_height; + public weak int base_width; + public weak int base_height; + public weak int width_inc; + public weak int height_inc; + public weak double min_aspect; + public weak double max_aspect; + public weak Gdk.Gravity win_gravity; + } + [ReferenceType ()] + public struct KeymapKey { + public weak uint keycode; + public weak int group; + public weak int level; + } + [ReferenceType ()] + public struct PangoAttrEmbossed { + public weak Pango.Attribute attr; + public weak bool embossed; + public construct (bool embossed); + } + [ReferenceType ()] + public struct PangoAttrStipple { + public weak Pango.Attribute attr; + public weak Gdk.Bitmap stipple; + public construct (Gdk.Bitmap stipple); + } + [ReferenceType ()] + public struct PixbufFormat { + public string get_description (); + public string get_extensions (); + public string get_license (); + public string get_mime_types (); + public string get_name (); + public bool is_disabled (); + public bool is_scalable (); + public bool is_writable (); + public void set_disabled (bool disabled); + } + [ReferenceType ()] + public struct PixbufFrame { + public weak Gdk.Pixbuf pixbuf; + public weak int x_offset; + public weak int y_offset; + public weak int delay_time; + public weak int elapsed; + public weak Gdk.PixbufFrameAction action; + public weak bool need_recomposite; + public weak bool bg_transparent; + public weak Gdk.Pixbuf composited; + public weak Gdk.Pixbuf revert; + } + [ReferenceType ()] + public struct Pixdata { + public weak uint magic; + public weak int length; + public weak uint pixdata_type; + public weak uint rowstride; + public weak uint width; + public weak uint height; + public weak uchar pixel_data; + public bool deserialize (uint stream_length, uchar stream, GLib.Error error); + public pointer from_pixbuf (Gdk.Pixbuf pixbuf, bool use_rle); + public uchar serialize (uint stream_length_p); + public GLib.String to_csource (string name, Gdk.PixdataDumpType dump_type); + } + [ReferenceType ()] + public struct PixmapObject { + public weak Gdk.Drawable parent_instance; + public weak Gdk.Drawable impl; + public weak int depth; + } + [ReferenceType ()] + public struct Point { + public weak int x; + public weak int y; + } + [ReferenceType ()] + public struct PointerHooks { + } + public struct Rectangle { + public GLib.Type get_type (); + public bool intersect (Gdk.Rectangle src2, Gdk.Rectangle dest); + public void union (Gdk.Rectangle src2, Gdk.Rectangle dest); + } + [ReferenceType ()] + public struct Region { + public weak long size; + public weak long numRects; + public weak Gdk.RegionBox rects; + public weak Gdk.RegionBox extents; + public Gdk.Region copy (); + public void destroy (); + public bool empty (); + public bool equal (Gdk.Region region2); + public void get_clipbox (Gdk.Rectangle rectangle); + public void get_rectangles (Gdk.Rectangle rectangles, int n_rectangles); + public void intersect (Gdk.Region source2); + public construct (); + public void offset (int dx, int dy); + public bool point_in (int x, int y); + public static Gdk.Region polygon (Gdk.Point points, int npoints, Gdk.FillRule fill_rule); + public Gdk.OverlapType rect_in (Gdk.Rectangle rectangle); + public static Gdk.Region rectangle (Gdk.Rectangle rectangle); + public void shrink (int dx, int dy); + public void spans_intersect_foreach (Gdk.Span spans, int n_spans, bool sorted, Gdk.SpanFunc function, pointer data); + public void subtract (Gdk.Region source2); + public void union (Gdk.Region source2); + public void union_with_rect (Gdk.Rectangle rect); + public void xor (Gdk.Region source2); + } + [ReferenceType ()] + public struct RegionBox { + public weak int x1; + public weak int y1; + public weak int x2; + public weak int y2; + } + [ReferenceType ()] + public struct RgbCmap { + public weak uint colors; + public weak int n_colors; + public void free (); + public construct (uint colors, int n_colors); + } + [ReferenceType ()] + public struct Segment { + public weak int x1; + public weak int y1; + public weak int x2; + public weak int y2; + } + [ReferenceType ()] + public struct Span { + public weak int x; + public weak int y; + public weak int width; + } + [ReferenceType ()] + public struct TimeCoord { + public weak uint time; + public weak double axes; + } + [ReferenceType ()] + public struct Trapezoid { + public weak double y1; + public weak double x11; + public weak double x21; + public weak double y2; + public weak double x12; + public weak double x22; + } + [ReferenceType ()] + public struct WindowAttr { + public weak string title; + public weak int event_mask; + public weak int x; + public weak int y; + public weak int width; + public weak int height; + public weak pointer wclass; + public weak Gdk.Visual visual; + public weak Gdk.Colormap colormap; + public weak Gdk.WindowType window_type; + public weak Gdk.Cursor cursor; + public weak string wmclass_name; + public weak string wmclass_class; + public weak bool override_redirect; + } + [ReferenceType ()] + public struct WindowObject { + public weak Gdk.Drawable parent_instance; + public weak Gdk.Drawable impl; + public weak Gdk.WindowObject parent; + public weak pointer user_data; + public weak int x; + public weak int y; + public weak int extension_events; + public weak GLib.List filters; + public weak GLib.List children; + public weak Gdk.Color bg_color; + public weak Gdk.Pixmap bg_pixmap; + public weak GLib.SList paint_stack; + public weak Gdk.Region update_area; + public weak uint update_freeze_count; + public weak uchar window_type; + public weak uchar depth; + public weak uchar resize_count; + public weak Gdk.WindowState state; + public weak uint guffaw_gravity; + public weak uint input_only; + public weak uint modal_hint; + public weak uint destroyed; + public weak uint accept_focus; + public weak uint focus_on_map; + public weak uint shaped; + public weak Gdk.EventMask event_mask; + public GLib.Type get_type (); + } + [ReferenceType ()] + public struct POINTBLOCK { + } + [ReferenceType ()] + public struct ScanLineList { + } + [ReferenceType ()] + public struct ScanLineListBlock { + } + public struct Atom { + public static Gdk.Atom intern (string atom_name, bool only_if_exists); + public static Gdk.Atom intern_static_string (string atom_name); + public string name (); + } + [ReferenceType ()] + public struct Global { + public static void _add_client_message_filter (Gdk.Atom message_type, Gdk.FilterFunc func, pointer data); + public static void _add_option_entries_libgtk_only (GLib.OptionGroup group); + public GLib.List _devices_list (); + public bool _events_pending (); + public static void _free_compound_text (uchar ctext); + public static void _free_text_list (string list); + public Gdk.Window _get_default_root_window (); + public string _get_display (); + public string _get_display_arg_name (); + public string _get_program_class (); + public bool _get_show_events (); + public static bool _init_check (int argc, string argv); + public GLib.List _list_visuals (); + public void _notify_startup_complete (); + public static void _parse_args (int argc, string argv); + public void _pre_parse_libgtk_only (); + public static void _set_double_click_time (uint msec); + public string _set_locale (); + public static Gdk.PointerHooks _set_pointer_hooks (Gdk.PointerHooks new_hooks); + public static void _set_program_class (string program_class); + public static void _set_show_events (bool show_events); + public static void _set_sm_client_id (string sm_client_id); + public static bool _setting_get (string name, GLib.Value value); + public static int _string_to_compound_text (string str, Gdk.Atom encoding, int format, uchar ctext, int length); + public static int _string_to_compound_text_for_display (Gdk.Display display, string str, Gdk.Atom encoding, int format, uchar ctext, int length); + public static uint _unicode_to_keyval (uint wc); + } + [ReferenceType ()] + public struct Cairo { + public static Cairo.Context create (Gdk.Drawable drawable); + public static void rectangle (Cairo.Context cr, Gdk.Rectangle rectangle); + public static void region (Cairo.Context cr, Gdk.Region region); + public static void set_source_color (Cairo.Context cr, Gdk.Color color); + public static void set_source_pixbuf (Cairo.Context cr, Gdk.Pixbuf pixbuf, double pixbuf_x, double pixbuf_y); + public static void set_source_pixmap (Cairo.Context cr, Gdk.Pixmap pixmap, double pixmap_x, double pixmap_y); + } + [ReferenceType ()] + public struct Char { + } + [ReferenceType ()] + public struct Colors { + } + [ReferenceType ()] + public struct Drag { + public static void abort (Gdk.DragContext context, uint time_); + public static Gdk.DragContext begin (Gdk.Window window, GLib.List targets); + public static void drop (Gdk.DragContext context, uint time_); + public static bool drop_succeeded (Gdk.DragContext context); + public static void find_window (Gdk.DragContext context, Gdk.Window drag_window, int x_root, int y_root, Gdk.Window dest_window, Gdk.DragProtocol protocol); + public static void find_window_for_screen (Gdk.DragContext context, Gdk.Window drag_window, Gdk.Screen screen, int x_root, int y_root, Gdk.Window dest_window, Gdk.DragProtocol protocol); + public static uint get_protocol (uint xid, Gdk.DragProtocol protocol); + public static uint get_protocol_for_display (Gdk.Display display, uint xid, Gdk.DragProtocol protocol); + public static Gdk.Atom get_selection (Gdk.DragContext context); + public static bool motion (Gdk.DragContext context, Gdk.Window dest_window, Gdk.DragProtocol protocol, int x_root, int y_root, Gdk.DragAction suggested_action, Gdk.DragAction possible_actions, uint time_); + public static void status (Gdk.DragContext context, Gdk.DragAction action, uint time_); + } + [ReferenceType ()] + public struct Drop { + public static void finish (Gdk.DragContext context, bool success, uint time_); + public static void reply (Gdk.DragContext context, bool ok, uint time_); + } + [ReferenceType ()] + public struct Error { + public int trap_pop (); + public void trap_push (); + } + [ReferenceType ()] + public struct Event { + public Gdk.Event copy (); + public void free (); + public Gdk.Event @get (); + public bool get_axis (Gdk.AxisUse axis_use, double value); + public bool get_coords (double x_win, double y_win); + public static Gdk.Event get_graphics_expose (Gdk.Window window); + public bool get_root_coords (double x_root, double y_root); + public Gdk.Screen get_screen (); + public bool get_state (Gdk.ModifierType state); + public uint get_time (); + public GLib.Type get_type (); + public static void handler_set (Gdk.EventFunc func, pointer data, GLib.DestroyNotify notify); + public construct (Gdk.EventType type); + public Gdk.Event peek (); + public void put (); + public bool send_client_message (pointer winid); + public static bool send_client_message_for_display (Gdk.Display display, Gdk.Event event, pointer winid); + public void send_clientmessage_toall (); + public void set_screen (Gdk.Screen screen); + } + [ReferenceType ()] + public struct Fontset { + } + [ReferenceType ()] + public struct Input { + public static void set_extension_events (Gdk.Window window, int mask, Gdk.ExtensionMode mode); + } + [ReferenceType ()] + public struct Keyboard { + public static Gdk.GrabStatus grab (Gdk.Window window, bool owner_events, uint time_); + public static bool grab_info_libgtk_only (Gdk.Display display, Gdk.Window grab_window, bool owner_events); + public static void ungrab (uint time_); + } + [ReferenceType ()] + public struct Keyval { + public static void convert_case (uint symbol, uint lower, uint upper); + public static uint from_name (string keyval_name); + public static bool is_lower (uint keyval); + public static bool is_upper (uint keyval); + public static string name (uint keyval); + public static uint to_lower (uint keyval); + public static uint to_unicode (uint keyval); + public static uint to_upper (uint keyval); + } + [ReferenceType ()] + public struct Pango { + public Pango.Context context_get (); + public static Pango.Context context_get_for_screen (Gdk.Screen screen); + public static Gdk.Region layout_get_clip_region (Pango.Layout layout, int x_origin, int y_origin, int index_ranges, int n_ranges); + public static Gdk.Region layout_line_get_clip_region (Pango.LayoutLine line, int x_origin, int y_origin, int index_ranges, int n_ranges); + } + [ReferenceType ()] + public struct Pointer { + public static Gdk.GrabStatus grab (Gdk.Window window, bool owner_events, Gdk.EventMask event_mask, Gdk.Window confine_to, Gdk.Cursor cursor, uint time_); + public static bool grab_info_libgtk_only (Gdk.Display display, Gdk.Window grab_window, bool owner_events); + public bool is_grabbed (); + public static void ungrab (uint time_); + } + [ReferenceType ()] + public struct Property { + public static void change (Gdk.Window window, Gdk.Atom property, Gdk.Atom type, int format, Gdk.PropMode mode, uchar data, int nelements); + public static void delete (Gdk.Window window, Gdk.Atom property); + public static bool @get (Gdk.Window window, Gdk.Atom property, Gdk.Atom type, ulong offset, ulong length, int pdelete, Gdk.Atom actual_property_type, int actual_format, int actual_length, uchar data); + } + [ReferenceType ()] + public struct Query { + public static void depths (int depths, int count); + public static void visual_types (Gdk.VisualType visual_types, int count); + } + [ReferenceType ()] + public struct Rgb { + public static bool colormap_ditherable (Gdk.Colormap cmap); + public bool ditherable (); + public static void find_color (Gdk.Colormap colormap, Gdk.Color color); + public Gdk.Colormap get_colormap (); + public Gdk.Visual get_visual (); + public static void set_install (bool install); + public static void set_min_colors (int min_colors); + public static void set_verbose (bool verbose); + } + [ReferenceType ()] + public struct Selection { + public static void convert (Gdk.Window requestor, Gdk.Atom selection, Gdk.Atom target, uint time_); + public static Gdk.Window owner_get (Gdk.Atom selection); + public static Gdk.Window owner_get_for_display (Gdk.Display display, Gdk.Atom selection); + public static bool owner_set (Gdk.Window owner, Gdk.Atom selection, uint time_, bool send_event); + public static bool owner_set_for_display (Gdk.Display display, Gdk.Window owner, Gdk.Atom selection, uint time_, bool send_event); + public static bool property_get (Gdk.Window requestor, uchar data, Gdk.Atom prop_type, int prop_format); + public static void send_notify (uint requestor, Gdk.Atom selection, Gdk.Atom target, Gdk.Atom property, uint time_); + public static void send_notify_for_display (Gdk.Display display, uint requestor, Gdk.Atom selection, Gdk.Atom target, Gdk.Atom property, uint time_); + } + [ReferenceType ()] + public struct Spawn { + public static bool command_line_on_screen (Gdk.Screen screen, string command_line, GLib.Error error); + public static bool on_screen (Gdk.Screen screen, string working_directory, string argv, string envp, GLib.SpawnFlags @flags, GLib.SpawnChildSetupFunc child_setup, pointer user_data, int child_pid, GLib.Error error); + public static bool on_screen_with_pipes (Gdk.Screen screen, string working_directory, string argv, string envp, GLib.SpawnFlags @flags, GLib.SpawnChildSetupFunc child_setup, pointer user_data, int child_pid, int standard_input, int standard_output, int standard_error, GLib.Error error); + } + [ReferenceType ()] + public struct Text { + public static int property_to_text_list (Gdk.Atom encoding, int format, uchar text, int length, string list); + public static int property_to_text_list_for_display (Gdk.Display display, Gdk.Atom encoding, int format, uchar text, int length, string list); + public static int property_to_utf8_list (Gdk.Atom encoding, int format, uchar text, int length, string list); + public static int property_to_utf8_list_for_display (Gdk.Display display, Gdk.Atom encoding, int format, uchar text, int length, string list); + } + [ReferenceType ()] + public struct Threads { + public void enter (); + public void init (); + public void leave (); + public static void set_lock_functions (GLib.Callback enter_fn, GLib.Callback leave_fn); + } + [CCode (cprefix = "GDK_AXIS_")] + public enum AxisUse { + IGNORE, + X, + Y, + PRESSURE, + XTILT, + YTILT, + WHEEL, + LAST, + } + [CCode (cprefix = "GDK_")] + public enum ByteOrder { + LSB_FIRST, + MSB_FIRST, + } + [CCode (cprefix = "GDK_CAP_")] + public enum CapStyle { + NOT_LAST, + BUTT, + ROUND, + PROJECTING, + } + [CCode (cprefix = "GDK_COLORSPACE_")] + public enum Colorspace { + RGB, + } + [CCode (cprefix = "GDK_CROSSING_")] + public enum CrossingMode { + NORMAL, + GRAB, + UNGRAB, + } + [CCode (cprefix = "GDK_")] + public enum CursorType { + X_CURSOR, + ARROW, + BASED_ARROW_DOWN, + BASED_ARROW_UP, + BOAT, + BOGOSITY, + BOTTOM_LEFT_CORNER, + BOTTOM_RIGHT_CORNER, + BOTTOM_SIDE, + BOTTOM_TEE, + BOX_SPIRAL, + CENTER_PTR, + CIRCLE, + CLOCK, + COFFEE_MUG, + CROSS, + CROSS_REVERSE, + CROSSHAIR, + DIAMOND_CROSS, + DOT, + DOTBOX, + DOUBLE_ARROW, + DRAFT_LARGE, + DRAFT_SMALL, + DRAPED_BOX, + EXCHANGE, + FLEUR, + GOBBLER, + GUMBY, + HAND1, + HAND2, + HEART, + ICON, + IRON_CROSS, + LEFT_PTR, + LEFT_SIDE, + LEFT_TEE, + LEFTBUTTON, + LL_ANGLE, + LR_ANGLE, + MAN, + MIDDLEBUTTON, + MOUSE, + PENCIL, + PIRATE, + PLUS, + QUESTION_ARROW, + RIGHT_PTR, + RIGHT_SIDE, + RIGHT_TEE, + RIGHTBUTTON, + RTL_LOGO, + SAILBOAT, + SB_DOWN_ARROW, + SB_H_DOUBLE_ARROW, + SB_LEFT_ARROW, + SB_RIGHT_ARROW, + SB_UP_ARROW, + SB_V_DOUBLE_ARROW, + SHUTTLE, + SIZING, + SPIDER, + SPRAYCAN, + STAR, + TARGET, + TCROSS, + TOP_LEFT_ARROW, + TOP_LEFT_CORNER, + TOP_RIGHT_CORNER, + TOP_SIDE, + TOP_TEE, + TREK, + UL_ANGLE, + UMBRELLA, + UR_ANGLE, + WATCH, + XTERM, + LAST_CURSOR, + CURSOR_IS_PIXMAP, + } + [CCode (cprefix = "GDK_ACTION_")] + public enum DragAction { + DEFAULT, + COPY, + MOVE, + LINK, + PRIVATE, + ASK, + } + [CCode (cprefix = "GDK_DRAG_PROTO_")] + public enum DragProtocol { + MOTIF, + XDND, + ROOTWIN, + NONE, + WIN32_DROPFILES, + OLE2, + LOCAL, + } + [CCode (cprefix = "GDK_")] + public enum EventMask { + EXPOSURE_MASK, + POINTER_MOTION_MASK, + POINTER_MOTION_HINT_MASK, + BUTTON_MOTION_MASK, + BUTTON1_MOTION_MASK, + BUTTON2_MOTION_MASK, + BUTTON3_MOTION_MASK, + BUTTON_PRESS_MASK, + BUTTON_RELEASE_MASK, + KEY_PRESS_MASK, + KEY_RELEASE_MASK, + ENTER_NOTIFY_MASK, + LEAVE_NOTIFY_MASK, + FOCUS_CHANGE_MASK, + STRUCTURE_MASK, + PROPERTY_CHANGE_MASK, + VISIBILITY_NOTIFY_MASK, + PROXIMITY_IN_MASK, + PROXIMITY_OUT_MASK, + SUBSTRUCTURE_MASK, + SCROLL_MASK, + ALL_EVENTS_MASK, + } + [CCode (cprefix = "GDK_")] + public enum EventType { + NOTHING, + DELETE, + DESTROY, + EXPOSE, + MOTION_NOTIFY, + BUTTON_PRESS, + 2BUTTON_PRESS, + 3BUTTON_PRESS, + BUTTON_RELEASE, + KEY_PRESS, + KEY_RELEASE, + ENTER_NOTIFY, + LEAVE_NOTIFY, + FOCUS_CHANGE, + CONFIGURE, + MAP, + UNMAP, + PROPERTY_NOTIFY, + SELECTION_CLEAR, + SELECTION_REQUEST, + SELECTION_NOTIFY, + PROXIMITY_IN, + PROXIMITY_OUT, + DRAG_ENTER, + DRAG_LEAVE, + DRAG_MOTION, + DRAG_STATUS, + DROP_START, + DROP_FINISHED, + CLIENT_EVENT, + VISIBILITY_NOTIFY, + NO_EXPOSE, + SCROLL, + WINDOW_STATE, + SETTING, + OWNER_CHANGE, + GRAB_BROKEN, + } + [CCode (cprefix = "GDK_EXTENSION_EVENTS_")] + public enum ExtensionMode { + NONE, + ALL, + CURSOR, + } + [CCode (cprefix = "GDK_")] + public enum Fill { + SOLID, + TILED, + STIPPLED, + OPAQUE_STIPPLED, + } + [CCode (cprefix = "GDK_")] + public enum FillRule { + EVEN_ODD_RULE, + WINDING_RULE, + } + [CCode (cprefix = "GDK_FILTER_")] + public enum FilterReturn { + CONTINUE, + TRANSLATE, + REMOVE, + } + [CCode (cprefix = "GDK_FONT_")] + public enum FontType { + FONT, + FONTSET, + } + [CCode (cprefix = "GDK_")] + public enum Function { + COPY, + INVERT, + XOR, + CLEAR, + AND, + AND_REVERSE, + AND_INVERT, + NOOP, + OR, + EQUIV, + OR_REVERSE, + COPY_INVERT, + OR_INVERT, + NAND, + NOR, + SET, + } + [CCode (cprefix = "GDK_GC_")] + public enum GCValuesMask { + FOREGROUND, + BACKGROUND, + FONT, + FUNCTION, + FILL, + TILE, + STIPPLE, + CLIP_MASK, + SUBWINDOW, + TS_X_ORIGIN, + TS_Y_ORIGIN, + CLIP_X_ORIGIN, + CLIP_Y_ORIGIN, + EXPOSURES, + LINE_WIDTH, + LINE_STYLE, + CAP_STYLE, + JOIN_STYLE, + } + [CCode (cprefix = "GDK_GRAB_")] + public enum GrabStatus { + SUCCESS, + ALREADY_GRABBED, + INVALID_TIME, + NOT_VIEWABLE, + FROZEN, + } + [CCode (cprefix = "GDK_GRAVITY_")] + public enum Gravity { + NORTH_WEST, + NORTH, + NORTH_EAST, + WEST, + CENTER, + EAST, + SOUTH_WEST, + SOUTH, + SOUTH_EAST, + STATIC, + } + [CCode (cprefix = "GDK_IMAGE_")] + public enum ImageType { + NORMAL, + SHARED, + FASTEST, + } + [CCode (cprefix = "GDK_INPUT_")] + public enum InputCondition { + READ, + WRITE, + EXCEPTION, + } + [CCode (cprefix = "GDK_MODE_")] + public enum InputMode { + DISABLED, + SCREEN, + WINDOW, + } + [CCode (cprefix = "GDK_SOURCE_")] + public enum InputSource { + MOUSE, + PEN, + ERASER, + CURSOR, + } + [CCode (cprefix = "GDK_INTERP_")] + public enum InterpType { + NEAREST, + TILES, + BILINEAR, + HYPER, + } + [CCode (cprefix = "GDK_JOIN_")] + public enum JoinStyle { + MITER, + ROUND, + BEVEL, + } + [CCode (cprefix = "GDK_LINE_")] + public enum LineStyle { + SOLID, + ON_OFF_DASH, + DOUBLE_DASH, + } + [CCode (cprefix = "GDK_")] + public enum ModifierType { + SHIFT_MASK, + LOCK_MASK, + CONTROL_MASK, + MOD1_MASK, + MOD2_MASK, + MOD3_MASK, + MOD4_MASK, + MOD5_MASK, + BUTTON1_MASK, + BUTTON2_MASK, + BUTTON3_MASK, + BUTTON4_MASK, + BUTTON5_MASK, + SUPER_MASK, + HYPER_MASK, + META_MASK, + RELEASE_MASK, + MODIFIER_MASK, + } + [CCode (cprefix = "GDK_NOTIFY_")] + public enum NotifyType { + ANCESTOR, + VIRTUAL, + INFERIOR, + NONLINEAR, + NONLINEAR_VIRTUAL, + UNKNOWN, + } + [CCode (cprefix = "GDK_OVERLAP_RECTANGLE_")] + public enum OverlapType { + IN, + OUT, + PART, + } + [CCode (cprefix = "GDK_OWNER_CHANGE_")] + public enum OwnerChange { + NEW_OWNER, + DESTROY, + CLOSE, + } + [CCode (cprefix = "GDK_PIXBUF_ALPHA_")] + public enum PixbufAlphaMode { + BILEVEL, + FULL, + } + [CCode (cprefix = "GDK_PIXBUF_ERROR_")] + public enum PixbufError { + CORRUPT_IMAGE, + INSUFFICIENT_MEMORY, + BAD_OPTION, + UNKNOWN_TYPE, + UNSUPPORTED_OPERATION, + FAILED, + } + [CCode (cprefix = "GDK_PIXBUF_FRAME_")] + public enum PixbufFrameAction { + RETAIN, + DISPOSE, + REVERT, + } + [CCode (cprefix = "GDK_PIXBUF_ROTATE_")] + public enum PixbufRotation { + NONE, + COUNTERCLOCKWISE, + UPSIDEDOWN, + CLOCKWISE, + } + [CCode (cprefix = "GDK_PIXDATA_DUMP_")] + public enum PixdataDumpType { + PIXDATA_STREAM, + PIXDATA_STRUCT, + MACROS, + GTYPES, + CTYPES, + STATIC, + CONST, + RLE_DECODER, + } + [CCode (cprefix = "GDK_PIXDATA_")] + public enum PixdataType { + COLOR_TYPE_RGB, + COLOR_TYPE_RGBA, + COLOR_TYPE_MASK, + SAMPLE_WIDTH_8, + SAMPLE_WIDTH_MASK, + ENCODING_RAW, + ENCODING_RLE, + ENCODING_MASK, + } + [CCode (cprefix = "GDK_PROP_MODE_")] + public enum PropMode { + REPLACE, + PREPEND, + APPEND, + } + [CCode (cprefix = "GDK_PROPERTY_")] + public enum PropertyState { + NEW_VALUE, + DELETE, + } + [CCode (cprefix = "GDK_RGB_DITHER_")] + public enum RgbDither { + NONE, + NORMAL, + MAX, + } + [CCode (cprefix = "GDK_SCROLL_")] + public enum ScrollDirection { + UP, + DOWN, + LEFT, + RIGHT, + } + [CCode (cprefix = "GDK_SETTING_ACTION_")] + public enum SettingAction { + NEW, + CHANGED, + DELETED, + } + [CCode (cprefix = "GDK_")] + public enum Status { + OK, + ERROR, + ERROR_PARAM, + ERROR_FILE, + ERROR_MEM, + } + [CCode (cprefix = "GDK_")] + public enum SubwindowMode { + CLIP_BY_CHILDREN, + INCLUDE_INFERIORS, + } + [CCode (cprefix = "GDK_VISIBILITY_")] + public enum VisibilityState { + UNOBSCURED, + PARTIAL, + FULLY_OBSCURED, + } + [CCode (cprefix = "GDK_VISUAL_")] + public enum VisualType { + STATIC_GRAY, + GRAYSCALE, + STATIC_COLOR, + PSEUDO_COLOR, + TRUE_COLOR, + DIRECT_COLOR, + } + [CCode (cprefix = "GDK_DECOR_")] + public enum WMDecoration { + ALL, + BORDER, + RESIZEH, + TITLE, + MENU, + MINIMIZE, + MAXIMIZE, + } + [CCode (cprefix = "GDK_FUNC_")] + public enum WMFunction { + ALL, + RESIZE, + MOVE, + MINIMIZE, + MAXIMIZE, + CLOSE, + } + [CCode (cprefix = "GDK_WA_")] + public enum WindowAttributesType { + TITLE, + X, + Y, + CURSOR, + COLORMAP, + VISUAL, + WMCLASS, + NOREDIR, + } + [CCode (cprefix = "GDK_INPUT_")] + public enum WindowClass { + OUTPUT, + ONLY, + } + [CCode (cprefix = "GDK_WINDOW_EDGE_")] + public enum WindowEdge { + NORTH_WEST, + NORTH, + NORTH_EAST, + WEST, + EAST, + SOUTH_WEST, + SOUTH, + SOUTH_EAST, + } + [CCode (cprefix = "GDK_HINT_")] + public enum WindowHints { + POS, + MIN_SIZE, + MAX_SIZE, + BASE_SIZE, + ASPECT, + RESIZE_INC, + WIN_GRAVITY, + USER_POS, + USER_SIZE, + } + [CCode (cprefix = "GDK_WINDOW_STATE_")] + public enum WindowState { + WITHDRAWN, + ICONIFIED, + MAXIMIZED, + STICKY, + FULLSCREEN, + ABOVE, + BELOW, + } + [CCode (cprefix = "GDK_WINDOW_")] + public enum WindowType { + ROOT, + TOPLEVEL, + CHILD, + DIALOG, + TEMP, + FOREIGN, + } + [CCode (cprefix = "GDK_WINDOW_TYPE_HINT_")] + public enum WindowTypeHint { + NORMAL, + DIALOG, + MENU, + TOOLBAR, + SPLASHSCREEN, + UTILITY, + DOCK, + DESKTOP, + DROPDOWN_MENU, + POPUP_MENU, + TOOLTIP, + NOTIFICATION, + COMBO, + DND, + } + public callback void DestroyNotify (pointer data); + public callback void EventFunc (Gdk.Event event, pointer data); + public callback Gdk.FilterReturn FilterFunc (pointer xevent, Gdk.Event event, pointer data); + public callback void InputFunction (pointer data, int source, Gdk.InputCondition condition); + public callback void PixbufDestroyNotify (uchar pixels, pointer data); + public callback bool PixbufSaveFunc (string buf, ulong count, GLib.Error error, pointer data); + public callback void SpanFunc (Gdk.Span span, pointer data); + public callback bool invalidate_maybe_recurseChildFunc (Gdk.Window arg1, pointer data); +} diff --git a/vala/vapi/glib-2.0.vala b/vala/vapi/glib-2.0.vala index 9c187338c..10f0f6648 100644 --- a/vala/vapi/glib-2.0.vala +++ b/vala/vapi/glib-2.0.vala @@ -219,11 +219,44 @@ namespace GLib { public Object get_object (); } + public struct SignalInvocationHint { + public uint signal_id; + public Quark detail; + public SignalFlags run_type; + } + + public callback bool SignalEmissionHook (SignalInvocationHint ihint, uint n_param_values, Value[] param_values, pointer data); + + [CCode (cprefix = "G_SIGNAL_")] + public enum SignalFlags { + RUN_FIRST, + RUN_LAST, + RUN_CLEANUP, + DETAILED, + ACTION, + NO_HOOKS + } + public callback void Callback (); public struct Closure { } + public struct ValueArray { + } + + [CCode (cheader_filename = "math.h")] + public struct Math { + [CCode (cname = "sqrt")] + public static double sqrt (double v); + + [CCode (cname = "G_E")] + public static double E; + + [CCode (cname = "G_PI")] + public static double PI; + } + [ReferenceType (dup_function = "g_main_loop_ref", free_function = "g_main_loop_unref")] public struct MainLoop { public construct (MainContext context, bool is_running); @@ -245,6 +278,10 @@ namespace GLib { public bool is_owner (); } + public struct Timeout { + public static uint add (uint interval, SourceFunc function, pointer data); + } + [ReferenceType ()] public struct IdleSource { public construct (); @@ -632,6 +669,10 @@ namespace GLib { public long allocated_len; } + [ReferenceType (free_function = "g_ptr_array_free")] + public struct PtrArray { + } + public struct Quark { public static Quark from_string (string string); public string to_string (); diff --git a/vala/vapi/gtk+-2.0.vala b/vala/vapi/gtk+-2.0.vala index 2c3849267..f9d205ef3 100644 --- a/vala/vapi/gtk+-2.0.vala +++ b/vala/vapi/gtk+-2.0.vala @@ -1,248 +1,5756 @@ -/* gtk+-2.0.vala - * - * Copyright (C) 2006 Jürg Billeter - * - * This library 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 of the License, or (at your option) any later version. - - * This library 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 this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Author: - * Jürg Billeter - */ - [CCode (cheader_filename = "gtk/gtk.h")] namespace Gtk { - public static void init (ref int argc, out string[] argv); - public static void main (); - public static void main_quit (); - - // FIXME: that's not an enum, replace by constants - public enum Stock { - REFRESH + public class AboutDialog : Gtk.Dialog { + public string get_artists (); + public string get_authors (); + public string get_comments (); + public string get_copyright (); + public string get_documenters (); + public string get_license (); + public Gdk.Pixbuf get_logo (); + public string get_logo_icon_name (); + public string get_name (); + public string get_translator_credits (); + public GLib.Type get_type (); + public string get_version (); + public string get_website (); + public string get_website_label (); + public bool get_wrap_license (); + public construct (); + public void set_artists (string artists); + public void set_authors (string authors); + public void set_comments (string comments); + public void set_copyright (string copyright); + public void set_documenters (string documenters); + public static Gtk.AboutDialogActivateLinkFunc set_email_hook (Gtk.AboutDialogActivateLinkFunc func, pointer data, GLib.DestroyNotify destroy); + public void set_license (string license); + public void set_logo (Gdk.Pixbuf logo); + public void set_logo_icon_name (string icon_name); + public void set_name (string name); + public void set_translator_credits (string translator_credits); + public static Gtk.AboutDialogActivateLinkFunc set_url_hook (Gtk.AboutDialogActivateLinkFunc func, pointer data, GLib.DestroyNotify destroy); + public void set_version (string version); + public void set_website (string website); + public void set_website_label (string website_label); + public void set_wrap_license (bool wrap_license); + public weak string name { get; set; } + public weak string version { get; set; } + public weak string copyright { get; set; } + public weak string comments { get; set; } + public weak string license { get; set; } + public weak string website { get; set; } + public weak string website_label { get; set; } + public weak string[] authors { get; set; } + public weak string[] documenters { get; set; } + public weak string[] artists { get; set; } + public weak string translator_credits { get; set; } + public weak Gdk.Pixbuf logo { get; set; } + public weak string logo_icon_name { get; set; } + public weak bool wrap_license { get; set; } + } + public class AccelGroup : GLib.Object { + public bool activate (GLib.Quark accel_quark, GLib.Object acceleratable, uint accel_key, Gdk.ModifierType accel_mods); + public void connect (uint accel_key, Gdk.ModifierType accel_mods, Gtk.AccelFlags accel_flags, GLib.Closure closure); + public void connect_by_path (string accel_path, GLib.Closure closure); + public bool disconnect (GLib.Closure closure); + public bool disconnect_key (uint accel_key, Gdk.ModifierType accel_mods); + public Gtk.AccelKey find (Gtk.AccelGroupFindFunc find_func, pointer data); + public static Gtk.AccelGroup from_accel_closure (GLib.Closure closure); + public GLib.Type get_type (); + public void lock (); + public construct (); + public Gtk.AccelGroupEntry query (uint accel_key, Gdk.ModifierType accel_mods, uint n_entries); + public void unlock (); + public signal bool accel_activate (GLib.Object p0, uint p1, Gdk.ModifierType p2); + public signal void accel_changed (uint keyval, Gdk.ModifierType modifier, GLib.Closure accel_closure); + } + public class AccelLabel : Gtk.Label { + public Gtk.Widget get_accel_widget (); + public uint get_accel_width (); + public GLib.Type get_type (); + public construct (string string); + public bool refetch (); + public void set_accel_closure (GLib.Closure accel_closure); + public void set_accel_widget (Gtk.Widget accel_widget); + [NoAccessorMethod ()] + public weak GLib.Closure accel_closure { get; set; } + public weak Gtk.Widget accel_widget { get; set; } + } + public class AccelMap : GLib.Object { + public static void add_entry (string accel_path, uint accel_key, Gdk.ModifierType accel_mods); + public static void add_filter (string filter_pattern); + public static bool change_entry (string accel_path, uint accel_key, Gdk.ModifierType accel_mods, bool replace); + public static void @foreach (pointer data, Gtk.AccelMapForeach foreach_func); + public static void foreach_unfiltered (pointer data, Gtk.AccelMapForeach foreach_func); + public Gtk.AccelMap @get (); + public GLib.Type get_type (); + public static void load (string file_name); + public static void load_fd (int fd); + public static void load_scanner (GLib.Scanner scanner); + public static void lock_path (string accel_path); + public static bool lookup_entry (string accel_path, Gtk.AccelKey key); + public static void save (string file_name); + public static void save_fd (int fd); + public static void unlock_path (string accel_path); + public signal void changed (string p0, uint p1, Gdk.ModifierType p2); + } + public class Accessible : Atk.Object { + public void connect_widget_destroyed (); + public GLib.Type get_type (); + } + public class Action : GLib.Object { + public void block_activate_from (Gtk.Widget proxy); + public void connect_accelerator (); + public void connect_proxy (Gtk.Widget proxy); + public Gtk.Widget create_icon (Gtk.IconSize icon_size); + public Gtk.Widget create_menu_item (); + public Gtk.Widget create_tool_item (); + public void disconnect_accelerator (); + public void disconnect_proxy (Gtk.Widget proxy); + public GLib.Closure get_accel_closure (); + public string get_accel_path (); + public string get_name (); + public GLib.SList get_proxies (); + public bool get_sensitive (); + public GLib.Type get_type (); + public bool get_visible (); + public bool is_sensitive (); + public bool is_visible (); + public construct (string name, string label, string tooltip, string stock_id); + public void set_accel_group (Gtk.AccelGroup accel_group); + public void set_accel_path (string accel_path); + public void set_sensitive (bool sensitive); + public void set_visible (bool visible); + public void unblock_activate_from (Gtk.Widget proxy); + [NoAccessorMethod ()] + public weak string name { get; construct; } + [NoAccessorMethod ()] + public weak string label { get; set; } + [NoAccessorMethod ()] + public weak string short_label { get; set; } + [NoAccessorMethod ()] + public weak string tooltip { get; set; } + [NoAccessorMethod ()] + public weak string stock_id { get; set; } + [NoAccessorMethod ()] + public weak string icon_name { get; set; } + [NoAccessorMethod ()] + public weak bool visible_horizontal { get; set; } + [NoAccessorMethod ()] + public weak bool visible_overflown { get; set; } + [NoAccessorMethod ()] + public weak bool visible_vertical { get; set; } + [NoAccessorMethod ()] + public weak bool is_important { get; set; } + [NoAccessorMethod ()] + public weak bool hide_if_empty { get; set; } + public weak bool sensitive { get; set; } + public weak bool visible { get; set; } + [NoAccessorMethod ()] + public weak Gtk.ActionGroup action_group { get; set; } + [HasEmitter ()] + public signal void activate (); + } + public class ActionGroup : GLib.Object { + public void add_action (Gtk.Action action); + public void add_action_with_accel (Gtk.Action action, string accelerator); + public void add_actions (Gtk.ActionEntry entries, uint n_entries, pointer user_data); + public void add_actions_full (Gtk.ActionEntry entries, uint n_entries, pointer user_data, GLib.DestroyNotify destroy); + public void add_radio_actions (Gtk.RadioActionEntry entries, uint n_entries, int value, GLib.Callback on_change, pointer user_data); + public void add_radio_actions_full (Gtk.RadioActionEntry entries, uint n_entries, int value, GLib.Callback on_change, pointer user_data, GLib.DestroyNotify destroy); + public void add_toggle_actions (Gtk.ToggleActionEntry entries, uint n_entries, pointer user_data); + public void add_toggle_actions_full (Gtk.ToggleActionEntry entries, uint n_entries, pointer user_data, GLib.DestroyNotify destroy); + public Gtk.Action get_action (string action_name); + public string get_name (); + public bool get_sensitive (); + public GLib.Type get_type (); + public bool get_visible (); + public GLib.List list_actions (); + public construct (string name); + public void remove_action (Gtk.Action action); + public void set_sensitive (bool sensitive); + public void set_translate_func (Gtk.TranslateFunc func, pointer data, Gtk.DestroyNotify notify); + public void set_translation_domain (string domain); + public void set_visible (bool visible); + public string translate_string (string string); + [NoAccessorMethod ()] + public weak string name { get; construct; } + public weak bool sensitive { get; set; } + public weak bool visible { get; set; } + public signal void connect_proxy (Gtk.Action p0, Gtk.Widget p1); + public signal void disconnect_proxy (Gtk.Action p0, Gtk.Widget p1); + public signal void pre_activate (Gtk.Action p0); + public signal void post_activate (Gtk.Action p0); + } + public class Adjustment : Gtk.Object { + public void clamp_page (double lower, double upper); + public GLib.Type get_type (); + public double get_value (); + public construct (double value, double lower, double upper, double step_increment, double page_increment, double page_size); + public void set_value (double value); + public weak double value { get; set; } + [NoAccessorMethod ()] + public weak double lower { get; set; } + [NoAccessorMethod ()] + public weak double upper { get; set; } + [NoAccessorMethod ()] + public weak double step_increment { get; set; } + [NoAccessorMethod ()] + public weak double page_increment { get; set; } + [NoAccessorMethod ()] + public weak double page_size { get; set; } + [HasEmitter ()] + public signal void changed (); + [HasEmitter ()] + public signal void value_changed (); + } + public class Alignment : Gtk.Bin { + public void get_padding (uint padding_top, uint padding_bottom, uint padding_left, uint padding_right); + public GLib.Type get_type (); + public construct (float xalign, float yalign, float xscale, float yscale); + public void @set (float xalign, float yalign, float xscale, float yscale); + public void set_padding (uint padding_top, uint padding_bottom, uint padding_left, uint padding_right); + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak float yalign { get; set; } + [NoAccessorMethod ()] + public weak float xscale { get; set; } + [NoAccessorMethod ()] + public weak float yscale { get; set; } + [NoAccessorMethod ()] + public weak uint top_padding { get; set; } + [NoAccessorMethod ()] + public weak uint bottom_padding { get; set; } + [NoAccessorMethod ()] + public weak uint left_padding { get; set; } + [NoAccessorMethod ()] + public weak uint right_padding { get; set; } + } + public class Arrow : Gtk.Misc { + public GLib.Type get_type (); + public construct (Gtk.ArrowType arrow_type, Gtk.ShadowType shadow_type); + public void @set (Gtk.ArrowType arrow_type, Gtk.ShadowType shadow_type); + [NoAccessorMethod ()] + public weak Gtk.ArrowType arrow_type { get; set; } + [NoAccessorMethod ()] + public weak Gtk.ShadowType shadow_type { get; set; } + } + public class AspectFrame : Gtk.Frame { + public GLib.Type get_type (); + public construct (string label, float xalign, float yalign, float ratio, bool obey_child); + public void @set (float xalign, float yalign, float ratio, bool obey_child); + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak float yalign { get; set; } + [NoAccessorMethod ()] + public weak float ratio { get; set; } + [NoAccessorMethod ()] + public weak bool obey_child { get; set; } + } + public class Assistant : Gtk.Window { + public void add_action_widget (Gtk.Widget child); + public int append_page (Gtk.Widget page); + public int get_current_page (); + public int get_n_pages (); + public Gtk.Widget get_nth_page (int page_num); + public bool get_page_complete (Gtk.Widget page); + public Gdk.Pixbuf get_page_header_image (Gtk.Widget page); + public Gdk.Pixbuf get_page_side_image (Gtk.Widget page); + public string get_page_title (Gtk.Widget page); + public Gtk.AssistantPageType get_page_type (Gtk.Widget page); + public GLib.Type get_type (); + public int insert_page (Gtk.Widget page, int position); + public construct (); + public int prepend_page (Gtk.Widget page); + public void remove_action_widget (Gtk.Widget child); + public void set_current_page (int page_num); + public void set_forward_page_func (Gtk.AssistantPageFunc page_func, pointer data, GLib.DestroyNotify destroy); + public void set_page_complete (Gtk.Widget page, bool complete); + public void set_page_header_image (Gtk.Widget page, Gdk.Pixbuf pixbuf); + public void set_page_side_image (Gtk.Widget page, Gdk.Pixbuf pixbuf); + public void set_page_title (Gtk.Widget page, string title); + public void set_page_type (Gtk.Widget page, Gtk.AssistantPageType type); + public void update_buttons_state (); + public signal void cancel (); + public signal void prepare (Gtk.Widget page); + public signal void apply (); + public signal void close (); + } + public class Bin : Gtk.Container { + public Gtk.Widget get_child (); + public GLib.Type get_type (); + } + public class Box : Gtk.Container { + public weak GLib.List children; + public bool get_homogeneous (); + public int get_spacing (); + public GLib.Type get_type (); + public void pack_end (Gtk.Widget child, bool expand, bool fill, uint padding); + public void pack_end_defaults (Gtk.Widget widget); + public void pack_start (Gtk.Widget child, bool expand, bool fill, uint padding); + public void pack_start_defaults (Gtk.Widget widget); + public void query_child_packing (Gtk.Widget child, bool expand, bool fill, uint padding, Gtk.PackType pack_type); + public void reorder_child (Gtk.Widget child, int position); + public void set_child_packing (Gtk.Widget child, bool expand, bool fill, uint padding, Gtk.PackType pack_type); + public void set_homogeneous (bool homogeneous); + public void set_spacing (int spacing); + public weak int spacing { get; set; } + public weak bool homogeneous { get; set; } + } + public class Button : Gtk.Bin { + public GLib.Type action_get_type (); + public void get_alignment (float xalign, float yalign); + public bool get_focus_on_click (); + public Gtk.Widget get_image (); + public Gtk.PositionType get_image_position (); + public string get_label (); + public Gtk.ReliefStyle get_relief (); + public GLib.Type get_type (); + public bool get_use_stock (); + public bool get_use_underline (); + public construct (); + public construct from_stock (string stock_id); + public construct with_label (string label); + public construct with_mnemonic (string label); + public void set_alignment (float xalign, float yalign); + public void set_focus_on_click (bool focus_on_click); + public void set_image (Gtk.Widget image); + public void set_image_position (Gtk.PositionType position); + public void set_label (string label); + public void set_relief (Gtk.ReliefStyle newstyle); + public void set_use_stock (bool use_stock); + public void set_use_underline (bool use_underline); + public weak string label { get; set construct; } + public weak bool use_underline { get; set construct; } + public weak bool use_stock { get; set construct; } + public weak bool focus_on_click { get; set; } + public weak Gtk.ReliefStyle relief { get; set; } + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak float yalign { get; set; } + public weak Gtk.Widget image { get; set; } + public weak Gtk.PositionType image_position { get; set; } + [HasEmitter ()] + public signal void pressed (); + [HasEmitter ()] + public signal void released (); + [HasEmitter ()] + public signal void clicked (); + [HasEmitter ()] + public signal void enter (); + [HasEmitter ()] + public signal void leave (); + public signal void activate (); + } + public class ButtonBox : Gtk.Box { + public bool get_child_secondary (Gtk.Widget child); + public Gtk.ButtonBoxStyle get_layout (); + public GLib.Type get_type (); + public void set_child_secondary (Gtk.Widget child, bool is_secondary); + public void set_layout (Gtk.ButtonBoxStyle layout_style); + [NoAccessorMethod ()] + public weak Gtk.ButtonBoxStyle layout_style { get; set; } + } + public class Calendar : Gtk.Widget { + public void clear_marks (); + public void get_date (uint year, uint month, uint day); + public Gtk.CalendarDisplayOptions get_display_options (); + public GLib.Type get_type (); + public bool mark_day (uint day); + public construct (); + public void select_day (uint day); + public bool select_month (uint month, uint year); + public void set_display_options (Gtk.CalendarDisplayOptions @flags); + public bool unmark_day (uint day); + [NoAccessorMethod ()] + public weak int year { get; set; } + [NoAccessorMethod ()] + public weak int month { get; set; } + [NoAccessorMethod ()] + public weak int day { get; set; } + [NoAccessorMethod ()] + public weak bool show_heading { get; set; } + [NoAccessorMethod ()] + public weak bool show_day_names { get; set; } + [NoAccessorMethod ()] + public weak bool no_month_change { get; set; } + [NoAccessorMethod ()] + public weak bool show_week_numbers { get; set; } + public signal void month_changed (); + public signal void day_selected (); + public signal void day_selected_double_click (); + public signal void prev_month (); + public signal void next_month (); + public signal void prev_year (); + public signal void next_year (); + } + public class CellRenderer : Gtk.Object { + public bool activate (Gdk.Event event, Gtk.Widget widget, string path, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState @flags); + public void get_fixed_size (int width, int height); + public void get_size (Gtk.Widget widget, Gdk.Rectangle cell_area, int x_offset, int y_offset, int width, int height); + public GLib.Type get_type (); + public void render (Gdk.Window window, Gtk.Widget widget, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gdk.Rectangle expose_area, Gtk.CellRendererState @flags); + public void set_fixed_size (int width, int height); + public Gtk.CellEditable start_editing (Gdk.Event event, Gtk.Widget widget, string path, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.CellRendererState @flags); + public void stop_editing (bool canceled); + [NoAccessorMethod ()] + public weak Gtk.CellRendererMode mode { get; set; } + [NoAccessorMethod ()] + public weak bool visible { get; set; } + [NoAccessorMethod ()] + public weak bool sensitive { get; set; } + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak float yalign { get; set; } + [NoAccessorMethod ()] + public weak uint xpad { get; set; } + [NoAccessorMethod ()] + public weak uint ypad { get; set; } + [NoAccessorMethod ()] + public weak int width { get; set; } + [NoAccessorMethod ()] + public weak int height { get; set; } + [NoAccessorMethod ()] + public weak bool is_expander { get; set; } + [NoAccessorMethod ()] + public weak bool is_expanded { get; set; } + [NoAccessorMethod ()] + public weak string cell_background { set; } + [NoAccessorMethod ()] + public weak Gdk.Color cell_background_gdk { get; set; } + public signal void editing_canceled (); + public signal void editing_started (Gtk.CellEditable editable, string path); + } + public class CellRendererAccel : Gtk.CellRendererText { + public GLib.Type get_type (); + public construct (); + [NoAccessorMethod ()] + public weak uint accel_key { get; set; } + [NoAccessorMethod ()] + public weak Gdk.ModifierType accel_mods { get; set; } + [NoAccessorMethod ()] + public weak uint keycode { get; set; } + [NoAccessorMethod ()] + public weak Gtk.CellRendererAccelMode accel_mode { get; set; } + public signal void accel_edited (string path_string, uint accel_key, Gdk.ModifierType accel_mods, uint hardware_keycode); + public signal void accel_cleared (string path_string); + } + public class CellRendererCombo : Gtk.CellRendererText { + public GLib.Type get_type (); + public construct (); + [NoAccessorMethod ()] + public weak Gtk.TreeModel model { get; set; } + [NoAccessorMethod ()] + public weak int text_column { get; set; } + [NoAccessorMethod ()] + public weak bool has_entry { get; set; } + } + public class CellRendererPixbuf : Gtk.CellRenderer { + public GLib.Type get_type (); + public construct (); + [NoAccessorMethod ()] + public weak Gdk.Pixbuf pixbuf { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixbuf pixbuf_expander_open { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixbuf pixbuf_expander_closed { get; set; } + [NoAccessorMethod ()] + public weak string stock_id { get; set; } + [NoAccessorMethod ()] + public weak uint stock_size { get; set; } + [NoAccessorMethod ()] + public weak string stock_detail { get; set; } + [NoAccessorMethod ()] + public weak string icon_name { get; set; } + [NoAccessorMethod ()] + public weak bool follow_state { get; set; } + } + public class CellRendererProgress : Gtk.CellRenderer { + public GLib.Type get_type (); + public construct (); + [NoAccessorMethod ()] + public weak int value { get; set; } + [NoAccessorMethod ()] + public weak string text { get; set; } + } + public class CellRendererSpin : Gtk.CellRendererText { + public GLib.Type get_type (); + public construct (); + [NoAccessorMethod ()] + public weak Gtk.Adjustment adjustment { get; set; } + [NoAccessorMethod ()] + public weak double climb_rate { get; set; } + [NoAccessorMethod ()] + public weak uint digits { get; set; } + } + public class CellRendererText : Gtk.CellRenderer { + public GLib.Type get_type (); + public construct (); + public void set_fixed_height_from_font (int number_of_rows); + [NoAccessorMethod ()] + public weak string text { get; set; } + [NoAccessorMethod ()] + public weak string markup { set; } + [NoAccessorMethod ()] + public weak Pango.AttrList attributes { get; set; } + [NoAccessorMethod ()] + public weak bool single_paragraph_mode { get; set; } + [NoAccessorMethod ()] + public weak string background { set; } + [NoAccessorMethod ()] + public weak Gdk.Color background_gdk { get; set; } + [NoAccessorMethod ()] + public weak string foreground { set; } + [NoAccessorMethod ()] + public weak Gdk.Color foreground_gdk { get; set; } + [NoAccessorMethod ()] + public weak bool editable { get; set; } + [NoAccessorMethod ()] + public weak string font { get; set; } + [NoAccessorMethod ()] + public weak Pango.FontDescription font_desc { get; set; } + [NoAccessorMethod ()] + public weak string family { get; set; } + [NoAccessorMethod ()] + public weak Pango.Style style { get; set; } + [NoAccessorMethod ()] + public weak Pango.Variant variant { get; set; } + [NoAccessorMethod ()] + public weak int weight { get; set; } + [NoAccessorMethod ()] + public weak Pango.Stretch stretch { get; set; } + [NoAccessorMethod ()] + public weak int size { get; set; } + [NoAccessorMethod ()] + public weak double size_points { get; set; } + [NoAccessorMethod ()] + public weak double scale { get; set; } + [NoAccessorMethod ()] + public weak int rise { get; set; } + [NoAccessorMethod ()] + public weak bool strikethrough { get; set; } + [NoAccessorMethod ()] + public weak Pango.Underline underline { get; set; } + [NoAccessorMethod ()] + public weak string language { get; set; } + [NoAccessorMethod ()] + public weak Pango.EllipsizeMode ellipsize { get; set; } + [NoAccessorMethod ()] + public weak int width_chars { get; set; } + [NoAccessorMethod ()] + public weak Pango.WrapMode wrap_mode { get; set; } + [NoAccessorMethod ()] + public weak int wrap_width { get; set; } + [NoAccessorMethod ()] + public weak Pango.Alignment alignment { get; set; } + public signal void edited (string path, string new_text); + } + public class CellRendererToggle : Gtk.CellRenderer { + public bool get_active (); + public bool get_radio (); + public GLib.Type get_type (); + public construct (); + public void set_active (bool setting); + public void set_radio (bool radio); + public weak bool active { get; set; } + [NoAccessorMethod ()] + public weak bool inconsistent { get; set; } + [NoAccessorMethod ()] + public weak bool activatable { get; set; } + public weak bool radio { get; set; } + [NoAccessorMethod ()] + public weak int indicator_size { get; set; } + public signal void toggled (string path); + } + public class CellView : Gtk.Widget, Gtk.CellLayout { + public GLib.List get_cell_renderers (); + public Gtk.TreePath get_displayed_row (); + public bool get_size_of_row (Gtk.TreePath path, Gtk.Requisition requisition); + public GLib.Type get_type (); + public construct (); + public construct with_markup (string markup); + public construct with_pixbuf (Gdk.Pixbuf pixbuf); + public construct with_text (string text); + public void set_background_color (Gdk.Color color); + public void set_displayed_row (Gtk.TreePath path); + public void set_model (Gtk.TreeModel model); + [NoAccessorMethod ()] + public weak string background { set; } + [NoAccessorMethod ()] + public weak Gdk.Color background_gdk { get; set; } + [NoAccessorMethod ()] + public weak Gtk.TreeModel model { get; set; } + } + public class CheckButton : Gtk.ToggleButton { + public GLib.Type get_type (); + public construct (); + public construct with_label (string label); + public construct with_mnemonic (string label); + } + public class CheckMenuItem : Gtk.MenuItem { + public bool get_active (); + public bool get_draw_as_radio (); + public bool get_inconsistent (); + public GLib.Type get_type (); + public construct (); + public construct with_label (string label); + public construct with_mnemonic (string label); + public void set_active (bool is_active); + public void set_draw_as_radio (bool draw_as_radio); + public void set_inconsistent (bool setting); + public weak bool active { get; set; } + public weak bool inconsistent { get; set; } + public weak bool draw_as_radio { get; set; } + [HasEmitter ()] + public signal void toggled (); + } + public class Clipboard : GLib.Object { + public void clear (); + public static Gtk.Clipboard @get (Gdk.Atom selection); + public Gdk.Display get_display (); + public static Gtk.Clipboard get_for_display (Gdk.Display display, Gdk.Atom selection); + public GLib.Object get_owner (); + public GLib.Type get_type (); + public void request_contents (Gdk.Atom target, Gtk.ClipboardReceivedFunc @callback, pointer user_data); + public void request_image (Gtk.ClipboardImageReceivedFunc @callback, pointer user_data); + public void request_rich_text (Gtk.TextBuffer buffer, Gtk.ClipboardRichTextReceivedFunc @callback, pointer user_data); + public void request_targets (Gtk.ClipboardTargetsReceivedFunc @callback, pointer user_data); + public void request_text (Gtk.ClipboardTextReceivedFunc @callback, pointer user_data); + public void set_can_store (Gtk.TargetEntry targets, int n_targets); + public void set_image (Gdk.Pixbuf pixbuf); + public void set_text (string text, int len); + public bool set_with_data (Gtk.TargetEntry targets, uint n_targets, Gtk.ClipboardGetFunc get_func, Gtk.ClipboardClearFunc clear_func, pointer user_data); + public bool set_with_owner (Gtk.TargetEntry targets, uint n_targets, Gtk.ClipboardGetFunc get_func, Gtk.ClipboardClearFunc clear_func, GLib.Object owner); + public void store (); + public Gtk.SelectionData wait_for_contents (Gdk.Atom target); + public Gdk.Pixbuf wait_for_image (); + public uchar wait_for_rich_text (Gtk.TextBuffer buffer, Gdk.Atom format, ulong length); + public bool wait_for_targets (Gdk.Atom targets, int n_targets); + public string wait_for_text (); + public bool wait_is_image_available (); + public bool wait_is_rich_text_available (Gtk.TextBuffer buffer); + public bool wait_is_target_available (Gdk.Atom target); + public bool wait_is_text_available (); + public signal void owner_change (Gdk.EventOwnerChange event); + } + public class ColorButton : Gtk.Button { + public ushort get_alpha (); + public void get_color (Gdk.Color color); + public string get_title (); + public GLib.Type get_type (); + public bool get_use_alpha (); + public construct (); + public construct with_color (Gdk.Color color); + public void set_alpha (ushort alpha); + public void set_color (Gdk.Color color); + public void set_title (string title); + public void set_use_alpha (bool use_alpha); + public weak bool use_alpha { get; set; } + public weak string title { get; set; } + public weak Gdk.Color color { get; set; } + public weak uint alpha { get; set; } + public signal void color_set (); + } + public class ColorSelection : Gtk.VBox { + public ushort get_current_alpha (); + public void get_current_color (Gdk.Color color); + public bool get_has_opacity_control (); + public bool get_has_palette (); + public ushort get_previous_alpha (); + public void get_previous_color (Gdk.Color color); + public GLib.Type get_type (); + public bool is_adjusting (); + public construct (); + public static bool palette_from_string (string str, Gdk.Color colors, int n_colors); + public static string palette_to_string (Gdk.Color colors, int n_colors); + public static Gtk.ColorSelectionChangePaletteWithScreenFunc set_change_palette_with_screen_hook (Gtk.ColorSelectionChangePaletteWithScreenFunc func); + public void set_current_alpha (ushort alpha); + public void set_current_color (Gdk.Color color); + public void set_has_opacity_control (bool has_opacity); + public void set_has_palette (bool has_palette); + public void set_previous_alpha (ushort alpha); + public void set_previous_color (Gdk.Color color); + public weak bool has_opacity_control { get; set; } + public weak bool has_palette { get; set; } + public weak Gdk.Color current_color { get; set; } + public weak uint current_alpha { get; set; } + public signal void color_changed (); + } + public class ColorSelectionDialog : Gtk.Dialog { + public GLib.Type get_type (); + public construct (string title); + } + public class Combo : Gtk.HBox { + public weak Gtk.Widget entry; + public weak Gtk.Widget list; + [NoAccessorMethod ()] + public weak bool enable_arrow_keys { get; set; } + [NoAccessorMethod ()] + public weak bool enable_arrows_always { get; set; } + [NoAccessorMethod ()] + public weak bool case_sensitive { get; set; } + [NoAccessorMethod ()] + public weak bool allow_empty { get; set; } + [NoAccessorMethod ()] + public weak bool value_in_list { get; set; } + } + public class ComboBox : Gtk.Bin, Gtk.CellLayout, Gtk.CellEditable { + public void append_text (string text); + public int get_active (); + public bool get_active_iter (Gtk.TreeIter iter); + public string get_active_text (); + public bool get_add_tearoffs (); + public int get_column_span_column (); + public bool get_focus_on_click (); + public Gtk.TreeModel get_model (); + public Atk.Object get_popup_accessible (); + public Gtk.TreeViewRowSeparatorFunc get_row_separator_func (); + public int get_row_span_column (); + public string get_title (); + public GLib.Type get_type (); + public int get_wrap_width (); + public void insert_text (int position, string text); + public construct (); + public construct text (); + public construct with_model (Gtk.TreeModel model); + public void popdown (); + public void popup (); + public void prepend_text (string text); + public void remove_text (int position); + public void set_active (int index_); + public void set_active_iter (Gtk.TreeIter iter); + public void set_add_tearoffs (bool add_tearoffs); + public void set_column_span_column (int column_span); + public void set_focus_on_click (bool focus_on_click); + public void set_model (Gtk.TreeModel model); + public void set_row_separator_func (Gtk.TreeViewRowSeparatorFunc func, pointer data, Gtk.DestroyNotify destroy); + public void set_row_span_column (int row_span); + public void set_title (string title); + public void set_wrap_width (int width); + public weak Gtk.TreeModel model { get; set; } + public weak int wrap_width { get; set; } + public weak int row_span_column { get; set; } + public weak int column_span_column { get; set; } + public weak int active { get; set; } + public weak bool add_tearoffs { get; set; } + [NoAccessorMethod ()] + public weak bool has_frame { get; set; } + public weak bool focus_on_click { get; set; } + [NoAccessorMethod ()] + public weak string tearoff_title { get; set; } + [NoAccessorMethod ()] + public weak bool popup_shown { get; } + public signal void changed (); + } + public class ComboBoxEntry : Gtk.ComboBox { + public int get_text_column (); + public GLib.Type get_type (); + public construct (); + public construct text (); + public construct with_model (Gtk.TreeModel model, int text_column); + public void set_text_column (int text_column); + public weak int text_column { get; set; } + } + public class Container : Gtk.Widget { + public void add_with_properties (Gtk.Widget widget, string first_prop_name); + public void child_get (Gtk.Widget child, string first_prop_name); + public void child_get_property (Gtk.Widget child, string property_name, GLib.Value value); + public void child_get_valist (Gtk.Widget child, string first_property_name, pointer var_args); + public void child_set (Gtk.Widget child, string first_prop_name); + public void child_set_property (Gtk.Widget child, string property_name, GLib.Value value); + public void child_set_valist (Gtk.Widget child, string first_property_name, pointer var_args); + public GLib.Type child_type (); + public static GLib.ParamSpec class_find_child_property (pointer cclass, string property_name); + public static void class_install_child_property (pointer cclass, uint property_id, GLib.ParamSpec pspec); + public static GLib.ParamSpec class_list_child_properties (pointer cclass, uint n_properties); + public void forall (Gtk.Callback @callback, pointer callback_data); + public void @foreach (Gtk.Callback @callback, pointer callback_data); + public uint get_border_width (); + public GLib.List get_children (); + public bool get_focus_chain (GLib.List focusable_widgets); + public Gtk.Adjustment get_focus_hadjustment (); + public Gtk.Adjustment get_focus_vadjustment (); + public Gtk.ResizeMode get_resize_mode (); + public GLib.Type get_type (); + public void propagate_expose (Gtk.Widget child, Gdk.EventExpose event); + public void resize_children (); + public void set_border_width (uint border_width); + public void set_focus_chain (GLib.List focusable_widgets); + public void set_focus_hadjustment (Gtk.Adjustment adjustment); + public void set_focus_vadjustment (Gtk.Adjustment adjustment); + public void set_reallocate_redraws (bool needs_redraws); + public void set_resize_mode (Gtk.ResizeMode resize_mode); + public void unset_focus_chain (); + public weak Gtk.ResizeMode resize_mode { get; set; } + public weak uint border_width { get; set; } + [NoAccessorMethod ()] + public weak Gtk.Widget child { set; } + [HasEmitter ()] + public signal void add (Gtk.Widget widget); + [HasEmitter ()] + public signal void remove (Gtk.Widget widget); + [HasEmitter ()] + public signal void check_resize (); + [HasEmitter ()] + public signal void set_focus_child (Gtk.Widget widget); + } + public class Curve : Gtk.DrawingArea { + public GLib.Type get_type (); + public void get_vector (int veclen, float[] vector); + public construct (); + public void reset (); + public void set_curve_type (Gtk.CurveType type); + public void set_gamma (float gamma_); + public void set_range (float min_x, float max_x, float min_y, float max_y); + public void set_vector (int veclen, float[] vector); + [NoAccessorMethod ()] + public weak Gtk.CurveType curve_type { get; set; } + [NoAccessorMethod ()] + public weak float min_x { get; set; } + [NoAccessorMethod ()] + public weak float max_x { get; set; } + [NoAccessorMethod ()] + public weak float min_y { get; set; } + [NoAccessorMethod ()] + public weak float max_y { get; set; } + public signal void curve_type_changed (); + } + public class Dialog : Gtk.Window { + public weak Gtk.Widget vbox; + public weak Gtk.Widget action_area; + public void add_action_widget (Gtk.Widget child, int response_id); + public Gtk.Widget add_button (string button_text, int response_id); + public void add_buttons (string first_button_text); + public bool get_has_separator (); + public int get_response_for_widget (Gtk.Widget widget); + public GLib.Type get_type (); + public construct (); + public construct with_buttons (string title, Gtk.Window parent, Gtk.DialogFlags @flags, string first_button_text); + public int run (); + public void set_alternative_button_order (int first_response_id); + public void set_alternative_button_order_from_array (int n_params, int new_order); + public void set_default_response (int response_id); + public void set_has_separator (bool setting); + public void set_response_sensitive (int response_id, bool setting); + public weak bool has_separator { get; set; } + [HasEmitter ()] + public signal void response (int response_id); + public signal void close (); + } + public class DrawingArea : Gtk.Widget { + public GLib.Type get_type (); + public construct (); + } + public class Entry : Gtk.Widget, Gtk.Editable, Gtk.CellEditable { + public bool get_activates_default (); + public float get_alignment (); + public Gtk.EntryCompletion get_completion (); + public bool get_has_frame (); + public Gtk.Border get_inner_border (); + public unichar get_invisible_char (); + public Pango.Layout get_layout (); + public void get_layout_offsets (int x, int y); + public int get_max_length (); + public string get_text (); + public GLib.Type get_type (); + public bool get_visibility (); + public int get_width_chars (); + public int layout_index_to_text_index (int layout_index); + public construct (); + public void set_activates_default (bool setting); + public void set_alignment (float xalign); + public void set_completion (Gtk.EntryCompletion completion); + public void set_has_frame (bool setting); + public void set_inner_border (Gtk.Border border); + public void set_invisible_char (unichar ch); + public void set_max_length (int max); + public void set_text (string text); + public void set_visibility (bool visible); + public void set_width_chars (int n_chars); + public int text_index_to_layout_index (int text_index); + [NoAccessorMethod ()] + public weak int cursor_position { get; } + [NoAccessorMethod ()] + public weak int selection_bound { get; } + [NoAccessorMethod ()] + public weak bool editable { get; set; } + public weak int max_length { get; set; } + public weak bool visibility { get; set; } + public weak bool has_frame { get; set; } + public weak Gtk.Border inner_border { get; set; } + public weak unichar invisible_char { get; set; } + public weak bool activates_default { get; set; } + public weak int width_chars { get; set; } + [NoAccessorMethod ()] + public weak int scroll_offset { get; } + public weak string text { get; set; } + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak bool truncate_multiline { get; set; } + public signal void populate_popup (Gtk.Menu menu); + public signal void activate (); + public signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public signal void insert_at_cursor (string str); + public signal void delete_from_cursor (Gtk.DeleteType type, int count); + public signal void backspace (); + public signal void cut_clipboard (); + public signal void copy_clipboard (); + public signal void paste_clipboard (); + public signal void toggle_overwrite (); + } + public class EntryCompletion : GLib.Object, Gtk.CellLayout { + public void complete (); + public void delete_action (int index_); + public Gtk.Widget get_entry (); + public bool get_inline_completion (); + public int get_minimum_key_length (); + public Gtk.TreeModel get_model (); + public bool get_popup_completion (); + public bool get_popup_set_width (); + public bool get_popup_single_match (); + public int get_text_column (); + public GLib.Type get_type (); + public void insert_action_markup (int index_, string markup); + public void insert_action_text (int index_, string text); + public construct (); + public void set_inline_completion (bool inline_completion); + public void set_match_func (Gtk.EntryCompletionMatchFunc func, pointer func_data, GLib.DestroyNotify func_notify); + public void set_minimum_key_length (int length); + public void set_model (Gtk.TreeModel model); + public void set_popup_completion (bool popup_completion); + public void set_popup_set_width (bool popup_set_width); + public void set_popup_single_match (bool popup_single_match); + public void set_text_column (int column); + public weak Gtk.TreeModel model { get; set; } + public weak int minimum_key_length { get; set; } + public weak int text_column { get; set; } + public weak bool inline_completion { get; set; } + public weak bool popup_completion { get; set; } + public weak bool popup_set_width { get; set; } + public weak bool popup_single_match { get; set; } + [HasEmitter ()] + public signal bool insert_prefix (string prefix); + public signal bool match_selected (Gtk.TreeModel model, Gtk.TreeIter iter); + public signal void action_activated (int index_); + } + public class EventBox : Gtk.Bin { + public bool get_above_child (); + public GLib.Type get_type (); + public bool get_visible_window (); + public construct (); + public void set_above_child (bool above_child); + public void set_visible_window (bool visible_window); + public weak bool visible_window { get; set; } + public weak bool above_child { get; set; } + } + public class Expander : Gtk.Bin { + public bool get_expanded (); + public string get_label (); + public Gtk.Widget get_label_widget (); + public int get_spacing (); + public GLib.Type get_type (); + public bool get_use_markup (); + public bool get_use_underline (); + public construct (string label); + public construct with_mnemonic (string label); + public void set_expanded (bool expanded); + public void set_label (string label); + public void set_label_widget (Gtk.Widget label_widget); + public void set_spacing (int spacing); + public void set_use_markup (bool use_markup); + public void set_use_underline (bool use_underline); + public weak bool expanded { get; set construct; } + public weak string label { get; set construct; } + public weak bool use_underline { get; set construct; } + public weak bool use_markup { get; set construct; } + public weak int spacing { get; set; } + public weak Gtk.Widget label_widget { get; set; } + public signal void activate (); + } + public class FileChooserButton : Gtk.HBox, Gtk.FileChooser { + public bool get_focus_on_click (); + public string get_title (); + public GLib.Type get_type (); + public int get_width_chars (); + public construct (string title, Gtk.FileChooserAction action); + public construct with_backend (string title, Gtk.FileChooserAction action, string backend); + public construct with_dialog (Gtk.Widget dialog); + public void set_focus_on_click (bool focus_on_click); + public void set_title (string title); + public void set_width_chars (int n_chars); + [NoAccessorMethod ()] + public weak Gtk.FileChooserDialog dialog { construct; } + public weak bool focus_on_click { get; set; } + public weak string title { get; set; } + public weak int width_chars { get; set; } + } + public class FileChooserDialog : Gtk.Dialog, Gtk.FileChooser { + public GLib.Type get_type (); + public construct (string title, Gtk.Window parent, Gtk.FileChooserAction action, string first_button_text); + public construct with_backend (string title, Gtk.Window parent, Gtk.FileChooserAction action, string backend, string first_button_text); + } + public class FileChooserWidget : Gtk.VBox, Gtk.FileChooser { + public GLib.Type get_type (); + public construct (Gtk.FileChooserAction action); + public construct with_backend (Gtk.FileChooserAction action, string backend); + } + public class FileFilter : Gtk.Object { + public void add_custom (Gtk.FileFilterFlags needed, Gtk.FileFilterFunc func, pointer data, GLib.DestroyNotify notify); + public void add_mime_type (string mime_type); + public void add_pattern (string pattern); + public void add_pixbuf_formats (); + public bool filter (Gtk.FileFilterInfo filter_info); + public string get_name (); + public Gtk.FileFilterFlags get_needed (); + public GLib.Type get_type (); + public construct (); + public void set_name (string name); + } + public class FileSelection : Gtk.Dialog { + public weak Gtk.Widget dir_list; + public weak Gtk.Widget file_list; + public weak Gtk.Widget selection_entry; + public weak Gtk.Widget selection_text; + public weak Gtk.Widget main_vbox; + public weak Gtk.Widget ok_button; + public weak Gtk.Widget cancel_button; + public weak Gtk.Widget help_button; + public weak Gtk.Widget history_pulldown; + public weak Gtk.Widget history_menu; + public weak GLib.List history_list; + public weak Gtk.Widget fileop_dialog; + public weak Gtk.Widget fileop_entry; + public weak string fileop_file; + public weak pointer cmpl_state; + public weak Gtk.Widget fileop_c_dir; + public weak Gtk.Widget fileop_del_file; + public weak Gtk.Widget fileop_ren_file; + public weak Gtk.Widget button_area; + public weak Gtk.Widget action_area; + public void complete (string pattern); + public string get_filename (); + public bool get_select_multiple (); + public string get_selections (); + public GLib.Type get_type (); + public void hide_fileop_buttons (); + public construct (string title); + public void set_filename (string filename); + public void set_select_multiple (bool select_multiple); + public void show_fileop_buttons (); + public weak string filename { get; set; } + [NoAccessorMethod ()] + public weak bool show_fileops { get; set; } + public weak bool select_multiple { get; set; } + } + public class Fixed : Gtk.Container { + public bool get_has_window (); + public GLib.Type get_type (); + public void move (Gtk.Widget widget, int x, int y); + public construct (); + public void put (Gtk.Widget widget, int x, int y); + public void set_has_window (bool has_window); + } + public class FontButton : Gtk.Button { + public string get_font_name (); + public bool get_show_size (); + public bool get_show_style (); + public string get_title (); + public GLib.Type get_type (); + public bool get_use_font (); + public bool get_use_size (); + public construct (); + public construct with_font (string fontname); + public bool set_font_name (string fontname); + public void set_show_size (bool show_size); + public void set_show_style (bool show_style); + public void set_title (string title); + public void set_use_font (bool use_font); + public void set_use_size (bool use_size); + public weak string title { get; set; } + public weak string font_name { get; set; } + public weak bool use_font { get; set; } + public weak bool use_size { get; set; } + public weak bool show_style { get; set; } + public weak bool show_size { get; set; } + public signal void font_set (); + } + public class FontSelection : Gtk.VBox { + public string get_font_name (); + public string get_preview_text (); + public GLib.Type get_type (); + public construct (); + public bool set_font_name (string fontname); + public void set_preview_text (string text); + public weak string font_name { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Font font { get; } + public weak string preview_text { get; set; } + } + public class FontSelectionDialog : Gtk.Dialog { + public weak Gtk.Widget ok_button; + public weak Gtk.Widget apply_button; + public weak Gtk.Widget cancel_button; + public string get_font_name (); + public string get_preview_text (); + public GLib.Type get_type (); + public construct (string title); + public bool set_font_name (string fontname); + public void set_preview_text (string text); + } + public class Frame : Gtk.Bin { + public string get_label (); + public void get_label_align (float xalign, float yalign); + public Gtk.Widget get_label_widget (); + public Gtk.ShadowType get_shadow_type (); + public GLib.Type get_type (); + public construct (string label); + public void set_label (string label); + public void set_label_align (float xalign, float yalign); + public void set_label_widget (Gtk.Widget label_widget); + public void set_shadow_type (Gtk.ShadowType type); + public weak string label { get; set; } + [NoAccessorMethod ()] + public weak float label_xalign { get; set; } + [NoAccessorMethod ()] + public weak float label_yalign { get; set; } + [NoAccessorMethod ()] + public weak Gtk.ShadowType shadow { get; set; } + public weak Gtk.ShadowType shadow_type { get; set; } + public weak Gtk.Widget label_widget { get; set; } + } + public class GammaCurve : Gtk.VBox { + public GLib.Type get_type (); + public construct (); + } + public class HandleBox : Gtk.Bin { + public Gtk.PositionType get_handle_position (); + public Gtk.ShadowType get_shadow_type (); + public Gtk.PositionType get_snap_edge (); + public GLib.Type get_type (); + public construct (); + public void set_handle_position (Gtk.PositionType position); + public void set_shadow_type (Gtk.ShadowType type); + public void set_snap_edge (Gtk.PositionType edge); + [NoAccessorMethod ()] + public weak Gtk.ShadowType shadow { get; set; } + public weak Gtk.ShadowType shadow_type { get; set; } + public weak Gtk.PositionType handle_position { get; set; } + public weak Gtk.PositionType snap_edge { get; set; } + [NoAccessorMethod ()] + public weak bool snap_edge_set { get; set; } + public signal void child_attached (Gtk.Widget child); + public signal void child_detached (Gtk.Widget child); + } + public class HBox : Gtk.Box { + public GLib.Type get_type (); + public construct (bool homogeneous, int spacing); + } + public class HButtonBox : Gtk.ButtonBox { + public GLib.Type get_type (); + public construct (); + } + public class HPaned : Gtk.Paned { + public GLib.Type get_type (); + public construct (); + } + public class HRuler : Gtk.Ruler { + public GLib.Type get_type (); + public construct (); + } + public class HScale : Gtk.Scale { + public GLib.Type get_type (); + public construct (Gtk.Adjustment adjustment); + public construct with_range (double min, double max, double step); + } + public class HScrollbar : Gtk.Scrollbar { + public GLib.Type get_type (); + public construct (Gtk.Adjustment adjustment); + } + public class HSeparator : Gtk.Separator { + public GLib.Type get_type (); + public construct (); + } + public class HSV : Gtk.Widget { + public void get_color (double h, double s, double v); + public void get_metrics (int size, int ring_width); + public GLib.Type get_type (); + public bool is_adjusting (); + public construct (); + public void set_color (double h, double s, double v); + public void set_metrics (int size, int ring_width); + public static void to_rgb (double h, double s, double v, double r, double g, double b); + public signal void changed (); + public signal void move (Gtk.DirectionType type); + } + public class IconFactory : GLib.Object { + public void add (string stock_id, Gtk.IconSet icon_set); + public void add_default (); + public GLib.Type get_type (); + public Gtk.IconSet lookup (string stock_id); + public static Gtk.IconSet lookup_default (string stock_id); + public construct (); + public void remove_default (); + } + public class IconTheme : GLib.Object { + public static void add_builtin_icon (string icon_name, int size, Gdk.Pixbuf pixbuf); + public void append_search_path (string path); + public GLib.Quark error_quark (); + public Gtk.IconTheme get_default (); + public string get_example_icon_name (); + public static Gtk.IconTheme get_for_screen (Gdk.Screen screen); + public int get_icon_sizes (string icon_name); + public void get_search_path (string path, int n_elements); + public GLib.Type get_type (); + public bool has_icon (string icon_name); + public GLib.List list_icons (string context); + public Gdk.Pixbuf load_icon (string icon_name, int size, Gtk.IconLookupFlags @flags, GLib.Error error); + public Gtk.IconInfo lookup_icon (string icon_name, int size, Gtk.IconLookupFlags @flags); + public construct (); + public void prepend_search_path (string path); + public bool rescan_if_needed (); + public void set_custom_theme (string theme_name); + public void set_screen (Gdk.Screen screen); + public void set_search_path (string[] path, int n_elements); + public signal void changed (); + } + public class IconView : Gtk.Container, Gtk.CellLayout { + public Gdk.Pixmap create_drag_icon (Gtk.TreePath path); + public void enable_model_drag_dest (Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public void enable_model_drag_source (Gdk.ModifierType start_button_mask, Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public int get_column_spacing (); + public int get_columns (); + public bool get_cursor (Gtk.TreePath path, Gtk.CellRenderer cell); + public bool get_dest_item_at_pos (int drag_x, int drag_y, Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public void get_drag_dest_item (Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public bool get_item_at_pos (int x, int y, Gtk.TreePath path, Gtk.CellRenderer cell); + public int get_item_width (); + public int get_margin (); + public int get_markup_column (); + public Gtk.TreeModel get_model (); + public Gtk.Orientation get_orientation (); + public Gtk.TreePath get_path_at_pos (int x, int y); + public int get_pixbuf_column (); + public bool get_reorderable (); + public int get_row_spacing (); + public GLib.List get_selected_items (); + public Gtk.SelectionMode get_selection_mode (); + public int get_spacing (); + public int get_text_column (); + public GLib.Type get_type (); + public bool get_visible_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public construct (); + public construct with_model (Gtk.TreeModel model); + public bool path_is_selected (Gtk.TreePath path); + public void scroll_to_path (Gtk.TreePath path, bool use_align, float row_align, float col_align); + public void select_path (Gtk.TreePath path); + public void selected_foreach (Gtk.IconViewForeachFunc func, pointer data); + public void set_column_spacing (int column_spacing); + public void set_columns (int columns); + public void set_cursor (Gtk.TreePath path, Gtk.CellRenderer cell, bool start_editing); + public void set_drag_dest_item (Gtk.TreePath path, Gtk.IconViewDropPosition pos); + public void set_item_width (int item_width); + public void set_margin (int margin); + public void set_markup_column (int column); + public void set_model (Gtk.TreeModel model); + public void set_orientation (Gtk.Orientation orientation); + public void set_pixbuf_column (int column); + public void set_reorderable (bool reorderable); + public void set_row_spacing (int row_spacing); + public void set_selection_mode (Gtk.SelectionMode mode); + public void set_spacing (int spacing); + public void set_text_column (int column); + public void unselect_path (Gtk.TreePath path); + public void unset_model_drag_dest (); + public void unset_model_drag_source (); + public weak Gtk.SelectionMode selection_mode { get; set; } + public weak int pixbuf_column { get; set; } + public weak int text_column { get; set; } + public weak int markup_column { get; set; } + public weak Gtk.TreeModel model { get; set; } + public weak int columns { get; set; } + public weak int item_width { get; set; } + public weak int spacing { get; set; } + public weak int row_spacing { get; set; } + public weak int column_spacing { get; set; } + public weak int margin { get; set; } + public weak Gtk.Orientation orientation { get; set; } + public weak bool reorderable { get; set; } + public signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + [HasEmitter ()] + public signal void item_activated (Gtk.TreePath path); + public signal void selection_changed (); + public signal void select_all (); + public signal void unselect_all (); + public signal void select_cursor_item (); + public signal void toggle_cursor_item (); + public signal bool activate_cursor_item (); + public signal bool move_cursor (Gtk.MovementStep step, int count); + } + public class Image : Gtk.Misc { + public void clear (); + public Gdk.PixbufAnimation get_animation (); + public void get_icon_name (string icon_name, Gtk.IconSize size); + public void get_icon_set (Gtk.IconSet icon_set, Gtk.IconSize size); + public void get_image (Gdk.Image gdk_image, Gdk.Bitmap mask); + public Gdk.Pixbuf get_pixbuf (); + public int get_pixel_size (); + public void get_pixmap (Gdk.Pixmap pixmap, Gdk.Bitmap mask); + public void get_stock (string stock_id, Gtk.IconSize size); + public Gtk.ImageType get_storage_type (); + public GLib.Type get_type (); + public construct (); + public construct from_animation (Gdk.PixbufAnimation animation); + public construct from_file (string filename); + public construct from_icon_name (string icon_name, Gtk.IconSize size); + public construct from_icon_set (Gtk.IconSet icon_set, Gtk.IconSize size); + public construct from_image (Gdk.Image image, Gdk.Bitmap mask); + public construct from_pixbuf (Gdk.Pixbuf pixbuf); + public construct from_pixmap (Gdk.Pixmap pixmap, Gdk.Bitmap mask); + public construct from_stock (string stock_id, Gtk.IconSize size); + public void set_from_animation (Gdk.PixbufAnimation animation); + public void set_from_file (string filename); + public void set_from_icon_name (string icon_name, Gtk.IconSize size); + public void set_from_icon_set (Gtk.IconSet icon_set, Gtk.IconSize size); + public void set_from_image (Gdk.Image gdk_image, Gdk.Bitmap mask); + public void set_from_pixbuf (Gdk.Pixbuf pixbuf); + public void set_from_pixmap (Gdk.Pixmap pixmap, Gdk.Bitmap mask); + public void set_from_stock (string stock_id, Gtk.IconSize size); + public void set_pixel_size (int pixel_size); + [NoAccessorMethod ()] + public weak Gdk.Pixbuf pixbuf { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixmap pixmap { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Image image { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixmap mask { get; set; } + [NoAccessorMethod ()] + public weak string file { get; set; } + [NoAccessorMethod ()] + public weak string stock { get; set; } + [NoAccessorMethod ()] + public weak Gtk.IconSet icon_set { get; set; } + [NoAccessorMethod ()] + public weak int icon_size { get; set; } + public weak int pixel_size { get; set; } + [NoAccessorMethod ()] + public weak Gdk.PixbufAnimation pixbuf_animation { get; set; } + [NoAccessorMethod ()] + public weak string icon_name { get; set; } + public weak Gtk.ImageType storage_type { get; } + } + public class ImageMenuItem : Gtk.MenuItem { + public Gtk.Widget get_image (); + public GLib.Type get_type (); + public construct (); + public construct from_stock (string stock_id, Gtk.AccelGroup accel_group); + public construct with_label (string label); + public construct with_mnemonic (string label); + public void set_image (Gtk.Widget image); + public weak Gtk.Widget image { get; set; } + } + public class IMContext : GLib.Object { + public bool filter_keypress (Gdk.EventKey event); + public void focus_in (); + public void focus_out (); + public void get_preedit_string (string str, Pango.AttrList attrs, int cursor_pos); + public bool get_surrounding (string text, int cursor_index); + public GLib.Type get_type (); + public void reset (); + public void set_client_window (Gdk.Window window); + public void set_cursor_location (Gdk.Rectangle area); + public void set_surrounding (string text, int len, int cursor_index); + public void set_use_preedit (bool use_preedit); + public signal void preedit_start (); + public signal void preedit_end (); + public signal void preedit_changed (); + public signal void commit (string str); + public signal bool retrieve_surrounding (); + [HasEmitter ()] + public signal bool delete_surrounding (int offset, int n_chars); + } + public class IMContextSimple : Gtk.IMContext { + public void add_table (ushort data, int max_seq_len, int n_seqs); + public GLib.Type get_type (); + public construct (); + } + public class IMMulticontext : Gtk.IMContext { + public void append_menuitems (Gtk.MenuShell menushell); + public GLib.Type get_type (); + public construct (); + } + public class InputDialog : Gtk.Dialog { + public GLib.Type get_type (); + public construct (); + public signal void enable_device (Gdk.Device device); + public signal void disable_device (Gdk.Device device); + } + public class Invisible : Gtk.Widget { + public Gdk.Screen get_screen (); + public GLib.Type get_type (); + public construct (); + public construct for_screen (Gdk.Screen screen); + public void set_screen (Gdk.Screen screen); + public weak Gdk.Screen screen { get; set; } + } + public class Item : Gtk.Bin { + public GLib.Type get_type (); + [HasEmitter ()] + public signal void select (); + [HasEmitter ()] + public signal void deselect (); + [HasEmitter ()] + public signal void toggle (); + } + public class ItemFactory : Gtk.Object { + } + public class Label : Gtk.Misc { + public double get_angle (); + public Pango.AttrList get_attributes (); + public Pango.EllipsizeMode get_ellipsize (); + public Gtk.Justification get_justify (); + public string get_label (); + public Pango.Layout get_layout (); + public void get_layout_offsets (int x, int y); + public bool get_line_wrap (); + public Pango.WrapMode get_line_wrap_mode (); + public int get_max_width_chars (); + public uint get_mnemonic_keyval (); + public Gtk.Widget get_mnemonic_widget (); + public bool get_selectable (); + public bool get_selection_bounds (int start, int end); + public bool get_single_line_mode (); + public string get_text (); + public GLib.Type get_type (); + public bool get_use_markup (); + public bool get_use_underline (); + public int get_width_chars (); + public construct (string str); + public construct with_mnemonic (string str); + public void select_region (int start_offset, int end_offset); + public void set_angle (double angle); + public void set_attributes (Pango.AttrList attrs); + public void set_ellipsize (Pango.EllipsizeMode mode); + public void set_justify (Gtk.Justification jtype); + public void set_label (string str); + public void set_line_wrap (bool wrap); + public void set_line_wrap_mode (Pango.WrapMode wrap_mode); + public void set_markup (string str); + public void set_markup_with_mnemonic (string str); + public void set_max_width_chars (int n_chars); + public void set_mnemonic_widget (Gtk.Widget widget); + public void set_pattern (string pattern); + public void set_selectable (bool setting); + public void set_single_line_mode (bool single_line_mode); + public void set_text (string str); + public void set_text_with_mnemonic (string str); + public void set_use_markup (bool setting); + public void set_use_underline (bool setting); + public void set_width_chars (int n_chars); + public weak string label { get; set; } + public weak Pango.AttrList attributes { get; set; } + public weak bool use_markup { get; set; } + public weak bool use_underline { get; set; } + public weak Gtk.Justification justify { get; set; } + public weak string pattern { set; } + [NoAccessorMethod ()] + public weak bool wrap { get; set; } + [NoAccessorMethod ()] + public weak Pango.WrapMode wrap_mode { get; set; } + public weak bool selectable { get; set; } + public weak uint mnemonic_keyval { get; } + public weak Gtk.Widget mnemonic_widget { get; set; } + [NoAccessorMethod ()] + public weak int cursor_position { get; } + [NoAccessorMethod ()] + public weak int selection_bound { get; } + public weak Pango.EllipsizeMode ellipsize { get; set; } + public weak int width_chars { get; set; } + public weak bool single_line_mode { get; set; } + public weak double angle { get; set; } + public weak int max_width_chars { get; set; } + public signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public signal void copy_clipboard (); + public signal void populate_popup (Gtk.Menu menu); + } + public class Layout : Gtk.Container { + public weak Gdk.Window bin_window; + public Gtk.Adjustment get_hadjustment (); + public void get_size (uint width, uint height); + public GLib.Type get_type (); + public Gtk.Adjustment get_vadjustment (); + public void move (Gtk.Widget child_widget, int x, int y); + public construct (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public void put (Gtk.Widget child_widget, int x, int y); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_size (uint width, uint height); + public void set_vadjustment (Gtk.Adjustment adjustment); + public weak Gtk.Adjustment hadjustment { get; set; } + public weak Gtk.Adjustment vadjustment { get; set; } + [NoAccessorMethod ()] + public weak uint width { get; set; } + [NoAccessorMethod ()] + public weak uint height { get; set; } + public signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + } + public class LinkButton : Gtk.Button { + public GLib.Type get_type (); + public string get_uri (); + public construct (string uri); + public construct with_label (string uri, string label); + public void set_uri (string uri); + public static Gtk.LinkButtonUriFunc set_uri_hook (Gtk.LinkButtonUriFunc func, pointer data, GLib.DestroyNotify destroy); + public weak string uri { get; set; } + } + public class ListStore : GLib.Object, Gtk.TreeModel, Gtk.TreeDragSource, Gtk.TreeDragDest, Gtk.TreeSortable { + public void append (Gtk.TreeIter iter); + public void clear (); + public GLib.Type get_type (); + public void insert (Gtk.TreeIter iter, int position); + public void insert_after (Gtk.TreeIter iter, Gtk.TreeIter sibling); + public void insert_before (Gtk.TreeIter iter, Gtk.TreeIter sibling); + public void insert_with_values (Gtk.TreeIter iter, int position); + public void insert_with_valuesv (Gtk.TreeIter iter, int position, int columns, GLib.Value values, int n_values); + public bool iter_is_valid (Gtk.TreeIter iter); + public void move_after (Gtk.TreeIter iter, Gtk.TreeIter position); + public void move_before (Gtk.TreeIter iter, Gtk.TreeIter position); + public construct (int n_columns); + public construct newv (int n_columns, GLib.Type types); + public void prepend (Gtk.TreeIter iter); + public bool remove (Gtk.TreeIter iter); + public void reorder (int new_order); + public void @set (Gtk.TreeIter iter); + public void set_column_types (int n_columns, GLib.Type types); + public void set_valist (Gtk.TreeIter iter, pointer var_args); + public void set_value (Gtk.TreeIter iter, int column, GLib.Value value); + public void swap (Gtk.TreeIter a, Gtk.TreeIter b); + } + public class Menu : Gtk.MenuShell { + public void attach (Gtk.Widget child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach); + public void attach_to_widget (Gtk.Widget attach_widget, Gtk.MenuDetachFunc detacher); + public void detach (); + public Gtk.AccelGroup get_accel_group (); + public Gtk.Widget get_active (); + public Gtk.Widget get_attach_widget (); + public static GLib.List get_for_attach_widget (Gtk.Widget widget); + public bool get_tearoff_state (); + public string get_title (); + public GLib.Type get_type (); + public construct (); + public void popdown (); + public void popup (Gtk.Widget parent_menu_shell, Gtk.Widget parent_menu_item, Gtk.MenuPositionFunc func, pointer data, uint button, uint activate_time); + public void reorder_child (Gtk.Widget child, int position); + public void reposition (); + public void set_accel_group (Gtk.AccelGroup accel_group); + public void set_accel_path (string accel_path); + public void set_active (uint index_); + public void set_monitor (int monitor_num); + public void set_screen (Gdk.Screen screen); + public void set_tearoff_state (bool torn_off); + public void set_title (string title); + [NoAccessorMethod ()] + public weak string tearoff_title { get; set; } + public weak bool tearoff_state { get; set; } + } + public class MenuBar : Gtk.MenuShell { + public Gtk.PackDirection get_child_pack_direction (); + public Gtk.PackDirection get_pack_direction (); + public GLib.Type get_type (); + public construct (); + public void set_child_pack_direction (Gtk.PackDirection child_pack_dir); + public void set_pack_direction (Gtk.PackDirection pack_dir); + public weak Gtk.PackDirection pack_direction { get; set; } + public weak Gtk.PackDirection child_pack_direction { get; set; } + } + public class MenuItem : Gtk.Item { + public void deselect (); + public bool get_right_justified (); + public Gtk.Widget get_submenu (); + public GLib.Type get_type (); + public construct (); + public construct with_label (string label); + public construct with_mnemonic (string label); + public void remove_submenu (); + public void select (); + public void set_accel_path (string accel_path); + public void set_right_justified (bool right_justified); + public void set_submenu (Gtk.Widget submenu); + [HasEmitter ()] + public signal void activate (); + public signal void activate_item (); + [HasEmitter ()] + public signal void toggle_size_request (int requisition); + [HasEmitter ()] + public signal void toggle_size_allocate (int allocation); + } + public class MenuShell : Gtk.Container { + public void activate_item (Gtk.Widget menu_item, bool force_deactivate); + public void append (Gtk.Widget child); + public void deselect (); + public bool get_take_focus (); + public GLib.Type get_type (); + public void insert (Gtk.Widget child, int position); + public void prepend (Gtk.Widget child); + public void select_first (bool search_sensitive); + public void select_item (Gtk.Widget menu_item); + public void set_take_focus (bool take_focus); + public weak bool take_focus { get; set; } + [HasEmitter ()] + public signal void deactivate (); + public signal void selection_done (); + public signal void move_current (Gtk.MenuDirectionType direction); + public signal void activate_current (bool force_hide); + [HasEmitter ()] + public signal void cancel (); + } + public class MenuToolButton : Gtk.ToolButton { + public Gtk.Widget get_menu (); + public GLib.Type get_type (); + public construct (Gtk.Widget icon_widget, string label); + public construct from_stock (string stock_id); + public void set_arrow_tooltip (Gtk.Tooltips tooltips, string tip_text, string tip_private); + public void set_menu (Gtk.Widget menu); + public weak Gtk.Menu menu { get; set; } + public signal void show_menu (); + } + public class MessageDialog : Gtk.Dialog { + public void format_secondary_markup (string message_format); + public void format_secondary_text (string message_format); + public GLib.Type get_type (); + public construct (Gtk.Window parent, Gtk.DialogFlags @flags, Gtk.MessageType type, Gtk.ButtonsType buttons, string message_format); + public construct with_markup (Gtk.Window parent, Gtk.DialogFlags @flags, Gtk.MessageType type, Gtk.ButtonsType buttons, string message_format); + public void set_image (Gtk.Widget image); + public void set_markup (string str); + [NoAccessorMethod ()] + public weak Gtk.MessageType message_type { get; set construct; } + [NoAccessorMethod ()] + public weak Gtk.ButtonsType buttons { construct; } + [NoAccessorMethod ()] + public weak string text { get; set; } + [NoAccessorMethod ()] + public weak bool use_markup { get; set; } + [NoAccessorMethod ()] + public weak string secondary_text { get; set; } + [NoAccessorMethod ()] + public weak bool secondary_use_markup { get; set; } + [NoAccessorMethod ()] + public weak Gtk.Widget image { get; set; } + } + public class Misc : Gtk.Widget { + public void get_alignment (float xalign, float yalign); + public void get_padding (int xpad, int ypad); + public GLib.Type get_type (); + public void set_alignment (float xalign, float yalign); + public void set_padding (int xpad, int ypad); + [NoAccessorMethod ()] + public weak float xalign { get; set; } + [NoAccessorMethod ()] + public weak float yalign { get; set; } + [NoAccessorMethod ()] + public weak int xpad { get; set; } + [NoAccessorMethod ()] + public weak int ypad { get; set; } + } + public class Notebook : Gtk.Container { + public int append_page (Gtk.Widget child, Gtk.Widget tab_label); + public int append_page_menu (Gtk.Widget child, Gtk.Widget tab_label, Gtk.Widget menu_label); + public int get_current_page (); + public int get_group_id (); + public Gtk.Widget get_menu_label (Gtk.Widget child); + public string get_menu_label_text (Gtk.Widget child); + public int get_n_pages (); + public Gtk.Widget get_nth_page (int page_num); + public bool get_scrollable (); + public bool get_show_border (); + public bool get_show_tabs (); + public bool get_tab_detachable (Gtk.Widget child); + public Gtk.Widget get_tab_label (Gtk.Widget child); + public string get_tab_label_text (Gtk.Widget child); + public Gtk.PositionType get_tab_pos (); + public bool get_tab_reorderable (Gtk.Widget child); + public GLib.Type get_type (); + public int insert_page (Gtk.Widget child, Gtk.Widget tab_label, int position); + public int insert_page_menu (Gtk.Widget child, Gtk.Widget tab_label, Gtk.Widget menu_label, int position); + public construct (); + public void next_page (); + public void popup_disable (); + public void popup_enable (); + public int prepend_page (Gtk.Widget child, Gtk.Widget tab_label); + public int prepend_page_menu (Gtk.Widget child, Gtk.Widget tab_label, Gtk.Widget menu_label); + public void prev_page (); + public void query_tab_label_packing (Gtk.Widget child, bool expand, bool fill, Gtk.PackType pack_type); + public void remove_page (int page_num); + public void reorder_child (Gtk.Widget child, int position); + public void set_current_page (int page_num); + public void set_group_id (int group_id); + public void set_menu_label (Gtk.Widget child, Gtk.Widget menu_label); + public void set_menu_label_text (Gtk.Widget child, string menu_text); + public void set_scrollable (bool scrollable); + public void set_show_border (bool show_border); + public void set_show_tabs (bool show_tabs); + public void set_tab_detachable (Gtk.Widget child, bool detachable); + public void set_tab_label (Gtk.Widget child, Gtk.Widget tab_label); + public void set_tab_label_packing (Gtk.Widget child, bool expand, bool fill, Gtk.PackType pack_type); + public void set_tab_label_text (Gtk.Widget child, string tab_text); + public void set_tab_pos (Gtk.PositionType pos); + public void set_tab_reorderable (Gtk.Widget child, bool reorderable); + public static void set_window_creation_hook (Gtk.NotebookWindowCreationFunc func, pointer data, GLib.DestroyNotify destroy); + [NoAccessorMethod ()] + public weak int page { get; set; } + public weak Gtk.PositionType tab_pos { get; set; } + [NoAccessorMethod ()] + public weak uint tab_border { set; } + [NoAccessorMethod ()] + public weak uint tab_hborder { get; set; } + [NoAccessorMethod ()] + public weak uint tab_vborder { get; set; } + public weak bool show_tabs { get; set; } + public weak bool show_border { get; set; } + public weak bool scrollable { get; set; } + [NoAccessorMethod ()] + public weak bool enable_popup { get; set; } + [NoAccessorMethod ()] + public weak bool homogeneous { get; set; } + public weak int group_id { get; set; } + public signal void switch_page (Gtk.NotebookPage page, uint page_num); + public signal bool focus_tab (Gtk.NotebookTab type); + public signal bool select_page (bool move_focus); + public signal void change_current_page (int offset); + public signal void move_focus_out (Gtk.DirectionType direction); + public signal void reorder_tab (Gtk.DirectionType direction, bool move_to_last); + public signal void page_reordered (Gtk.Widget p0, uint p1); + public signal void page_removed (Gtk.Widget p0, uint p1); + public signal void page_added (Gtk.Widget p0, uint p1); + } + public class Object : GLib.InitiallyUnowned { + public Gtk.Type get_type (); + [NoAccessorMethod ()] + public weak pointer user_data { get; set; } + public signal void destroy (); + } + public class OptionMenu : Gtk.Button { + [NoAccessorMethod ()] + public weak Gtk.Menu menu { get; set; } + public signal void changed (); + } + public class PageSetup : GLib.Object { + public Gtk.PageSetup copy (); + public double get_bottom_margin (Gtk.Unit unit); + public double get_left_margin (Gtk.Unit unit); + public Gtk.PageOrientation get_orientation (); + public double get_page_height (Gtk.Unit unit); + public double get_page_width (Gtk.Unit unit); + public double get_paper_height (Gtk.Unit unit); + public Gtk.PaperSize get_paper_size (); + public double get_paper_width (Gtk.Unit unit); + public double get_right_margin (Gtk.Unit unit); + public double get_top_margin (Gtk.Unit unit); + public GLib.Type get_type (); + public construct (); + public void set_bottom_margin (double margin, Gtk.Unit unit); + public void set_left_margin (double margin, Gtk.Unit unit); + public void set_orientation (Gtk.PageOrientation orientation); + public void set_paper_size (Gtk.PaperSize size); + public void set_paper_size_and_default_margins (Gtk.PaperSize size); + public void set_right_margin (double margin, Gtk.Unit unit); + public void set_top_margin (double margin, Gtk.Unit unit); + } + public class PageSetupUnixDialog : Gtk.Dialog { + public Gtk.PageSetup get_page_setup (); + public Gtk.PrintSettings get_print_settings (); + public GLib.Type get_type (); + public construct (string title, Gtk.Window parent); + public void set_page_setup (Gtk.PageSetup page_setup); + public void set_print_settings (Gtk.PrintSettings print_settings); + } + public class Paned : Gtk.Container { + public void add1 (Gtk.Widget child); + public void add2 (Gtk.Widget child); + public Gtk.Widget get_child1 (); + public Gtk.Widget get_child2 (); + public int get_position (); + public GLib.Type get_type (); + public void pack1 (Gtk.Widget child, bool resize, bool shrink); + public void pack2 (Gtk.Widget child, bool resize, bool shrink); + public void set_position (int position); + public weak int position { get; set; } + [NoAccessorMethod ()] + public weak bool position_set { get; set; } + [NoAccessorMethod ()] + public weak int min_position { get; } + [NoAccessorMethod ()] + public weak int max_position { get; } + public signal bool cycle_child_focus (bool reverse); + public signal bool toggle_handle_focus (); + public signal bool move_handle (Gtk.ScrollType scroll); + public signal bool cycle_handle_focus (bool reverse); + public signal bool accept_position (); + public signal bool cancel_position (); + } + public class Plug : Gtk.Window { + public void @construct (pointer socket_id); + public void construct_for_display (Gdk.Display display, pointer socket_id); + public pointer get_id (); + public GLib.Type get_type (); + public construct (pointer socket_id); + public construct for_display (Gdk.Display display, pointer socket_id); + public signal void embedded (); + } + public class Printer : GLib.Object { + public int compare (Gtk.Printer b); + public Gtk.PrintBackend get_backend (); + public string get_description (); + public string get_icon_name (); + public int get_job_count (); + public string get_location (); + public string get_name (); + public string get_state_message (); + public GLib.Type get_type (); + public bool is_active (); + public bool is_default (); + public bool is_new (); + public construct (string name, Gtk.PrintBackend backend, bool virtual_); + public bool set_description (string description); + public void set_has_details (bool val); + public void set_icon_name (string icon); + public void set_is_active (bool active); + public void set_is_default (bool val); + public void set_is_new (bool val); + public bool set_job_count (int count); + public bool set_location (string location); + public bool set_state_message (string message); + [NoAccessorMethod ()] + public weak string name { get; construct; } + [NoAccessorMethod ()] + public weak Gtk.PrintBackend backend { get; construct; } + [NoAccessorMethod ()] + public weak bool is_virtual { get; construct; } + [NoAccessorMethod ()] + public weak bool accepts_pdf { get; construct; } + [NoAccessorMethod ()] + public weak bool accepts_ps { get; construct; } + public weak string state_message { get; } + public weak string location { get; } + public weak string icon_name { get; } + public weak int job_count { get; } + public signal void details_acquired (bool success); + } + public class PrinterOption : GLib.Object { + public void allocate_choices (int num); + public void choices_from_array (int num_choices, string[] choices, string[] choices_display); + public void clear_has_conflict (); + public GLib.Type get_type (); + public bool has_choice (string choice); + public construct (string name, string display_text, Gtk.PrinterOptionType type); + public void @set (string value); + public signal void changed (); + } + public class PrinterOptionSet : GLib.Object { + public void add (Gtk.PrinterOption option); + public static void boolean (Gtk.PrinterOption option, bool value); + public void clear_conflicts (); + public void @foreach (Gtk.PrinterOptionSetFunc func, pointer user_data); + public void foreach_in_group (string group, Gtk.PrinterOptionSetFunc func, pointer user_data); + public GLib.List get_groups (); + public GLib.Type get_type (); + public static void has_conflict (Gtk.PrinterOption option, bool has_conflict); + public Gtk.PrinterOption lookup (string name); + public construct (); + public void remove (Gtk.PrinterOption option); + public signal void changed (); + } + public class PrinterOptionWidget : Gtk.HBox { + public Gtk.Widget get_external_label (); + public GLib.Type get_type (); + public string get_value (); + public bool has_external_label (); + public construct (Gtk.PrinterOption source); + public void set_source (Gtk.PrinterOption source); + [NoAccessorMethod ()] + public weak Gtk.PrinterOption source { get; set construct; } + public signal void changed (); + } + public class PrintBackend : GLib.Object { + public void add_printer (Gtk.Printer printer); + public void destroy (); + public GLib.Quark error_quark (); + public Gtk.Printer find_printer (string printer_name); + public GLib.List get_printer_list (); + public GLib.Type get_type (); + public GLib.List load_modules (); + public void print_stream (Gtk.PrintJob job, GLib.IOChannel data_io, Gtk.PrintJobCompleteFunc @callback, pointer user_data, GLib.DestroyNotify dnotify); + public bool printer_list_is_done (); + public void remove_printer (Gtk.Printer printer); + public void set_list_done (); + public signal void printer_list_changed (); + public signal void printer_list_done (); + public signal void printer_added (Gtk.Printer printer); + public signal void printer_removed (Gtk.Printer printer); + public signal void printer_status_changed (Gtk.Printer printer); + } + public class PrintContext : GLib.Object { + public Pango.Context create_pango_context (); + public Pango.Layout create_pango_layout (); + public Cairo.Context get_cairo_context (); + public double get_dpi_x (); + public double get_dpi_y (); + public double get_height (); + public Gtk.PageSetup get_page_setup (); + public Pango.FontMap get_pango_fontmap (); + public GLib.Type get_type (); + public double get_width (); + public void set_cairo_context (Cairo.Context cr, double dpi_x, double dpi_y); + } + public class PrintJob : GLib.Object { + public Gtk.Printer get_printer (); + public Gtk.PrintSettings get_settings (); + public Gtk.PrintStatus get_status (); + public Cairo.Surface get_surface (GLib.Error error); + public string get_title (); + public bool get_track_print_status (); + public GLib.Type get_type (); + public construct (string title, Gtk.Printer printer, Gtk.PrintSettings settings, Gtk.PageSetup page_setup); + public void send (Gtk.PrintJobCompleteFunc @callback, pointer user_data, GLib.DestroyNotify dnotify); + public bool set_source_file (string filename, GLib.Error error); + public void set_track_print_status (bool track_status); + [NoAccessorMethod ()] + public weak string title { get; construct; } + [NoAccessorMethod ()] + public weak Gtk.Printer printer { get; construct; } + [NoAccessorMethod ()] + public weak Gtk.PrintSettings settings { get; construct; } + [NoAccessorMethod ()] + public weak Gtk.PageSetup page_setup { get; construct; } + public weak bool track_print_status { get; set; } + public signal void status_changed (); + } + public class PrintOperation : GLib.Object, Gtk.PrintOperationPreview { + public void cancel (); + public Gtk.PageSetup get_default_page_setup (); + public void get_error (GLib.Error error); + public Gtk.PrintSettings get_print_settings (); + public Gtk.PrintStatus get_status (); + public string get_status_string (); + public GLib.Type get_type (); + public bool is_finished (); + public construct (); + public Gtk.PrintOperationResult run (Gtk.PrintOperationAction action, Gtk.Window parent, GLib.Error error); + public void set_allow_async (bool allow_async); + public void set_current_page (int current_page); + public void set_custom_tab_label (string label); + public void set_default_page_setup (Gtk.PageSetup default_page_setup); + public void set_export_filename (string filename); + public void set_job_name (string job_name); + public void set_n_pages (int n_pages); + public void set_print_settings (Gtk.PrintSettings print_settings); + public void set_show_progress (bool show_progress); + public void set_track_print_status (bool track_status); + public void set_unit (Gtk.Unit unit); + public void set_use_full_page (bool full_page); + public weak Gtk.PageSetup default_page_setup { get; set; } + public weak Gtk.PrintSettings print_settings { get; set; } + [NoAccessorMethod ()] + public weak string job_name { get; set; } + [NoAccessorMethod ()] + public weak int n_pages { get; set; } + [NoAccessorMethod ()] + public weak int current_page { get; set; } + [NoAccessorMethod ()] + public weak bool use_full_page { get; set; } + [NoAccessorMethod ()] + public weak bool track_print_status { get; set; } + [NoAccessorMethod ()] + public weak Gtk.Unit unit { get; set; } + [NoAccessorMethod ()] + public weak bool show_progress { get; set; } + [NoAccessorMethod ()] + public weak bool allow_async { get; set; } + [NoAccessorMethod ()] + public weak string export_filename { get; set; } + public weak Gtk.PrintStatus status { get; } + public weak string status_string { get; } + [NoAccessorMethod ()] + public weak string custom_tab_label { get; set; } + public signal void done (Gtk.PrintOperationResult result); + public signal void begin_print (Gtk.PrintContext context); + public signal bool paginate (Gtk.PrintContext context); + public signal void request_page_setup (Gtk.PrintContext context, int page_nr, Gtk.PageSetup setup); + public signal void draw_page (Gtk.PrintContext context, int page_nr); + public signal void end_print (Gtk.PrintContext context); + public signal void status_changed (); + public signal Gtk.Widget create_custom_widget (); + public signal void custom_widget_apply (Gtk.Widget widget); + public signal bool preview (Gtk.PrintOperationPreview preview, Gtk.PrintContext context, Gtk.Window parent); + } + public class PrintSettings : GLib.Object { + public Gtk.PrintSettings copy (); + public void @foreach (Gtk.PrintSettingsFunc func, pointer user_data); + public string @get (string key); + public bool get_bool (string key); + public bool get_collate (); + public string get_default_source (); + public string get_dither (); + public double get_double (string key); + public double get_double_with_default (string key, double def); + public Gtk.PrintDuplex get_duplex (); + public string get_finishings (); + public int get_int (string key); + public int get_int_with_default (string key, int def); + public double get_length (string key, Gtk.Unit unit); + public string get_media_type (); + public int get_n_copies (); + public int get_number_up (); + public Gtk.PageOrientation get_orientation (); + public string get_output_bin (); + public Gtk.PageRange get_page_ranges (int num_ranges); + public Gtk.PageSet get_page_set (); + public double get_paper_height (Gtk.Unit unit); + public Gtk.PaperSize get_paper_size (); + public double get_paper_width (Gtk.Unit unit); + public Gtk.PrintPages get_print_pages (); + public string get_printer (); + public Gtk.PrintQuality get_quality (); + public int get_resolution (); + public bool get_reverse (); + public double get_scale (); + public GLib.Type get_type (); + public bool get_use_color (); + public bool has_key (string key); + public construct (); + public void @set (string key, string value); + public void set_bool (string key, bool value); + public void set_collate (bool collate); + public void set_default_source (string default_source); + public void set_dither (string dither); + public void set_double (string key, double value); + public void set_duplex (Gtk.PrintDuplex duplex); + public void set_finishings (string finishings); + public void set_int (string key, int value); + public void set_length (string key, double value, Gtk.Unit unit); + public void set_media_type (string media_type); + public void set_n_copies (int num_copies); + public void set_number_up (int number_up); + public void set_orientation (Gtk.PageOrientation orientation); + public void set_output_bin (string output_bin); + public void set_page_ranges (Gtk.PageRange page_ranges, int num_ranges); + public void set_page_set (Gtk.PageSet page_set); + public void set_paper_height (double height, Gtk.Unit unit); + public void set_paper_size (Gtk.PaperSize paper_size); + public void set_paper_width (double width, Gtk.Unit unit); + public void set_print_pages (Gtk.PrintPages pages); + public void set_printer (string printer); + public void set_quality (Gtk.PrintQuality quality); + public void set_resolution (int resolution); + public void set_reverse (bool reverse); + public void set_scale (double scale); + public void set_use_color (bool use_color); + public void unset (string key); + } + public class PrintUnixDialog : Gtk.Dialog { + public void add_custom_tab (Gtk.Widget child, Gtk.Widget tab_label); + public int get_current_page (); + public Gtk.PageSetup get_page_setup (); + public Gtk.Printer get_selected_printer (); + public Gtk.PrintSettings get_settings (); + public GLib.Type get_type (); + public construct (string title, Gtk.Window parent); + public void set_current_page (int current_page); + public void set_manual_capabilities (Gtk.PrintCapabilities capabilities); + public void set_page_setup (Gtk.PageSetup page_setup); + public void set_settings (Gtk.PrintSettings settings); + public weak Gtk.PageSetup page_setup { get; set; } + public weak int current_page { get; set; } + [NoAccessorMethod ()] + public weak Gtk.PrintSettings print_settings { get; set; } + public weak Gtk.Printer selected_printer { get; } + } + public class Progress : Gtk.Widget { + [NoAccessorMethod ()] + public weak bool activity_mode { get; set; } + [NoAccessorMethod ()] + public weak bool show_text { get; set; } + [NoAccessorMethod ()] + public weak float text_xalign { get; set; } + [NoAccessorMethod ()] + public weak float text_yalign { get; set; } + } + public class ProgressBar : Gtk.Progress { + public Pango.EllipsizeMode get_ellipsize (); + public double get_fraction (); + public Gtk.ProgressBarOrientation get_orientation (); + public double get_pulse_step (); + public string get_text (); + public GLib.Type get_type (); + public construct (); + public void pulse (); + public void set_ellipsize (Pango.EllipsizeMode mode); + public void set_fraction (double fraction); + public void set_orientation (Gtk.ProgressBarOrientation orientation); + public void set_pulse_step (double fraction); + public void set_text (string text); + [NoAccessorMethod ()] + public weak Gtk.Adjustment adjustment { get; set; } + public weak Gtk.ProgressBarOrientation orientation { get; set; } + [NoAccessorMethod ()] + public weak Gtk.ProgressBarStyle bar_style { get; set; } + [NoAccessorMethod ()] + public weak uint activity_step { get; set; } + [NoAccessorMethod ()] + public weak uint activity_blocks { get; set; } + [NoAccessorMethod ()] + public weak uint discrete_blocks { get; set; } + public weak double fraction { get; set; } + public weak double pulse_step { get; set; } + public weak string text { get; set; } + public weak Pango.EllipsizeMode ellipsize { get; set; } + } + public class RadioAction : Gtk.ToggleAction { + public int get_current_value (); + public GLib.SList get_group (); + public GLib.Type get_type (); + public construct (string name, string label, string tooltip, string stock_id, int value); + public void set_current_value (int current_value); + public void set_group (GLib.SList group); + [NoAccessorMethod ()] + public weak int value { get; set; } + public weak Gtk.RadioAction group { set; } + public weak int current_value { get; set; } + public signal void changed (Gtk.RadioAction current); + } + public class RadioButton : Gtk.CheckButton { + public GLib.SList get_group (); + public GLib.Type get_type (); + public construct (GLib.SList group); + public construct from_widget (); + public construct with_label (GLib.SList group, string label); + public construct with_label_from_widget (string label); + public construct with_mnemonic (GLib.SList group, string label); + public construct with_mnemonic_from_widget (string label); + public void set_group (GLib.SList group); + public weak Gtk.RadioButton group { set; } + public signal void group_changed (); + } + public class RadioMenuItem : Gtk.CheckMenuItem { + public GLib.SList get_group (); + public GLib.Type get_type (); + public construct (GLib.SList group); + public construct from_widget (); + public construct with_label (GLib.SList group, string label); + public construct with_label_from_widget (string label); + public construct with_mnemonic (GLib.SList group, string label); + public construct with_mnemonic_from_widget (string label); + public void set_group (GLib.SList group); + public weak Gtk.RadioMenuItem group { set; } + public signal void group_changed (); + } + public class RadioToolButton : Gtk.ToggleToolButton { + public GLib.SList get_group (); + public GLib.Type get_type (); + public construct (GLib.SList group); + public construct from_stock (GLib.SList group, string stock_id); + public construct from_widget (); + public construct with_stock_from_widget (string stock_id); + public void set_group (GLib.SList group); + public weak Gtk.RadioToolButton group { set; } + } + public class Range : Gtk.Widget { + public Gtk.Adjustment get_adjustment (); + public bool get_inverted (); + public Gtk.SensitivityType get_lower_stepper_sensitivity (); + public GLib.Type get_type (); + public Gtk.UpdateType get_update_policy (); + public Gtk.SensitivityType get_upper_stepper_sensitivity (); + public double get_value (); + public void set_adjustment (Gtk.Adjustment adjustment); + public void set_increments (double step, double page); + public void set_inverted (bool setting); + public void set_lower_stepper_sensitivity (Gtk.SensitivityType sensitivity); + public void set_range (double min, double max); + public void set_update_policy (Gtk.UpdateType policy); + public void set_upper_stepper_sensitivity (Gtk.SensitivityType sensitivity); + public void set_value (double value); + public weak Gtk.UpdateType update_policy { get; set; } + public weak Gtk.Adjustment adjustment { get; set construct; } + public weak bool inverted { get; set; } + public weak Gtk.SensitivityType lower_stepper_sensitivity { get; set; } + public weak Gtk.SensitivityType upper_stepper_sensitivity { get; set; } + public signal void value_changed (); + public signal void adjust_bounds (double new_value); + public signal void move_slider (Gtk.ScrollType scroll); + public signal bool change_value (Gtk.ScrollType scroll, double new_value); + } + public class RcStyle : GLib.Object { + public weak string name; + public weak string bg_pixmap_name; + public weak Pango.FontDescription font_desc; + public weak Gtk.RcFlags color_flags; + public weak Gdk.Color fg; + public weak Gdk.Color bg; + public weak Gdk.Color text; + public weak Gdk.Color @base; + public weak int xthickness; + public weak int ythickness; + public Gtk.RcStyle copy (); + public GLib.Type get_type (); + public construct (); + public void @ref (); + public void unref (); + } + public class RecentChooserDefault : Gtk.VBox, Gtk.RecentChooser { + } + public class RecentChooserDialog : Gtk.Dialog, Gtk.RecentChooser { + public GLib.Type get_type (); + public construct (string title, Gtk.Window parent, string first_button_text); + public construct for_manager (string title, Gtk.Window parent, Gtk.RecentManager manager, string first_button_text); + } + public class RecentChooserMenu : Gtk.Menu, Gtk.RecentChooser { + public bool get_show_numbers (); + public GLib.Type get_type (); + public construct (); + public construct for_manager (Gtk.RecentManager manager); + public void set_show_numbers (bool show_numbers); + public weak bool show_numbers { get; set; } + } + public class RecentChooserWidget : Gtk.VBox, Gtk.RecentChooser { + public GLib.Type get_type (); + public construct (); + public construct for_manager (Gtk.RecentManager manager); + } + public class RecentFilter : Gtk.Object { + public void add_age (int days); + public void add_application (string application); + public void add_custom (Gtk.RecentFilterFlags needed, Gtk.RecentFilterFunc func, pointer data, GLib.DestroyNotify data_destroy); + public void add_group (string group); + public void add_mime_type (string mime_type); + public void add_pattern (string pattern); + public void add_pixbuf_formats (); + public bool filter (Gtk.RecentFilterInfo filter_info); + public string get_name (); + public Gtk.RecentFilterFlags get_needed (); + public GLib.Type get_type (); + public construct (); + public void set_name (string name); + } + public class RecentManager : GLib.Object { + public bool add_full (string uri, Gtk.RecentData recent_data); + public bool add_item (string uri); + public GLib.Quark error_quark (); + public Gtk.RecentManager get_default (); + public static Gtk.RecentManager get_for_screen (Gdk.Screen screen); + public GLib.List get_items (); + public int get_limit (); + public GLib.Type get_type (); + public bool has_item (string uri); + public Gtk.RecentInfo lookup_item (string uri, GLib.Error error); + public bool move_item (string uri, string new_uri, GLib.Error error); + public construct (); + public int purge_items (GLib.Error error); + public bool remove_item (string uri, GLib.Error error); + public void set_limit (int limit); + public void set_screen (Gdk.Screen screen); + [NoAccessorMethod ()] + public weak string filename { get; construct; } + public weak int limit { get; set; } + [NoAccessorMethod ()] + public weak int size { get; } + public signal void changed (); + } + public class Ruler : Gtk.Widget { + public void draw_pos (); + public void draw_ticks (); + public Gtk.MetricType get_metric (); + public void get_range (double lower, double upper, double position, double max_size); + public GLib.Type get_type (); + public void set_metric (Gtk.MetricType metric); + public void set_range (double lower, double upper, double position, double max_size); + [NoAccessorMethod ()] + public weak double lower { get; set; } + [NoAccessorMethod ()] + public weak double upper { get; set; } + [NoAccessorMethod ()] + public weak double position { get; set; } + [NoAccessorMethod ()] + public weak double max_size { get; set; } + public weak Gtk.MetricType metric { get; set; } + } + public class Scale : Gtk.Range { + public int get_digits (); + public bool get_draw_value (); + public Pango.Layout get_layout (); + public void get_layout_offsets (int x, int y); + public GLib.Type get_type (); + public Gtk.PositionType get_value_pos (); + public void set_digits (int digits); + public void set_draw_value (bool draw_value); + public void set_value_pos (Gtk.PositionType pos); + public weak int digits { get; set; } + public weak bool draw_value { get; set; } + public weak Gtk.PositionType value_pos { get; set; } + public signal string format_value (double value); + } + public class Scrollbar : Gtk.Range { + public GLib.Type get_type (); + } + public class ScrolledWindow : Gtk.Bin { + public weak Gtk.Widget hscrollbar; + public weak Gtk.Widget vscrollbar; + public void add_with_viewport (Gtk.Widget child); + public Gtk.Adjustment get_hadjustment (); + public Gtk.Widget get_hscrollbar (); + public Gtk.CornerType get_placement (); + public void get_policy (Gtk.PolicyType hscrollbar_policy, Gtk.PolicyType vscrollbar_policy); + public Gtk.ShadowType get_shadow_type (); + public GLib.Type get_type (); + public Gtk.Adjustment get_vadjustment (); + public Gtk.Widget get_vscrollbar (); + public construct (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public void set_hadjustment (Gtk.Adjustment hadjustment); + public void set_placement (Gtk.CornerType window_placement); + public void set_policy (Gtk.PolicyType hscrollbar_policy, Gtk.PolicyType vscrollbar_policy); + public void set_shadow_type (Gtk.ShadowType type); + public void set_vadjustment (Gtk.Adjustment vadjustment); + public void unset_placement (); + public weak Gtk.Adjustment hadjustment { get; set construct; } + public weak Gtk.Adjustment vadjustment { get; set construct; } + [NoAccessorMethod ()] + public weak Gtk.PolicyType hscrollbar_policy { get; set; } + [NoAccessorMethod ()] + public weak Gtk.PolicyType vscrollbar_policy { get; set; } + [NoAccessorMethod ()] + public weak Gtk.CornerType window_placement { get; set; } + [NoAccessorMethod ()] + public weak bool window_placement_set { get; set; } + public weak Gtk.ShadowType shadow_type { get; set; } + public signal void scroll_child (Gtk.ScrollType scroll, bool horizontal); + public signal void move_focus_out (Gtk.DirectionType direction); + } + public class Separator : Gtk.Widget { + public GLib.Type get_type (); + } + public class SeparatorMenuItem : Gtk.MenuItem { + public GLib.Type get_type (); + public construct (); + } + public class SeparatorToolItem : Gtk.ToolItem { + public bool get_draw (); + public GLib.Type get_type (); + public construct (); + public void set_draw (bool draw); + public weak bool draw { get; set; } + } + public class Settings : GLib.Object { + public Gtk.Settings get_default (); + public static Gtk.Settings get_for_screen (Gdk.Screen screen); + public GLib.Type get_type (); + public static void install_property (GLib.ParamSpec pspec); + public static void install_property_parser (GLib.ParamSpec pspec, Gtk.RcPropertyParser parser); + public void set_double_property (string name, double v_double, string origin); + public void set_long_property (string name, long v_long, string origin); + public void set_property_value (string name, Gtk.SettingsValue svalue); + public void set_string_property (string name, string v_string, string origin); + [NoAccessorMethod ()] + public weak GLib.HashTable color_hash { get; } + } + public class SizeGroup : GLib.Object { + public void add_widget (Gtk.Widget widget); + public bool get_ignore_hidden (); + public Gtk.SizeGroupMode get_mode (); + public GLib.Type get_type (); + public GLib.SList get_widgets (); + public construct (Gtk.SizeGroupMode mode); + public void remove_widget (Gtk.Widget widget); + public void set_ignore_hidden (bool ignore_hidden); + public void set_mode (Gtk.SizeGroupMode mode); + public weak Gtk.SizeGroupMode mode { get; set; } + public weak bool ignore_hidden { get; set; } + } + public class Socket : Gtk.Container { + public void add_id (pointer window_id); + public pointer get_id (); + public GLib.Type get_type (); + public construct (); + public signal void plug_added (); + public signal bool plug_removed (); + } + public class SpinButton : Gtk.Entry, Gtk.Editable { + public void configure (Gtk.Adjustment adjustment, double climb_rate, uint digits); + public Gtk.Adjustment get_adjustment (); + public uint get_digits (); + public void get_increments (double step, double page); + public bool get_numeric (); + public void get_range (double min, double max); + public bool get_snap_to_ticks (); + public GLib.Type get_type (); + public Gtk.SpinButtonUpdatePolicy get_update_policy (); + public double get_value (); + public int get_value_as_int (); + public bool get_wrap (); + public construct (Gtk.Adjustment adjustment, double climb_rate, uint digits); + public construct with_range (double min, double max, double step); + public void set_adjustment (Gtk.Adjustment adjustment); + public void set_digits (uint digits); + public void set_increments (double step, double page); + public void set_numeric (bool numeric); + public void set_range (double min, double max); + public void set_snap_to_ticks (bool snap_to_ticks); + public void set_update_policy (Gtk.SpinButtonUpdatePolicy policy); + public void set_value (double value); + public void set_wrap (bool wrap); + public void spin (Gtk.SpinType direction, double increment); + public void update (); + public weak Gtk.Adjustment adjustment { get; set; } + [NoAccessorMethod ()] + public weak double climb_rate { get; set; } + public weak uint digits { get; set; } + public weak bool snap_to_ticks { get; set; } + public weak bool numeric { get; set; } + public weak bool wrap { get; set; } + public weak Gtk.SpinButtonUpdatePolicy update_policy { get; set; } + public weak double value { get; set; } + public signal int input (double new_value); + public signal int output (); + public signal void value_changed (); + public signal void wrapped (); + public signal void change_value (Gtk.ScrollType scroll); + } + public class Statusbar : Gtk.HBox { + public uint get_context_id (string context_description); + public bool get_has_resize_grip (); + public GLib.Type get_type (); + public construct (); + public void pop (uint context_id); + public uint push (uint context_id, string text); + public void remove (uint context_id, uint message_id); + public void set_has_resize_grip (bool setting); + public weak bool has_resize_grip { get; set; } + public signal void text_pushed (uint context_id, string text); + public signal void text_popped (uint context_id, string text); + } + public class StatusIcon : GLib.Object { + public bool get_blinking (); + public bool get_geometry (Gdk.Screen screen, Gdk.Rectangle area, Gtk.Orientation orientation); + public string get_icon_name (); + public Gdk.Pixbuf get_pixbuf (); + public int get_size (); + public string get_stock (); + public Gtk.ImageType get_storage_type (); + public GLib.Type get_type (); + public bool get_visible (); + public bool is_embedded (); + public construct (); + public construct from_file (string filename); + public construct from_icon_name (string icon_name); + public construct from_pixbuf (Gdk.Pixbuf pixbuf); + public construct from_stock (string stock_id); + public static void position_menu (Gtk.Menu menu, int x, int y, bool push_in, pointer user_data); + public void set_blinking (bool blinking); + public void set_from_file (string filename); + public void set_from_icon_name (string icon_name); + public void set_from_pixbuf (Gdk.Pixbuf pixbuf); + public void set_from_stock (string stock_id); + public void set_tooltip (string tooltip_text); + public void set_visible (bool visible); + [NoAccessorMethod ()] + public weak Gdk.Pixbuf pixbuf { get; set; } + [NoAccessorMethod ()] + public weak string file { set; } + [NoAccessorMethod ()] + public weak string stock { get; set; } + [NoAccessorMethod ()] + public weak string icon_name { get; set; } + public weak Gtk.ImageType storage_type { get; } + public weak int size { get; } + public weak bool blinking { get; set; } + public weak bool visible { get; set; } + public signal void activate (); + public signal void popup_menu (uint button, uint activate_time); + public signal bool size_changed (int size); + } + public class Style : GLib.Object { + public weak Gdk.Color fg; + public weak Gdk.Color bg; + public weak Gdk.Color light; + public weak Gdk.Color dark; + public weak Gdk.Color mid; + public weak Gdk.Color text; + public weak Gdk.Color @base; + public weak Gdk.Color text_aa; + public weak Gdk.Color black; + public weak Gdk.Color white; + public weak Pango.FontDescription font_desc; + public weak int xthickness; + public weak int ythickness; + public weak Gdk.GC fg_gc; + public weak Gdk.GC bg_gc; + public weak Gdk.GC light_gc; + public weak Gdk.GC dark_gc; + public weak Gdk.GC mid_gc; + public weak Gdk.GC text_gc; + public weak Gdk.GC base_gc; + public weak Gdk.GC text_aa_gc; + public weak Gdk.GC black_gc; + public weak Gdk.GC white_gc; + public weak Gdk.Pixmap bg_pixmap; + public void apply_default_background (Gdk.Window window, bool set_bg, Gtk.StateType state_type, Gdk.Rectangle area, int x, int y, int width, int height); + public Gtk.Style attach (Gdk.Window window); + public Gtk.Style copy (); + public void detach (); + public GLib.Type get_type (); + public bool lookup_color (string color_name, Gdk.Color color); + public Gtk.IconSet lookup_icon_set (string stock_id); + public construct (); + public Gdk.Pixbuf render_icon (Gtk.IconSource source, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail); + public void set_background (Gdk.Window window, Gtk.StateType state_type); + public signal void realize (); + public signal void unrealize (); + } + public class Table : Gtk.Container { + public void attach (Gtk.Widget child, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach, Gtk.AttachOptions xoptions, Gtk.AttachOptions yoptions, uint xpadding, uint ypadding); + public void attach_defaults (Gtk.Widget widget, uint left_attach, uint right_attach, uint top_attach, uint bottom_attach); + public uint get_col_spacing (uint column); + public uint get_default_col_spacing (); + public uint get_default_row_spacing (); + public bool get_homogeneous (); + public uint get_row_spacing (uint row); + public GLib.Type get_type (); + public construct (uint rows, uint columns, bool homogeneous); + public void resize (uint rows, uint columns); + public void set_col_spacing (uint column, uint spacing); + public void set_col_spacings (uint spacing); + public void set_homogeneous (bool homogeneous); + public void set_row_spacing (uint row, uint spacing); + public void set_row_spacings (uint spacing); + [NoAccessorMethod ()] + public weak uint n_rows { get; set; } + [NoAccessorMethod ()] + public weak uint n_columns { get; set; } + public weak uint row_spacing { get; set; } + [NoAccessorMethod ()] + public weak uint column_spacing { get; set; } + public weak bool homogeneous { get; set; } + } + public class TearoffMenuItem : Gtk.MenuItem { + public GLib.Type get_type (); + public construct (); + } + public class TextBuffer : GLib.Object { + public void add_selection_clipboard (Gtk.Clipboard clipboard); + public void apply_tag_by_name (string name, Gtk.TextIter start, Gtk.TextIter end); + public bool backspace (Gtk.TextIter iter, bool interactive, bool default_editable); + public void copy_clipboard (Gtk.Clipboard clipboard); + public Gtk.TextChildAnchor create_child_anchor (Gtk.TextIter iter); + public Gtk.TextMark create_mark (string mark_name, Gtk.TextIter where, bool left_gravity); + public Gtk.TextTag create_tag (string tag_name, string first_property_name); + public void cut_clipboard (Gtk.Clipboard clipboard, bool default_editable); + public void delete (Gtk.TextIter start, Gtk.TextIter end); + public bool delete_interactive (Gtk.TextIter start_iter, Gtk.TextIter end_iter, bool default_editable); + public void delete_mark (Gtk.TextMark mark); + public void delete_mark_by_name (string name); + public bool delete_selection (bool interactive, bool default_editable); + public bool deserialize (Gtk.TextBuffer content_buffer, Gdk.Atom format, Gtk.TextIter iter, uchar data, ulong length, GLib.Error error); + public bool deserialize_get_can_create_tags (Gdk.Atom format); + public void deserialize_set_can_create_tags (Gdk.Atom format, bool can_create_tags); + public void get_bounds (Gtk.TextIter start, Gtk.TextIter end); + public int get_char_count (); + public Gtk.TargetList get_copy_target_list (); + public Gdk.Atom get_deserialize_formats (int n_formats); + public void get_end_iter (Gtk.TextIter iter); + public bool get_has_selection (); + public Gtk.TextMark get_insert (); + public void get_iter_at_child_anchor (Gtk.TextIter iter, Gtk.TextChildAnchor anchor); + public void get_iter_at_line (Gtk.TextIter iter, int line_number); + public void get_iter_at_line_index (Gtk.TextIter iter, int line_number, int byte_index); + public void get_iter_at_line_offset (Gtk.TextIter iter, int line_number, int char_offset); + public void get_iter_at_mark (Gtk.TextIter iter, Gtk.TextMark mark); + public void get_iter_at_offset (Gtk.TextIter iter, int char_offset); + public int get_line_count (); + public Gtk.TextMark get_mark (string name); + public bool get_modified (); + public Gtk.TargetList get_paste_target_list (); + public Gtk.TextMark get_selection_bound (); + public bool get_selection_bounds (Gtk.TextIter start, Gtk.TextIter end); + public Gdk.Atom get_serialize_formats (int n_formats); + public string get_slice (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars); + public void get_start_iter (Gtk.TextIter iter); + public Gtk.TextTagTable get_tag_table (); + public string get_text (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars); + public GLib.Type get_type (); + public void insert (Gtk.TextIter iter, string text, int len); + public void insert_at_cursor (string text, int len); + public bool insert_interactive (Gtk.TextIter iter, string text, int len, bool default_editable); + public bool insert_interactive_at_cursor (string text, int len, bool default_editable); + public void insert_range (Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end); + public bool insert_range_interactive (Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end, bool default_editable); + public void insert_with_tags (Gtk.TextIter iter, string text, int len, Gtk.TextTag first_tag); + public void insert_with_tags_by_name (Gtk.TextIter iter, string text, int len, string first_tag_name); + public void move_mark (Gtk.TextMark mark, Gtk.TextIter where); + public void move_mark_by_name (string name, Gtk.TextIter where); + public construct (Gtk.TextTagTable table); + public void paste_clipboard (Gtk.Clipboard clipboard, Gtk.TextIter override_location, bool default_editable); + public void place_cursor (Gtk.TextIter where); + public Gdk.Atom register_deserialize_format (string mime_type, Gtk.TextBufferDeserializeFunc function, pointer user_data, GLib.DestroyNotify user_data_destroy); + public Gdk.Atom register_deserialize_tagset (string tagset_name); + public Gdk.Atom register_serialize_format (string mime_type, Gtk.TextBufferSerializeFunc function, pointer user_data, GLib.DestroyNotify user_data_destroy); + public Gdk.Atom register_serialize_tagset (string tagset_name); + public void remove_all_tags (Gtk.TextIter start, Gtk.TextIter end); + public void remove_selection_clipboard (Gtk.Clipboard clipboard); + public void remove_tag_by_name (string name, Gtk.TextIter start, Gtk.TextIter end); + public void select_range (Gtk.TextIter ins, Gtk.TextIter bound); + public uchar serialize (Gtk.TextBuffer content_buffer, Gdk.Atom format, Gtk.TextIter start, Gtk.TextIter end, ulong length); + public void set_modified (bool setting); + public void set_text (string text, int len); + public void unregister_deserialize_format (Gdk.Atom format); + public void unregister_serialize_format (Gdk.Atom format); + [NoAccessorMethod ()] + public weak Gtk.TextTagTable tag_table { get; construct; } + public weak string text { get; set; } + public weak bool has_selection { get; } + [NoAccessorMethod ()] + public weak int cursor_position { get; } + public weak Gtk.TargetList copy_target_list { get; } + public weak Gtk.TargetList paste_target_list { get; } + public signal void insert_text (Gtk.TextIter pos, string text, int length); + [HasEmitter ()] + public signal void insert_pixbuf (Gtk.TextIter pos, Gdk.Pixbuf pixbuf); + [HasEmitter ()] + public signal void insert_child_anchor (Gtk.TextIter pos, Gtk.TextChildAnchor anchor); + public signal void delete_range (Gtk.TextIter start, Gtk.TextIter end); + public signal void changed (); + public signal void modified_changed (); + public signal void mark_set (Gtk.TextIter location, Gtk.TextMark mark); + public signal void mark_deleted (Gtk.TextMark mark); + [HasEmitter ()] + public signal void apply_tag (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char); + [HasEmitter ()] + public signal void remove_tag (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char); + [HasEmitter ()] + public signal void begin_user_action (); + [HasEmitter ()] + public signal void end_user_action (); + } + public class TextChildAnchor : GLib.Object { + public bool get_deleted (); + public GLib.Type get_type (); + public GLib.List get_widgets (); + public construct (); + } + public class TextMark : GLib.Object { + public Gtk.TextBuffer get_buffer (); + public bool get_deleted (); + public bool get_left_gravity (); + public string get_name (); + public GLib.Type get_type (); + public bool get_visible (); + public void set_visible (bool setting); + } + public class TextTag : GLib.Object { + public int get_priority (); + public GLib.Type get_type (); + public construct (string name); + public void set_priority (int priority); + [NoAccessorMethod ()] + public weak string name { get; construct; } + [NoAccessorMethod ()] + public weak string background { set; } + [NoAccessorMethod ()] + public weak Gdk.Color background_gdk { get; set; } + [NoAccessorMethod ()] + public weak bool background_full_height { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixmap background_stipple { get; set; } + [NoAccessorMethod ()] + public weak string foreground { set; } + [NoAccessorMethod ()] + public weak Gdk.Color foreground_gdk { get; set; } + [NoAccessorMethod ()] + public weak Gdk.Pixmap foreground_stipple { get; set; } + [NoAccessorMethod ()] + public weak Gtk.TextDirection direction { get; set; } + [NoAccessorMethod ()] + public weak bool editable { get; set; } + [NoAccessorMethod ()] + public weak string font { get; set; } + [NoAccessorMethod ()] + public weak Pango.FontDescription font_desc { get; set; } + [NoAccessorMethod ()] + public weak string family { get; set; } + [NoAccessorMethod ()] + public weak Pango.Style style { get; set; } + [NoAccessorMethod ()] + public weak Pango.Variant variant { get; set; } + [NoAccessorMethod ()] + public weak int weight { get; set; } + [NoAccessorMethod ()] + public weak Pango.Stretch stretch { get; set; } + [NoAccessorMethod ()] + public weak int size { get; set; } + [NoAccessorMethod ()] + public weak double scale { get; set; } + [NoAccessorMethod ()] + public weak double size_points { get; set; } + [NoAccessorMethod ()] + public weak Gtk.Justification justification { get; set; } + [NoAccessorMethod ()] + public weak string language { get; set; } + [NoAccessorMethod ()] + public weak int left_margin { get; set; } + [NoAccessorMethod ()] + public weak int right_margin { get; set; } + [NoAccessorMethod ()] + public weak int indent { get; set; } + [NoAccessorMethod ()] + public weak int rise { get; set; } + [NoAccessorMethod ()] + public weak int pixels_above_lines { get; set; } + [NoAccessorMethod ()] + public weak int pixels_below_lines { get; set; } + [NoAccessorMethod ()] + public weak int pixels_inside_wrap { get; set; } + [NoAccessorMethod ()] + public weak bool strikethrough { get; set; } + [NoAccessorMethod ()] + public weak Pango.Underline underline { get; set; } + [NoAccessorMethod ()] + public weak Gtk.WrapMode wrap_mode { get; set; } + [NoAccessorMethod ()] + public weak Pango.TabArray tabs { get; set; } + [NoAccessorMethod ()] + public weak bool invisible { get; set; } + [NoAccessorMethod ()] + public weak string paragraph_background { set; } + [NoAccessorMethod ()] + public weak Gdk.Color paragraph_background_gdk { get; set; } + [HasEmitter ()] + public signal bool event (GLib.Object event_object, Gdk.Event event, Gtk.TextIter iter); + } + public class TextTagTable : GLib.Object { + public void add (Gtk.TextTag tag); + public void @foreach (Gtk.TextTagTableForeach func, pointer data); + public int get_size (); + public GLib.Type get_type (); + public Gtk.TextTag lookup (string name); + public construct (); + public void remove (Gtk.TextTag tag); + public signal void tag_changed (Gtk.TextTag tag, bool size_changed); + public signal void tag_added (Gtk.TextTag tag); + public signal void tag_removed (Gtk.TextTag tag); + } + public class TextView : Gtk.Container { + public void add_child_at_anchor (Gtk.Widget child, Gtk.TextChildAnchor anchor); + public void add_child_in_window (Gtk.Widget child, Gtk.TextWindowType which_window, int xpos, int ypos); + public bool backward_display_line (Gtk.TextIter iter); + public bool backward_display_line_start (Gtk.TextIter iter); + public void buffer_to_window_coords (Gtk.TextWindowType win, int buffer_x, int buffer_y, int window_x, int window_y); + public bool forward_display_line (Gtk.TextIter iter); + public bool forward_display_line_end (Gtk.TextIter iter); + public bool get_accepts_tab (); + public int get_border_window_size (Gtk.TextWindowType type); + public Gtk.TextBuffer get_buffer (); + public bool get_cursor_visible (); + public Gtk.TextAttributes get_default_attributes (); + public bool get_editable (); + public int get_indent (); + public void get_iter_at_location (Gtk.TextIter iter, int x, int y); + public void get_iter_at_position (Gtk.TextIter iter, int trailing, int x, int y); + public void get_iter_location (Gtk.TextIter iter, Gdk.Rectangle location); + public Gtk.Justification get_justification (); + public int get_left_margin (); + public void get_line_at_y (Gtk.TextIter target_iter, int y, int line_top); + public void get_line_yrange (Gtk.TextIter iter, int y, int height); + public bool get_overwrite (); + public int get_pixels_above_lines (); + public int get_pixels_below_lines (); + public int get_pixels_inside_wrap (); + public int get_right_margin (); + public Pango.TabArray get_tabs (); + public GLib.Type get_type (); + public void get_visible_rect (Gdk.Rectangle visible_rect); + public Gdk.Window get_window (Gtk.TextWindowType win); + public Gtk.TextWindowType get_window_type (Gdk.Window window); + public Gtk.WrapMode get_wrap_mode (); + public void move_child (Gtk.Widget child, int xpos, int ypos); + public bool move_mark_onscreen (Gtk.TextMark mark); + public bool move_visually (Gtk.TextIter iter, int count); + public construct (); + public construct with_buffer (Gtk.TextBuffer buffer); + public bool place_cursor_onscreen (); + public void scroll_mark_onscreen (Gtk.TextMark mark); + public bool scroll_to_iter (Gtk.TextIter iter, double within_margin, bool use_align, double xalign, double yalign); + public void scroll_to_mark (Gtk.TextMark mark, double within_margin, bool use_align, double xalign, double yalign); + public void set_accepts_tab (bool accepts_tab); + public void set_border_window_size (Gtk.TextWindowType type, int size); + public void set_buffer (Gtk.TextBuffer buffer); + public void set_cursor_visible (bool setting); + public void set_editable (bool setting); + public void set_indent (int indent); + public void set_justification (Gtk.Justification justification); + public void set_left_margin (int left_margin); + public void set_overwrite (bool overwrite); + public void set_pixels_above_lines (int pixels_above_lines); + public void set_pixels_below_lines (int pixels_below_lines); + public void set_pixels_inside_wrap (int pixels_inside_wrap); + public void set_right_margin (int right_margin); + public void set_tabs (Pango.TabArray tabs); + public void set_wrap_mode (Gtk.WrapMode wrap_mode); + public bool starts_display_line (Gtk.TextIter iter); + public void window_to_buffer_coords (Gtk.TextWindowType win, int window_x, int window_y, int buffer_x, int buffer_y); + public weak int pixels_above_lines { get; set; } + public weak int pixels_below_lines { get; set; } + public weak int pixels_inside_wrap { get; set; } + public weak bool editable { get; set; } + public weak Gtk.WrapMode wrap_mode { get; set; } + public weak Gtk.Justification justification { get; set; } + public weak int left_margin { get; set; } + public weak int right_margin { get; set; } + public weak int indent { get; set; } + public weak Pango.TabArray tabs { get; set; } + public weak bool cursor_visible { get; set; } + public weak Gtk.TextBuffer buffer { get; set; } + public weak bool overwrite { get; set; } + public weak bool accepts_tab { get; set; } + public signal void move_cursor (Gtk.MovementStep step, int count, bool extend_selection); + public signal void page_horizontally (int count, bool extend_selection); + public signal void set_anchor (); + public signal void insert_at_cursor (string str); + public signal void delete_from_cursor (Gtk.DeleteType type, int count); + public signal void backspace (); + public signal void cut_clipboard (); + public signal void copy_clipboard (); + public signal void paste_clipboard (); + public signal void toggle_overwrite (); + public signal void move_focus (Gtk.DirectionType direction); + public signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public signal void populate_popup (Gtk.Menu menu); + } + public class ToggleAction : Gtk.Action { + public bool get_active (); + public bool get_draw_as_radio (); + public GLib.Type get_type (); + public construct (string name, string label, string tooltip, string stock_id); + public void set_active (bool is_active); + public void set_draw_as_radio (bool draw_as_radio); + public weak bool draw_as_radio { get; set; } + public weak bool active { get; set; } + [HasEmitter ()] + public signal void toggled (); + } + public class ToggleButton : Gtk.Button { + public bool get_active (); + public bool get_inconsistent (); + public bool get_mode (); + public GLib.Type get_type (); + public construct (); + public construct with_label (string label); + public construct with_mnemonic (string label); + public void set_active (bool is_active); + public void set_inconsistent (bool setting); + public void set_mode (bool draw_indicator); + public weak bool active { get; set; } + public weak bool inconsistent { get; set; } + [NoAccessorMethod ()] + public weak bool draw_indicator { get; set; } + [HasEmitter ()] + public signal void toggled (); + } + public class ToggleToolButton : Gtk.ToolButton { + public bool get_active (); + public GLib.Type get_type (); + public construct (); + public construct from_stock (string stock_id); + public void set_active (bool is_active); + public weak bool active { get; set; } + public signal void toggled (); + } + public class Toolbar : Gtk.Container { + public weak int num_children; + public weak GLib.List children; + public weak Gtk.ToolbarStyle style; + public int get_drop_index (int x, int y); + public Gtk.IconSize get_icon_size (); + public int get_item_index (Gtk.ToolItem item); + public int get_n_items (); + public Gtk.ToolItem get_nth_item (int n); + public Gtk.Orientation get_orientation (); + public Gtk.ReliefStyle get_relief_style (); + public bool get_show_arrow (); + public Gtk.ToolbarStyle get_style (); + public bool get_tooltips (); + public GLib.Type get_type (); + public void insert (Gtk.ToolItem item, int pos); + public construct (); + public void set_drop_highlight_item (Gtk.ToolItem tool_item, int index_); + public void set_orientation (Gtk.Orientation orientation); + public void set_show_arrow (bool show_arrow); + public void set_style (Gtk.ToolbarStyle style); + public void set_tooltips (bool enable); + public void unset_style (); + public weak Gtk.Orientation orientation { get; set; } + [NoAccessorMethod ()] + public weak Gtk.ToolbarStyle toolbar_style { get; set; } + public weak bool show_arrow { get; set; } + public weak bool tooltips { get; set; } + [NoAccessorMethod ()] + public weak Gtk.IconSize icon_size { get; set; } + [NoAccessorMethod ()] + public weak bool icon_size_set { get; set; } + public signal void orientation_changed (Gtk.Orientation orientation); + public signal void style_changed (Gtk.ToolbarStyle style); + public signal bool popup_context_menu (int x, int y, int button_number); + } + public class Tooltips : Gtk.Object { + public void disable (); + public void enable (); + public void force_window (); + public static bool get_info_from_tip_window (Gtk.Window tip_window, Gtk.Tooltips tooltips, Gtk.Widget current_widget); + public GLib.Type get_type (); + public construct (); + public void set_tip (Gtk.Widget widget, string tip_text, string tip_private); + } + public class ToolButton : Gtk.ToolItem { + public string get_icon_name (); + public Gtk.Widget get_icon_widget (); + public string get_label (); + public Gtk.Widget get_label_widget (); + public string get_stock_id (); + public GLib.Type get_type (); + public bool get_use_underline (); + public construct (Gtk.Widget icon_widget, string label); + public construct from_stock (string stock_id); + public void set_icon_name (string icon_name); + public void set_icon_widget (Gtk.Widget icon_widget); + public void set_label (string label); + public void set_label_widget (Gtk.Widget label_widget); + public void set_stock_id (string stock_id); + public void set_use_underline (bool use_underline); + public weak string label { get; set; } + public weak bool use_underline { get; set; } + public weak Gtk.Widget label_widget { get; set; } + public weak string stock_id { get; set; } + public weak string icon_name { get; set; } + public weak Gtk.Widget icon_widget { get; set; } + public signal void clicked (); + } + public class ToolItem : Gtk.Bin { + public bool get_expand (); + public bool get_homogeneous (); + public Gtk.IconSize get_icon_size (); + public bool get_is_important (); + public Gtk.Orientation get_orientation (); + public Gtk.Widget get_proxy_menu_item (string menu_item_id); + public Gtk.ReliefStyle get_relief_style (); + public Gtk.ToolbarStyle get_toolbar_style (); + public GLib.Type get_type (); + public bool get_use_drag_window (); + public bool get_visible_horizontal (); + public bool get_visible_vertical (); + public construct (); + public void rebuild_menu (); + public Gtk.Widget retrieve_proxy_menu_item (); + public void set_expand (bool expand); + public void set_homogeneous (bool homogeneous); + public void set_is_important (bool is_important); + public void set_proxy_menu_item (string menu_item_id, Gtk.Widget menu_item); + public void set_use_drag_window (bool use_drag_window); + public void set_visible_horizontal (bool visible_horizontal); + public void set_visible_vertical (bool visible_vertical); + public weak bool visible_horizontal { get; set; } + public weak bool visible_vertical { get; set; } + public weak bool is_important { get; set; } + public signal bool create_menu_proxy (); + public signal void toolbar_reconfigured (); + [HasEmitter ()] + public signal bool set_tooltip (Gtk.Tooltips tooltips, string tip_text, string tip_private); + } + public class TrayIcon : Gtk.Plug { + public GLib.Type get_type (); + [NoAccessorMethod ()] + public weak Gtk.Orientation orientation { get; } + } + public class TreeModelFilter : GLib.Object, Gtk.TreeModel, Gtk.TreeDragSource { + public void clear_cache (); + public bool convert_child_iter_to_iter (Gtk.TreeIter filter_iter, Gtk.TreeIter child_iter); + public Gtk.TreePath convert_child_path_to_path (Gtk.TreePath child_path); + public void convert_iter_to_child_iter (Gtk.TreeIter child_iter, Gtk.TreeIter filter_iter); + public Gtk.TreePath convert_path_to_child_path (Gtk.TreePath filter_path); + public Gtk.TreeModel get_model (); + public GLib.Type get_type (); + public construct (Gtk.TreeModel child_model, Gtk.TreePath root); + public void refilter (); + public void set_modify_func (int n_columns, GLib.Type types, Gtk.TreeModelFilterModifyFunc func, pointer data, Gtk.DestroyNotify destroy); + public void set_visible_column (int column); + public void set_visible_func (Gtk.TreeModelFilterVisibleFunc func, pointer data, Gtk.DestroyNotify destroy); + [NoAccessorMethod ()] + public weak Gtk.TreeModel child_model { get; construct; } + [NoAccessorMethod ()] + public weak Gtk.TreePath virtual_root { get; construct; } + } + public class TreeModelSort : GLib.Object, Gtk.TreeModel, Gtk.TreeSortable, Gtk.TreeDragSource { + public void clear_cache (); + public void convert_child_iter_to_iter (Gtk.TreeIter sort_iter, Gtk.TreeIter child_iter); + public Gtk.TreePath convert_child_path_to_path (Gtk.TreePath child_path); + public void convert_iter_to_child_iter (Gtk.TreeIter child_iter, Gtk.TreeIter sorted_iter); + public Gtk.TreePath convert_path_to_child_path (Gtk.TreePath sorted_path); + public Gtk.TreeModel get_model (); + public GLib.Type get_type (); + public bool iter_is_valid (Gtk.TreeIter iter); + public construct with_model (Gtk.TreeModel child_model); + public void reset_default_sort_func (); + [NoAccessorMethod ()] + public weak Gtk.TreeModel model { get; construct; } + } + public class TreeSelection : GLib.Object { + public int count_selected_rows (); + public Gtk.SelectionMode get_mode (); + public bool get_selected (Gtk.TreeModel model, Gtk.TreeIter iter); + public GLib.List get_selected_rows (Gtk.TreeModel model); + public Gtk.TreeView get_tree_view (); + public GLib.Type get_type (); + public pointer get_user_data (); + public bool iter_is_selected (Gtk.TreeIter iter); + public bool path_is_selected (Gtk.TreePath path); + public void select_all (); + public void select_iter (Gtk.TreeIter iter); + public void select_path (Gtk.TreePath path); + public void select_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public void selected_foreach (Gtk.TreeSelectionForeachFunc func, pointer data); + public void set_mode (Gtk.SelectionMode type); + public void set_select_function (Gtk.TreeSelectionFunc func, pointer data, Gtk.DestroyNotify destroy); + public void unselect_all (); + public void unselect_iter (Gtk.TreeIter iter); + public void unselect_path (Gtk.TreePath path); + public void unselect_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public signal void changed (); + } + public class TreeStore : GLib.Object, Gtk.TreeModel, Gtk.TreeDragSource, Gtk.TreeDragDest, Gtk.TreeSortable { + public void append (Gtk.TreeIter iter, Gtk.TreeIter parent); + public void clear (); + public GLib.Type get_type (); + public void insert (Gtk.TreeIter iter, Gtk.TreeIter parent, int position); + public void insert_after (Gtk.TreeIter iter, Gtk.TreeIter parent, Gtk.TreeIter sibling); + public void insert_before (Gtk.TreeIter iter, Gtk.TreeIter parent, Gtk.TreeIter sibling); + public void insert_with_values (Gtk.TreeIter iter, Gtk.TreeIter parent, int position); + public void insert_with_valuesv (Gtk.TreeIter iter, Gtk.TreeIter parent, int position, int columns, GLib.Value values, int n_values); + public bool is_ancestor (Gtk.TreeIter iter, Gtk.TreeIter descendant); + public int iter_depth (Gtk.TreeIter iter); + public bool iter_is_valid (Gtk.TreeIter iter); + public void move_after (Gtk.TreeIter iter, Gtk.TreeIter position); + public void move_before (Gtk.TreeIter iter, Gtk.TreeIter position); + public construct (int n_columns); + public construct newv (int n_columns, GLib.Type types); + public void prepend (Gtk.TreeIter iter, Gtk.TreeIter parent); + public bool remove (Gtk.TreeIter iter); + public void reorder (Gtk.TreeIter parent, int new_order); + public void @set (Gtk.TreeIter iter); + public void set_column_types (int n_columns, GLib.Type types); + public void set_valist (Gtk.TreeIter iter, pointer var_args); + public void set_value (Gtk.TreeIter iter, int column, GLib.Value value); + public void swap (Gtk.TreeIter a, Gtk.TreeIter b); + } + public class TreeView : Gtk.Container { + public int append_column (Gtk.TreeViewColumn column); + public void collapse_all (); + public bool collapse_row (Gtk.TreePath path); + public void columns_autosize (); + public Gdk.Pixmap create_row_drag_icon (Gtk.TreePath path); + public void enable_model_drag_dest (Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public void enable_model_drag_source (Gdk.ModifierType start_button_mask, Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public void expand_all (); + public bool expand_row (Gtk.TreePath path, bool open_all); + public void expand_to_path (Gtk.TreePath path); + public void get_background_area (Gtk.TreePath path, Gtk.TreeViewColumn column, Gdk.Rectangle rect); + public Gdk.Window get_bin_window (); + public void get_cell_area (Gtk.TreePath path, Gtk.TreeViewColumn column, Gdk.Rectangle rect); + public Gtk.TreeViewColumn get_column (int n); + public GLib.List get_columns (); + public void get_cursor (Gtk.TreePath path, Gtk.TreeViewColumn focus_column); + public bool get_dest_row_at_pos (int drag_x, int drag_y, Gtk.TreePath path, Gtk.TreeViewDropPosition pos); + public void get_drag_dest_row (Gtk.TreePath path, Gtk.TreeViewDropPosition pos); + public bool get_enable_search (); + public bool get_enable_tree_lines (); + public Gtk.TreeViewColumn get_expander_column (); + public bool get_fixed_height_mode (); + public Gtk.TreeViewGridLines get_grid_lines (); + public Gtk.Adjustment get_hadjustment (); + public bool get_headers_clickable (); + public bool get_headers_visible (); + public bool get_hover_expand (); + public bool get_hover_selection (); + public Gtk.TreeModel get_model (); + public bool get_path_at_pos (int x, int y, Gtk.TreePath path, Gtk.TreeViewColumn column, int cell_x, int cell_y); + public bool get_reorderable (); + public Gtk.TreeViewRowSeparatorFunc get_row_separator_func (); + public bool get_rubber_banding (); + public bool get_rules_hint (); + public int get_search_column (); + public Gtk.Entry get_search_entry (); + public Gtk.TreeViewSearchEqualFunc get_search_equal_func (); + public Gtk.TreeViewSearchPositionFunc get_search_position_func (); + public Gtk.TreeSelection get_selection (); + public GLib.Type get_type (); + public Gtk.Adjustment get_vadjustment (); + public bool get_visible_range (Gtk.TreePath start_path, Gtk.TreePath end_path); + public void get_visible_rect (Gdk.Rectangle visible_rect); + public int insert_column (Gtk.TreeViewColumn column, int position); + public int insert_column_with_attributes (int position, string title, Gtk.CellRenderer cell); + public int insert_column_with_data_func (int position, string title, Gtk.CellRenderer cell, Gtk.TreeCellDataFunc func, pointer data, GLib.DestroyNotify dnotify); + public void map_expanded_rows (Gtk.TreeViewMappingFunc func, pointer data); + public GLib.Type mode_get_type (); + public void move_column_after (Gtk.TreeViewColumn column, Gtk.TreeViewColumn base_column); + public construct (); + public construct with_model (Gtk.TreeModel model); + public int remove_column (Gtk.TreeViewColumn column); + public void scroll_to_cell (Gtk.TreePath path, Gtk.TreeViewColumn column, bool use_align, float row_align, float col_align); + public void scroll_to_point (int tree_x, int tree_y); + public void set_column_drag_function (Gtk.TreeViewColumnDropFunc func, pointer user_data, Gtk.DestroyNotify destroy); + public void set_cursor (Gtk.TreePath path, Gtk.TreeViewColumn focus_column, bool start_editing); + public void set_cursor_on_cell (Gtk.TreePath path, Gtk.TreeViewColumn focus_column, Gtk.CellRenderer focus_cell, bool start_editing); + public void set_destroy_count_func (Gtk.TreeDestroyCountFunc func, pointer data, Gtk.DestroyNotify destroy); + public void set_drag_dest_row (Gtk.TreePath path, Gtk.TreeViewDropPosition pos); + public void set_enable_search (bool enable_search); + public void set_enable_tree_lines (bool enabled); + public void set_expander_column (Gtk.TreeViewColumn column); + public void set_fixed_height_mode (bool enable); + public void set_grid_lines (Gtk.TreeViewGridLines grid_lines); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_headers_clickable (bool setting); + public void set_headers_visible (bool headers_visible); + public void set_hover_expand (bool expand); + public void set_hover_selection (bool hover); + public void set_model (Gtk.TreeModel model); + public void set_reorderable (bool reorderable); + public void set_row_separator_func (Gtk.TreeViewRowSeparatorFunc func, pointer data, Gtk.DestroyNotify destroy); + public void set_rubber_banding (bool enable); + public void set_rules_hint (bool setting); + public void set_search_column (int column); + public void set_search_entry (Gtk.Entry entry); + public void set_search_equal_func (Gtk.TreeViewSearchEqualFunc search_equal_func, pointer search_user_data, Gtk.DestroyNotify search_destroy); + public void set_search_position_func (Gtk.TreeViewSearchPositionFunc func, pointer data, GLib.DestroyNotify destroy); + public void set_vadjustment (Gtk.Adjustment adjustment); + public void tree_to_widget_coords (int tx, int ty, int wx, int wy); + public void unset_rows_drag_dest (); + public void unset_rows_drag_source (); + public void widget_to_tree_coords (int wx, int wy, int tx, int ty); + public weak Gtk.TreeModel model { get; set; } + public weak Gtk.Adjustment hadjustment { get; set; } + public weak Gtk.Adjustment vadjustment { get; set; } + public weak bool headers_visible { get; set; } + public weak bool headers_clickable { get; set; } + public weak Gtk.TreeViewColumn expander_column { get; set; } + public weak bool reorderable { get; set; } + public weak bool rules_hint { get; set; } + public weak bool enable_search { get; set; } + public weak int search_column { get; set; } + public weak bool fixed_height_mode { get; set; } + public weak bool hover_selection { get; set; } + public weak bool hover_expand { get; set; } + [NoAccessorMethod ()] + public weak bool show_expanders { get; set; } + [NoAccessorMethod ()] + public weak int level_indentation { get; set; } + public weak bool rubber_banding { get; set; } + [NoAccessorMethod ()] + public weak Gtk.TreeViewGridLines enable_grid_lines { get; set; } + public weak bool enable_tree_lines { get; set; } + public signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + [HasEmitter ()] + public signal void row_activated (Gtk.TreePath path, Gtk.TreeViewColumn column); + public signal bool test_expand_row (Gtk.TreeIter iter, Gtk.TreePath path); + public signal bool test_collapse_row (Gtk.TreeIter iter, Gtk.TreePath path); + [HasEmitter ()] + public signal void row_expanded (Gtk.TreeIter iter, Gtk.TreePath path); + public signal void row_collapsed (Gtk.TreeIter iter, Gtk.TreePath path); + public signal void columns_changed (); + public signal void cursor_changed (); + public signal bool move_cursor (Gtk.MovementStep step, int count); + public signal bool select_all (); + public signal bool unselect_all (); + public signal bool select_cursor_row (bool start_editing); + public signal bool toggle_cursor_row (); + public signal bool expand_collapse_cursor_row (bool logical, bool expand, bool open_all); + public signal bool select_cursor_parent (); + public signal bool start_interactive_search (); + } + public class TreeViewColumn : Gtk.Object, Gtk.CellLayout { + public void add_attribute (Gtk.CellRenderer cell_renderer, string attribute, int column); + public bool cell_get_position (Gtk.CellRenderer cell_renderer, int start_pos, int width); + public void cell_get_size (Gdk.Rectangle cell_area, int x_offset, int y_offset, int width, int height); + public bool cell_is_visible (); + public void cell_set_cell_data (Gtk.TreeModel tree_model, Gtk.TreeIter iter, bool is_expander, bool is_expanded); + public void clear (); + public void clear_attributes (Gtk.CellRenderer cell_renderer); + public void focus_cell (Gtk.CellRenderer cell); + public float get_alignment (); + public GLib.List get_cell_renderers (); + public bool get_clickable (); + public bool get_expand (); + public int get_fixed_width (); + public int get_max_width (); + public int get_min_width (); + public bool get_reorderable (); + public bool get_resizable (); + public Gtk.TreeViewColumnSizing get_sizing (); + public int get_sort_column_id (); + public bool get_sort_indicator (); + public Gtk.SortType get_sort_order (); + public int get_spacing (); + public string get_title (); + public GLib.Type get_type (); + public bool get_visible (); + public Gtk.Widget get_widget (); + public int get_width (); + public construct (); + public construct with_attributes (string title, Gtk.CellRenderer cell, ...); + public void pack_end (Gtk.CellRenderer cell, bool expand); + public void pack_start (Gtk.CellRenderer cell, bool expand); + public void queue_resize (); + public void set_alignment (float xalign); + public void set_attributes (Gtk.CellRenderer cell_renderer); + public void set_cell_data_func (Gtk.CellRenderer cell_renderer, Gtk.TreeCellDataFunc func, pointer func_data, Gtk.DestroyNotify destroy); + public void set_clickable (bool clickable); + public void set_expand (bool expand); + public void set_fixed_width (int fixed_width); + public void set_max_width (int max_width); + public void set_min_width (int min_width); + public void set_reorderable (bool reorderable); + public void set_resizable (bool resizable); + public void set_sizing (Gtk.TreeViewColumnSizing type); + public void set_sort_column_id (int sort_column_id); + public void set_sort_indicator (bool setting); + public void set_sort_order (Gtk.SortType order); + public void set_spacing (int spacing); + public void set_title (string title); + public void set_visible (bool visible); + public void set_widget (Gtk.Widget widget); + public weak bool visible { get; set; } + public weak bool resizable { get; set; } + public weak int width { get; } + public weak int spacing { get; set; } + public weak Gtk.TreeViewColumnSizing sizing { get; set; } + public weak int fixed_width { get; set; } + public weak int min_width { get; set; } + public weak int max_width { get; set; } + public weak string title { get; set; } + public weak bool expand { get; set; } + public weak bool clickable { get; set; } + public weak Gtk.Widget widget { get; set; } + public weak float alignment { get; set; } + public weak bool reorderable { get; set; } + public weak bool sort_indicator { get; set; } + public weak Gtk.SortType sort_order { get; set; } + [HasEmitter ()] + public signal void clicked (); + } + public class UIManager : GLib.Object { + public void add_ui (uint merge_id, string path, string name, string action, Gtk.UIManagerItemType type, bool top); + public uint add_ui_from_file (string filename, GLib.Error error); + public uint add_ui_from_string (string buffer, long length, GLib.Error error); + public void ensure_update (); + public Gtk.AccelGroup get_accel_group (); + public Gtk.Action get_action (string path); + public GLib.List get_action_groups (); + public bool get_add_tearoffs (); + public GLib.SList get_toplevels (Gtk.UIManagerItemType types); + public GLib.Type get_type (); + public string get_ui (); + public Gtk.Widget get_widget (string path); + public void insert_action_group (Gtk.ActionGroup action_group, int pos); + public construct (); + public construct merge_id (); + public void remove_action_group (Gtk.ActionGroup action_group); + public void remove_ui (uint merge_id); + public void set_add_tearoffs (bool add_tearoffs); + public weak bool add_tearoffs { get; set; } + public weak string ui { get; } + public signal void add_widget (Gtk.Widget widget); + public signal void actions_changed (); + public signal void connect_proxy (Gtk.Action action, Gtk.Widget proxy); + public signal void disconnect_proxy (Gtk.Action action, Gtk.Widget proxy); + public signal void pre_activate (Gtk.Action action); + public signal void post_activate (Gtk.Action action); + } + public class VBox : Gtk.Box { + public GLib.Type get_type (); + public construct (bool homogeneous, int spacing); + } + public class VButtonBox : Gtk.ButtonBox { + public GLib.Type get_type (); + public construct (); + } + public class Viewport : Gtk.Bin { + public Gtk.Adjustment get_hadjustment (); + public Gtk.ShadowType get_shadow_type (); + public GLib.Type get_type (); + public Gtk.Adjustment get_vadjustment (); + public construct (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public void set_hadjustment (Gtk.Adjustment adjustment); + public void set_shadow_type (Gtk.ShadowType type); + public void set_vadjustment (Gtk.Adjustment adjustment); + public weak Gtk.Adjustment hadjustment { get; set construct; } + public weak Gtk.Adjustment vadjustment { get; set construct; } + public weak Gtk.ShadowType shadow_type { get; set; } + public signal void set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + } + public class VPaned : Gtk.Paned { + public GLib.Type get_type (); + public construct (); + } + public class VRuler : Gtk.Ruler { + public GLib.Type get_type (); + public construct (); + } + public class VScale : Gtk.Scale { + public GLib.Type get_type (); + public construct (Gtk.Adjustment adjustment); + public construct with_range (double min, double max, double step); + } + public class VScrollbar : Gtk.Scrollbar { + public GLib.Type get_type (); + public construct (Gtk.Adjustment adjustment); + } + public class VSeparator : Gtk.Separator { + public GLib.Type get_type (); + public construct (); + } + public class Widget : Gtk.Object, Atk.Implementor { + public weak Gtk.Requisition requisition; + public weak pointer allocation; + public weak Gdk.Window window; + public bool activate (); + public void add_accelerator (string accel_signal, Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods, Gtk.AccelFlags accel_flags); + public void add_events (int events); + public void add_mnemonic_label (Gtk.Widget label); + public bool child_focus (Gtk.DirectionType direction); + public static GLib.ParamSpec class_find_style_property (pointer klass, string property_name); + public static void class_install_style_property (pointer klass, GLib.ParamSpec pspec); + public static void class_install_style_property_parser (pointer klass, GLib.ParamSpec pspec, Gtk.RcPropertyParser parser); + public static GLib.ParamSpec class_list_style_properties (pointer klass, uint n_properties); + public void class_path (uint path_length, string path, string path_reversed); + public Pango.Context create_pango_context (); + public Pango.Layout create_pango_layout (string text); + public void destroyed (Gtk.Widget widget_pointer); + public void ensure_style (); + public void freeze_child_notify (); + public Atk.Object get_accessible (); + public Gtk.Action get_action (); + public Gtk.Widget get_ancestor (GLib.Type widget_type); + public void get_child_requisition (Gtk.Requisition requisition); + public bool get_child_visible (); + public Gtk.Clipboard get_clipboard (Gdk.Atom selection); + public Gdk.Colormap get_colormap (); + public string get_composite_name (); + public Gdk.Colormap get_default_colormap (); + public Gtk.TextDirection get_default_direction (); + public Gtk.Style get_default_style (); + public Gdk.Visual get_default_visual (); + public Gtk.TextDirection get_direction (); + public Gdk.Display get_display (); + public int get_events (); + public Gdk.ExtensionMode get_extension_events (); + public Gtk.RcStyle get_modifier_style (); + public string get_name (); + public bool get_no_show_all (); + public Pango.Context get_pango_context (); + public Gtk.Widget get_parent (); + public Gdk.Window get_parent_window (); + public void get_pointer (int x, int y); + public Gdk.Window get_root_window (); + public Gdk.Screen get_screen (); + public Gtk.Settings get_settings (); + public void get_size_request (int width, int height); + public Gtk.Style get_style (); + public Gtk.Widget get_toplevel (); + public GLib.Type get_type (); + public Gdk.Visual get_visual (); + public void grab_default (); + public bool has_screen (); + public void hide_all (); + public bool hide_on_delete (); + public void input_shape_combine_mask (Gdk.Bitmap shape_mask, int offset_x, int offset_y); + public bool intersect (Gdk.Rectangle area, Gdk.Rectangle intersection); + public bool is_ancestor (Gtk.Widget ancestor); + public bool is_composited (); + public GLib.List list_accel_closures (); + public GLib.List list_mnemonic_labels (); + public void modify_base (Gtk.StateType state, Gdk.Color color); + public void modify_bg (Gtk.StateType state, Gdk.Color color); + public void modify_fg (Gtk.StateType state, Gdk.Color color); + public void modify_font (Pango.FontDescription font_desc); + public void modify_style (Gtk.RcStyle style); + public void modify_text (Gtk.StateType state, Gdk.Color color); + public construct (GLib.Type type, string first_property_name); + public void path (uint path_length, string path, string path_reversed); + public void pop_colormap (); + public void pop_composite_child (); + public static void push_colormap (Gdk.Colormap cmap); + public void push_composite_child (); + public void queue_draw (); + public void queue_draw_area (int x, int y, int width, int height); + public void queue_resize (); + public void queue_resize_no_redraw (); + public Gtk.Widget @ref (); + public Gdk.Region region_intersect (Gdk.Region region); + public bool remove_accelerator (Gtk.AccelGroup accel_group, uint accel_key, Gdk.ModifierType accel_mods); + public void remove_mnemonic_label (Gtk.Widget label); + public Gdk.Pixbuf render_icon (string stock_id, Gtk.IconSize size, string detail); + public void reparent (Gtk.Widget new_parent); + public void reset_rc_styles (); + public void reset_shapes (); + public int send_expose (Gdk.Event event); + public void set_accel_path (string accel_path, Gtk.AccelGroup accel_group); + public void set_app_paintable (bool app_paintable); + public void set_child_visible (bool is_visible); + public void set_colormap (Gdk.Colormap colormap); + public void set_composite_name (string name); + public static void set_default_colormap (Gdk.Colormap colormap); + public static void set_default_direction (Gtk.TextDirection dir); + public void set_direction (Gtk.TextDirection dir); + public void set_double_buffered (bool double_buffered); + public void set_events (int events); + public void set_extension_events (Gdk.ExtensionMode mode); + public void set_name (string name); + public void set_no_show_all (bool no_show_all); + public void set_parent (Gtk.Widget parent); + public void set_parent_window (Gdk.Window parent_window); + public void set_redraw_on_allocate (bool redraw_on_allocate); + public bool set_scroll_adjustments (Gtk.Adjustment hadjustment, Gtk.Adjustment vadjustment); + public void set_sensitive (bool sensitive); + public void set_size_request (int width, int height); + public void set_state (Gtk.StateType state); + public void set_style (Gtk.Style style); + public void shape_combine_mask (Gdk.Bitmap shape_mask, int offset_x, int offset_y); + public void show_all (); + public void show_now (); + public void style_get (string first_property_name); + public void style_get_property (string property_name, GLib.Value value); + public void style_get_valist (string first_property_name, pointer var_args); + public void thaw_child_notify (); + public bool translate_coordinates (Gtk.Widget dest_widget, int src_x, int src_y, int dest_x, int dest_y); + public void unparent (); + public void unref (); + public weak string name { get; set; } + public weak Gtk.Container parent { get; set; } + [NoAccessorMethod ()] + public weak int width_request { get; set; } + [NoAccessorMethod ()] + public weak int height_request { get; set; } + [NoAccessorMethod ()] + public weak bool visible { get; set; } + [NoAccessorMethod ()] + public weak bool sensitive { get; set; } + [NoAccessorMethod ()] + public weak bool app_paintable { get; set; } + [NoAccessorMethod ()] + public weak bool can_focus { get; set; } + [NoAccessorMethod ()] + public weak bool has_focus { get; set; } + [NoAccessorMethod ()] + public weak bool is_focus { get; set; } + [NoAccessorMethod ()] + public weak bool can_default { get; set; } + [NoAccessorMethod ()] + public weak bool has_default { get; set; } + [NoAccessorMethod ()] + public weak bool receives_default { get; set; } + [NoAccessorMethod ()] + public weak bool composite_child { get; } + public weak Gtk.Style style { get; set; } + public weak Gdk.EventMask events { get; set; } + public weak Gdk.ExtensionMode extension_events { get; set; } + public weak bool no_show_all { get; set; } + [HasEmitter ()] + public signal void show (); + [HasEmitter ()] + public signal void hide (); + [HasEmitter ()] + public signal void map (); + [HasEmitter ()] + public signal void unmap (); + [HasEmitter ()] + public signal void realize (); + [HasEmitter ()] + public signal void unrealize (); + [HasEmitter ()] + public signal void size_request (Gtk.Requisition requisition); + [HasEmitter ()] + public signal void size_allocate (pointer allocation); + public signal void state_changed (Gtk.StateType previous_state); + public signal void parent_set (Gtk.Widget previous_parent); + public signal void hierarchy_changed (Gtk.Widget previous_toplevel); + public signal void style_set (Gtk.Style previous_style); + public signal void direction_changed (Gtk.TextDirection previous_direction); + public signal void grab_notify (bool was_grabbed); + [HasEmitter ()] + public signal void child_notify (GLib.ParamSpec pspec); + [HasEmitter ()] + public signal bool mnemonic_activate (bool group_cycling); + [HasEmitter ()] + public signal void grab_focus (); + public signal bool focus (Gtk.DirectionType direction); + [HasEmitter ()] + public signal bool event (Gdk.Event event); + public signal void event_after (Gdk.Event p0); + public signal bool button_press_event (Gdk.EventButton event); + public signal bool button_release_event (Gdk.EventButton event); + public signal bool scroll_event (Gdk.EventScroll event); + public signal bool motion_notify_event (Gdk.EventMotion event); + public signal void composited_changed (); + public signal bool delete_event (Gdk.EventAny event); + public signal bool destroy_event (Gdk.EventAny event); + public signal bool expose_event (Gdk.EventExpose event); + public signal bool key_press_event (Gdk.EventKey event); + public signal bool key_release_event (Gdk.EventKey event); + public signal bool enter_notify_event (Gdk.EventCrossing event); + public signal bool leave_notify_event (Gdk.EventCrossing event); + public signal bool configure_event (Gdk.EventConfigure event); + public signal bool focus_in_event (Gdk.EventFocus event); + public signal bool focus_out_event (Gdk.EventFocus event); + public signal bool map_event (Gdk.EventAny event); + public signal bool unmap_event (Gdk.EventAny event); + public signal bool property_notify_event (Gdk.EventProperty event); + public signal bool selection_clear_event (Gdk.EventSelection event); + public signal bool selection_request_event (Gdk.EventSelection event); + public signal bool selection_notify_event (Gdk.EventSelection event); + public signal void selection_received (Gtk.SelectionData selection_data, uint time_); + public signal void selection_get (Gtk.SelectionData selection_data, uint info, uint time_); + public signal bool proximity_in_event (Gdk.EventProximity event); + public signal bool proximity_out_event (Gdk.EventProximity event); + public signal void drag_leave (Gdk.DragContext context, uint time_); + public signal void drag_begin (Gdk.DragContext context); + public signal void drag_end (Gdk.DragContext context); + public signal void drag_data_delete (Gdk.DragContext context); + public signal bool drag_motion (Gdk.DragContext context, int x, int y, uint time_); + public signal bool drag_drop (Gdk.DragContext context, int x, int y, uint time_); + public signal void drag_data_get (Gdk.DragContext context, Gtk.SelectionData selection_data, uint info, uint time_); + public signal void drag_data_received (Gdk.DragContext context, int x, int y, Gtk.SelectionData selection_data, uint info, uint time_); + public signal bool visibility_notify_event (Gdk.EventVisibility event); + public signal bool client_event (Gdk.EventClient event); + public signal bool no_expose_event (Gdk.EventAny event); + public signal bool window_state_event (Gdk.EventWindowState event); + public signal bool grab_broken_event (Gdk.EventGrabBroken event); + public signal bool popup_menu (); + public signal bool show_help (Gtk.WidgetHelpType help_type); + public signal void accel_closures_changed (); + public signal void screen_changed (Gdk.Screen previous_screen); + [HasEmitter ()] + public signal bool can_activate_accel (uint signal_id); } - - [CCode (cprefix = "GTK_WINDOW_")] - public enum WindowType { - TOPLEVEL, - POPUP + public class Win32EmbedWidget : Gtk.Window { + public GLib.Type get_type (); + } + public class Window : Gtk.Bin { + public bool activate_default (); + public bool activate_focus (); + public bool activate_key (Gdk.EventKey event); + public void add_accel_group (Gtk.AccelGroup accel_group); + public void add_embedded_xid (uint xid); + public void add_mnemonic (uint keyval, Gtk.Widget target); + public void begin_move_drag (int button, int root_x, int root_y, uint timestamp); + public void begin_resize_drag (Gdk.WindowEdge edge, int button, int root_x, int root_y, uint timestamp); + public void deiconify (); + public void fullscreen (); + public bool get_accept_focus (); + public bool get_decorated (); + public GLib.List get_default_icon_list (); + public void get_default_size (int width, int height); + public bool get_deletable (); + public bool get_destroy_with_parent (); + public Gtk.Widget get_focus (); + public bool get_focus_on_map (); + public void get_frame_dimensions (int left, int top, int right, int bottom); + public Gdk.Gravity get_gravity (); + public Gtk.WindowGroup get_group (); + public bool get_has_frame (); + public Gdk.Pixbuf get_icon (); + public GLib.List get_icon_list (); + public string get_icon_name (); + public Gdk.ModifierType get_mnemonic_modifier (); + public bool get_modal (); + public void get_position (int root_x, int root_y); + public bool get_resizable (); + public string get_role (); + public Gdk.Screen get_screen (); + public void get_size (int width, int height); + public bool get_skip_pager_hint (); + public bool get_skip_taskbar_hint (); + public string get_title (); + public Gtk.Window get_transient_for (); + public GLib.Type get_type (); + public Gdk.WindowTypeHint get_type_hint (); + public bool get_urgency_hint (); + public void iconify (); + public GLib.List list_toplevels (); + public void maximize (); + public bool mnemonic_activate (uint keyval, Gdk.ModifierType modifier); + public void move (int x, int y); + public construct (Gtk.WindowType type); + public bool parse_geometry (string geometry); + public void present (); + public void present_with_time (uint timestamp); + public bool propagate_key_event (Gdk.EventKey event); + public void remove_accel_group (Gtk.AccelGroup accel_group); + public void remove_embedded_xid (uint xid); + public void remove_mnemonic (uint keyval, Gtk.Widget target); + public void reshow_with_initial_size (); + public void resize (int width, int height); + public void set_accept_focus (bool setting); + public static void set_auto_startup_notification (bool setting); + public void set_decorated (bool setting); + public void set_default (Gtk.Widget default_widget); + public static void set_default_icon (Gdk.Pixbuf icon); + public static bool set_default_icon_from_file (string filename, GLib.Error err); + public static void set_default_icon_list (GLib.List list); + public static void set_default_icon_name (string name); + public void set_default_size (int width, int height); + public void set_deletable (bool setting); + public void set_destroy_with_parent (bool setting); + public void set_focus_on_map (bool setting); + public void set_frame_dimensions (int left, int top, int right, int bottom); + public void set_geometry_hints (Gtk.Widget geometry_widget, Gdk.Geometry geometry, Gdk.WindowHints geom_mask); + public void set_gravity (Gdk.Gravity gravity); + public void set_has_frame (bool setting); + public void set_icon (Gdk.Pixbuf icon); + public bool set_icon_from_file (string filename, GLib.Error err); + public void set_icon_list (GLib.List list); + public void set_icon_name (string name); + public void set_keep_above (bool setting); + public void set_keep_below (bool setting); + public void set_mnemonic_modifier (Gdk.ModifierType modifier); + public void set_modal (bool modal); + public void set_position (Gtk.WindowPosition position); + public void set_resizable (bool resizable); + public void set_role (string role); + public void set_screen (Gdk.Screen screen); + public void set_skip_pager_hint (bool setting); + public void set_skip_taskbar_hint (bool setting); + public void set_title (string title); + public void set_transient_for (Gtk.Window parent); + public void set_type_hint (Gdk.WindowTypeHint hint); + public void set_urgency_hint (bool setting); + public void set_wmclass (string wmclass_name, string wmclass_class); + public void stick (); + public void unfullscreen (); + public void unmaximize (); + public void unstick (); + [NoAccessorMethod ()] + public weak Gtk.WindowType type { get; construct; } + public weak string title { get; set; } + public weak string role { get; set; } + [NoAccessorMethod ()] + public weak bool allow_shrink { get; set; } + [NoAccessorMethod ()] + public weak bool allow_grow { get; set; } + public weak bool resizable { get; set; } + public weak bool modal { get; set; } + [NoAccessorMethod ()] + public weak Gtk.WindowPosition window_position { get; set; } + [NoAccessorMethod ()] + public weak int default_width { get; set; } + [NoAccessorMethod ()] + public weak int default_height { get; set; } + public weak bool destroy_with_parent { get; set; } + public weak Gdk.Pixbuf icon { get; set; } + public weak string icon_name { get; set; } + public weak Gdk.Screen screen { get; set; } + [NoAccessorMethod ()] + public weak bool is_active { get; } + [NoAccessorMethod ()] + public weak bool has_toplevel_focus { get; } + public weak Gdk.WindowTypeHint type_hint { get; set; } + public weak bool skip_taskbar_hint { get; set; } + public weak bool skip_pager_hint { get; set; } + public weak bool urgency_hint { get; set; } + public weak bool accept_focus { get; set; } + public weak bool focus_on_map { get; set; } + public weak bool decorated { get; set; } + public weak bool deletable { get; set; } + public weak Gdk.Gravity gravity { get; set; } + public weak Gtk.Window transient_for { get; set construct; } + [HasEmitter ()] + public signal void set_focus (Gtk.Widget focus); + public signal bool frame_event (Gdk.Event event); + public signal void focus_activated (); + public signal void default_activated (); + public signal void move_focus (Gtk.DirectionType direction); + public signal void keys_changed (); } - - public class Dialog : Window { + public class WindowGroup : GLib.Object { + public void add_window (Gtk.Window window); + public GLib.Type get_type (); public construct (); - public construct with_buttons (string title, Window parent, DialogFlags _flags, string first_button_text, ...); - public int run (); - public void response (int response_id); - public Widget add_button (string button_text, int response_id); - public void add_buttons (string first_button_text, ...); + public void remove_window (Gtk.Window window); + } + public interface CellEditable { + public void editing_done (); + public GLib.Type get_type (); + public void remove_widget (); + public void start_editing (Gdk.Event event); + } + public interface CellLayout { + public void add_attribute (Gtk.CellRenderer cell, string attribute, int column); + public void clear (); + public void clear_attributes (Gtk.CellRenderer cell); + public GLib.Type get_type (); + public void pack_end (Gtk.CellRenderer cell, bool expand); + public void pack_start (Gtk.CellRenderer cell, bool expand); + public void reorder (Gtk.CellRenderer cell, int position); + public void set_attributes (Gtk.CellRenderer cell); + public void set_cell_data_func (Gtk.CellRenderer cell, Gtk.CellLayoutDataFunc func, pointer func_data, GLib.DestroyNotify destroy); + } + public interface Editable { + public void copy_clipboard (); + public void cut_clipboard (); + public void delete_selection (); + public void delete_text (int start_pos, int end_pos); + public string get_chars (int start_pos, int end_pos); + public bool get_editable (); + public int get_position (); + public bool get_selection_bounds (int start, int end); + public GLib.Type get_type (); + public void insert_text (string new_text, int new_text_length, int position); + public void paste_clipboard (); + public void select_region (int start, int end); + public void set_editable (bool is_editable); + public void set_position (int position); + } + public interface FileChooser { + public void add_filter (Gtk.FileFilter filter); + public bool add_shortcut_folder (string folder, GLib.Error error); + public bool add_shortcut_folder_uri (string uri, GLib.Error error); + public GLib.Quark error_quark (); + public Gtk.FileChooserAction get_action (); + public string get_current_folder (); + public string get_current_folder_uri (); + public bool get_do_overwrite_confirmation (); + public Gtk.Widget get_extra_widget (); + public string get_filename (); + public GLib.SList get_filenames (); + public Gtk.FileFilter get_filter (); + public bool get_local_only (); + public string get_preview_filename (); + public string get_preview_uri (); + public Gtk.Widget get_preview_widget (); + public bool get_preview_widget_active (); + public bool get_select_multiple (); + public bool get_show_hidden (); + public GLib.Type get_type (); + public string get_uri (); + public GLib.SList get_uris (); + public bool get_use_preview_label (); + public GLib.SList list_filters (); + public GLib.SList list_shortcut_folder_uris (); + public GLib.SList list_shortcut_folders (); + public void remove_filter (Gtk.FileFilter filter); + public bool remove_shortcut_folder (string folder, GLib.Error error); + public bool remove_shortcut_folder_uri (string uri, GLib.Error error); + public void select_all (); + public bool select_filename (string filename); + public bool select_uri (string uri); + public void set_action (Gtk.FileChooserAction action); + public bool set_current_folder (string filename); + public bool set_current_folder_uri (string uri); + public void set_current_name (string name); + public void set_do_overwrite_confirmation (bool do_overwrite_confirmation); + public void set_extra_widget (Gtk.Widget extra_widget); + public bool set_filename (string filename); + public void set_filter (Gtk.FileFilter filter); + public void set_local_only (bool local_only); + public void set_preview_widget (Gtk.Widget preview_widget); + public void set_preview_widget_active (bool active); + public void set_select_multiple (bool select_multiple); + public void set_show_hidden (bool show_hidden); + public bool set_uri (string uri); + public void set_use_preview_label (bool use_label); + public void unselect_all (); + public void unselect_filename (string filename); + public void unselect_uri (string uri); + } + public interface PrintOperationPreview { + public void end_preview (); + public GLib.Type get_type (); + public bool is_selected (int page_nr); + public void render_page (int page_nr); + } + public interface RecentChooser { + public void add_filter (Gtk.RecentFilter filter); + public GLib.Quark error_quark (); + public Gtk.RecentInfo get_current_item (); + public string get_current_uri (); + public Gtk.RecentFilter get_filter (); + public GLib.List get_items (); + public int get_limit (); + public bool get_local_only (); + public bool get_select_multiple (); + public bool get_show_icons (); + public bool get_show_not_found (); + public bool get_show_numbers (); + public bool get_show_private (); + public bool get_show_tips (); + public Gtk.RecentSortType get_sort_type (); + public GLib.Type get_type (); + public string get_uris (ulong length); + public GLib.SList list_filters (); + public void remove_filter (Gtk.RecentFilter filter); + public void select_all (); + public bool select_uri (string uri, GLib.Error error); + public bool set_current_uri (string uri, GLib.Error error); + public void set_filter (Gtk.RecentFilter filter); + public void set_limit (int limit); + public void set_local_only (bool local_only); + public void set_select_multiple (bool select_multiple); + public void set_show_icons (bool show_icons); + public void set_show_not_found (bool show_not_found); + public void set_show_numbers (bool show_numbers); + public void set_show_private (bool show_private); + public void set_show_tips (bool show_tips); + public void set_sort_func (Gtk.RecentSortFunc sort_func, pointer sort_data, GLib.DestroyNotify data_destroy); + public void set_sort_type (Gtk.RecentSortType sort_type); + public void unselect_all (); + public void unselect_uri (string uri); + } + public interface TreeDragDest { + public bool drag_data_received (Gtk.TreePath dest, Gtk.SelectionData selection_data); + public GLib.Type get_type (); + public bool row_drop_possible (Gtk.TreePath dest_path, Gtk.SelectionData selection_data); + } + public interface TreeDragSource { + public bool drag_data_delete (Gtk.TreePath path); + public bool drag_data_get (Gtk.TreePath path, Gtk.SelectionData selection_data); + public GLib.Type get_type (); + public bool row_draggable (Gtk.TreePath path); + } + public interface TreeModel { + public void @foreach (Gtk.TreeModelForeachFunc func, pointer user_data); + public void @get (Gtk.TreeIter iter); + public GLib.Type get_column_type (int index_); + public Gtk.TreeModelFlags get_flags (); + public bool get_iter (Gtk.TreeIter iter, Gtk.TreePath path); + public bool get_iter_first (Gtk.TreeIter iter); + public bool get_iter_from_string (Gtk.TreeIter iter, string path_string); + public int get_n_columns (); + public Gtk.TreePath get_path (Gtk.TreeIter iter); + public string get_string_from_iter (Gtk.TreeIter iter); + public GLib.Type get_type (); + public void get_valist (Gtk.TreeIter iter, pointer var_args); + public void get_value (Gtk.TreeIter iter, int column, GLib.Value value); + public bool iter_children (Gtk.TreeIter iter, Gtk.TreeIter parent); + public bool iter_has_child (Gtk.TreeIter iter); + public int iter_n_children (Gtk.TreeIter iter); + public bool iter_next (Gtk.TreeIter iter); + public bool iter_nth_child (Gtk.TreeIter iter, Gtk.TreeIter parent, int n); + public bool iter_parent (Gtk.TreeIter iter, Gtk.TreeIter child); + public void ref_node (Gtk.TreeIter iter); + public void row_changed (Gtk.TreePath path, Gtk.TreeIter iter); + public void row_deleted (Gtk.TreePath path); + public void row_has_child_toggled (Gtk.TreePath path, Gtk.TreeIter iter); + public void row_inserted (Gtk.TreePath path, Gtk.TreeIter iter); + public void rows_reordered (Gtk.TreePath path, Gtk.TreeIter iter, int new_order); + public void unref_node (Gtk.TreeIter iter); + } + public interface TreeSortable { + public bool get_sort_column_id (int sort_column_id, Gtk.SortType order); + public GLib.Type get_type (); + public bool has_default_sort_func (); + public void set_default_sort_func (Gtk.TreeIterCompareFunc sort_func, pointer user_data, Gtk.DestroyNotify destroy); + public void set_sort_column_id (int sort_column_id, Gtk.SortType order); + public void set_sort_func (int sort_column_id, Gtk.TreeIterCompareFunc sort_func, pointer user_data, Gtk.DestroyNotify destroy); + public void sort_column_changed (); + } + [ReferenceType ()] + public struct AccelGroupEntry { + public weak Gtk.AccelKey key; + public weak GLib.Closure closure; + public weak GLib.Quark accel_path_quark; + } + [ReferenceType ()] + public struct AccelKey { + public weak uint accel_key; + public weak Gdk.ModifierType accel_mods; + public weak uint accel_flags; + } + [ReferenceType ()] + public struct ActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + public weak GLib.Callback @callback; + } + [ReferenceType ()] + public struct BindingArg { + public weak GLib.Type arg_type; + public weak long long_data; + } + [ReferenceType ()] + public struct BindingEntry { + public weak uint keyval; + public weak Gdk.ModifierType modifiers; + public weak Gtk.BindingSet binding_set; + public weak uint destroyed; + public weak uint in_emission; + public weak Gtk.BindingEntry set_next; + public weak Gtk.BindingEntry hash_next; + public weak Gtk.BindingSignal signals; + public static void add_signal (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers, string signal_name, uint n_args); + public static void add_signall (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers, string signal_name, GLib.SList binding_args); + public static void clear (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers); + public static void remove (Gtk.BindingSet binding_set, uint keyval, Gdk.ModifierType modifiers); + } + [ReferenceType ()] + public struct BindingSet { + public weak string set_name; + public weak int priority; + public weak GLib.SList widget_path_pspecs; + public weak GLib.SList widget_class_pspecs; + public weak GLib.SList class_branch_pspecs; + public weak Gtk.BindingEntry entries; + public weak Gtk.BindingEntry current; + public weak uint parsed; + public bool activate (uint keyval, Gdk.ModifierType modifiers, Gtk.Object object); + public void add_path (Gtk.PathType path_type, string path_pattern, Gtk.PathPriorityType priority); + public static Gtk.BindingSet by_class (pointer object_class); + public static Gtk.BindingSet find (string set_name); + public construct (string set_name); + } + [ReferenceType ()] + public struct BindingSignal { + public weak Gtk.BindingSignal next; + public weak string signal_name; + public weak uint n_args; + public weak Gtk.BindingArg args; + } + public struct Border { + public Gtk.Border copy (); + public void free (); + public GLib.Type get_type (); + } + [ReferenceType ()] + public struct BoxChild { + public weak Gtk.Widget widget; + public weak ushort padding; + public weak uint expand; + public weak uint fill; + public weak uint pack; + public weak uint is_secondary; + } + [ReferenceType ()] + public struct FileFilterInfo { + public weak Gtk.FileFilterFlags contains; + public weak string filename; + public weak string uri; + public weak string display_name; + public weak string mime_type; + } + [ReferenceType ()] + public struct FixedChild { + public weak Gtk.Widget widget; + public weak int x; + public weak int y; + } + [ReferenceType ()] + public struct IMContextInfo { + public weak string context_id; + public weak string context_name; + public weak string domain; + public weak string domain_dirname; + public weak string default_locales; + } + public struct IconInfo { + public Gtk.IconInfo copy (); + public void free (); + public bool get_attach_points (Gdk.Point points, int n_points); + public int get_base_size (); + public Gdk.Pixbuf get_builtin_pixbuf (); + public string get_display_name (); + public bool get_embedded_rect (Gdk.Rectangle rectangle); + public string get_filename (); + public GLib.Type get_type (); + public Gdk.Pixbuf load_icon (GLib.Error error); + public void set_raw_coordinates (bool raw_coordinates); + } + public struct IconSet { + public void add_source (Gtk.IconSource source); + public Gtk.IconSet copy (); + public void get_sizes (Gtk.IconSize sizes, int n_sizes); + public GLib.Type get_type (); + public construct (); + public construct from_pixbuf (Gdk.Pixbuf pixbuf); + public Gtk.IconSet @ref (); + public Gdk.Pixbuf render_icon (Gtk.Style style, Gtk.TextDirection direction, Gtk.StateType state, Gtk.IconSize size, Gtk.Widget widget, string detail); + public void unref (); + } + public struct IconSource { + public Gtk.IconSource copy (); + public void free (); + public Gtk.TextDirection get_direction (); + public bool get_direction_wildcarded (); + public string get_filename (); + public string get_icon_name (); + public Gdk.Pixbuf get_pixbuf (); + public Gtk.IconSize get_size (); + public bool get_size_wildcarded (); + public Gtk.StateType get_state (); + public bool get_state_wildcarded (); + public GLib.Type get_type (); + public construct (); + public void set_direction (Gtk.TextDirection direction); + public void set_direction_wildcarded (bool setting); + public void set_filename (string filename); + public void set_icon_name (string icon_name); + public void set_pixbuf (Gdk.Pixbuf pixbuf); + public void set_size (Gtk.IconSize size); + public void set_size_wildcarded (bool setting); + public void set_state (Gtk.StateType state); + public void set_state_wildcarded (bool setting); + } + [ReferenceType ()] + public struct ImageAnimationData { + public weak Gdk.PixbufAnimation anim; + public weak Gdk.PixbufAnimationIter iter; + public weak uint frame_timeout; + } + [ReferenceType ()] + public struct ImageIconNameData { + public weak string icon_name; + public weak Gdk.Pixbuf pixbuf; + public weak uint theme_change_id; + } + [ReferenceType ()] + public struct ImageIconSetData { + public weak Gtk.IconSet icon_set; + } + [ReferenceType ()] + public struct ImageImageData { + public weak Gdk.Image image; + } + [ReferenceType ()] + public struct ImagePixbufData { + public weak Gdk.Pixbuf pixbuf; + } + [ReferenceType ()] + public struct ImagePixmapData { + public weak Gdk.Pixmap pixmap; + } + [ReferenceType ()] + public struct ImageStockData { + public weak string stock_id; + } + [ReferenceType ()] + public struct KeyHash { + } + [ReferenceType ()] + public struct LabelSelectionInfo { + } + [ReferenceType ()] + public struct MenuEntry { + public weak string path; + public weak string accelerator; + public weak Gtk.MenuCallback @callback; + public weak pointer callback_data; + public weak Gtk.Widget widget; + } + [ReferenceType ()] + public struct MnemonicHash { + } + [ReferenceType ()] + public struct NotebookPage { + public static int num (Gtk.Notebook notebook, Gtk.Widget child); + } + [ReferenceType ()] + public struct PageRange { + public weak int start; + public weak int end; + } + public struct PaperSize { + public Gtk.PaperSize copy (); + public void free (); + public string get_default (); + public double get_default_bottom_margin (Gtk.Unit unit); + public double get_default_left_margin (Gtk.Unit unit); + public double get_default_right_margin (Gtk.Unit unit); + public double get_default_top_margin (Gtk.Unit unit); + public string get_display_name (); + public double get_height (Gtk.Unit unit); + public string get_name (); + public string get_ppd_name (); + public GLib.Type get_type (); + public double get_width (Gtk.Unit unit); + public bool is_custom (); + public bool is_equal (Gtk.PaperSize size2); + public construct (string name); + public construct custom (string name, string display_name, double width, double height, Gtk.Unit unit); + public construct from_ppd (string ppd_name, string ppd_display_name, double width, double height); + public void set_size (double width, double height, Gtk.Unit unit); + } + [ReferenceType ()] + public struct PrintWin32Devnames { + public weak string driver; + public weak string device; + public weak string output; + public weak int @flags; + public void free (); + public static pointer from_printer_name (string printer); + public static Gtk.PrintWin32Devnames from_win32 (pointer global); + public pointer to_win32 (); + } + [ReferenceType ()] + public struct RadioActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + public weak int value; + } + [ReferenceType ()] + public struct RangeLayout { + } + [ReferenceType ()] + public struct RangeStepTimer { + } + [ReferenceType ()] + public struct RcContext { + } + [ReferenceType ()] + public struct RcProperty { + public weak GLib.Quark type_name; + public weak GLib.Quark property_name; + public weak string origin; + public weak GLib.Value value; + public static bool parse_border (GLib.ParamSpec pspec, GLib.String gstring, GLib.Value property_value); + public static bool parse_color (GLib.ParamSpec pspec, GLib.String gstring, GLib.Value property_value); + public static bool parse_enum (GLib.ParamSpec pspec, GLib.String gstring, GLib.Value property_value); + public static bool parse_flags (GLib.ParamSpec pspec, GLib.String gstring, GLib.Value property_value); + public static bool parse_requisition (GLib.ParamSpec pspec, GLib.String gstring, GLib.Value property_value); + } + [ReferenceType ()] + public struct RecentData { + public weak string display_name; + public weak string description; + public weak string mime_type; + public weak string app_name; + public weak string app_exec; + public weak string groups; + public weak bool is_private; + } + [ReferenceType ()] + public struct RecentFilterInfo { + public weak Gtk.RecentFilterFlags contains; + public weak string uri; + public weak string display_name; + public weak string mime_type; + public weak string applications; + public weak string groups; + public weak int age; + } + public struct RecentInfo { + public bool exists (); + public ulong get_added (); + public int get_age (); + public bool get_application_info (string app_name, string app_exec, uint count, ulong time_); + public string get_applications (ulong length); + public string get_description (); + public string get_display_name (); + public string get_groups (ulong length); + public Gdk.Pixbuf get_icon (int size); + public string get_mime_type (); + public ulong get_modified (); + public bool get_private_hint (); + public string get_short_name (); + public GLib.Type get_type (); + public string get_uri (); + public string get_uri_display (); + public ulong get_visited (); + public bool has_application (string app_name); + public bool has_group (string group_name); + public bool is_local (); + public string last_application (); + public bool match (Gtk.RecentInfo info_b); + public Gtk.RecentInfo @ref (); + public void unref (); + } + public struct Requisition { + public Gtk.Requisition copy (); + public void free (); + public GLib.Type get_type (); + } + [ReferenceType ()] + public struct RulerMetric { + public weak string metric_name; + public weak string abbrev; + public weak double pixels_per_unit; + public weak double ruler_scale; + public weak int subdivide; + } + public struct SelectionData { + public Gtk.SelectionData copy (); + public void free (); + public Gdk.Pixbuf get_pixbuf (); + public bool get_targets (Gdk.Atom targets, int n_atoms); + public uchar get_text (); + public GLib.Type get_type (); + public string get_uris (); + public void @set (Gdk.Atom type, int format, uchar data, int length); + public bool set_pixbuf (Gdk.Pixbuf pixbuf); + public bool set_text (string str, int len); + public bool set_uris (string uris); + public bool targets_include_image (bool writable); + public bool targets_include_rich_text (Gtk.TextBuffer buffer); + public bool targets_include_text (); + public bool targets_include_uri (); + } + [ReferenceType ()] + public struct SettingsPropertyValue { + } + [ReferenceType ()] + public struct SettingsValue { + public weak string origin; + public weak GLib.Value value; + } + [ReferenceType ()] + public struct StockItem { + public weak string stock_id; + public weak string label; + public weak Gdk.ModifierType modifier; + public weak uint keyval; + public weak string translation_domain; + public Gtk.StockItem copy (); + public void free (); + } + [ReferenceType ()] + public struct TableChild { + public weak Gtk.Widget widget; + public weak ushort left_attach; + public weak ushort right_attach; + public weak ushort top_attach; + public weak ushort bottom_attach; + public weak ushort xpadding; + public weak ushort ypadding; + public weak uint xexpand; + public weak uint yexpand; + public weak uint xshrink; + public weak uint yshrink; + public weak uint xfill; + public weak uint yfill; + } + [ReferenceType ()] + public struct TableRowCol { + public weak ushort requisition; + public weak ushort allocation; + public weak ushort spacing; + public weak uint need_expand; + public weak uint need_shrink; + public weak uint expand; + public weak uint shrink; + public weak uint empty; + } + [ReferenceType ()] + public struct TargetEntry { + public weak string target; + public weak uint @flags; + public weak uint info; + } + public struct TargetList { + public void add (Gdk.Atom target, uint @flags, uint info); + public void add_image_targets (uint info, bool writable); + public void add_rich_text_targets (uint info, bool deserializable, Gtk.TextBuffer buffer); + public void add_table (Gtk.TargetEntry targets, uint ntargets); + public void add_text_targets (uint info); + public void add_uri_targets (uint info); + public bool find (Gdk.Atom target, uint info); + public GLib.Type get_type (); + public construct (Gtk.TargetEntry targets, uint ntargets); + public Gtk.TargetList @ref (); + public void remove (Gdk.Atom target); + public void unref (); + } + [ReferenceType ()] + public struct TargetPair { + public weak Gdk.Atom target; + public weak uint @flags; + public weak uint info; + } + [ReferenceType ()] + public struct TextAppearance { + public weak Gdk.Color bg_color; + public weak Gdk.Color fg_color; + public weak Gdk.Bitmap bg_stipple; + public weak Gdk.Bitmap fg_stipple; + public weak int rise; + public weak uint underline; + public weak uint strikethrough; + public weak uint draw_bg; + public weak uint inside_selection; + public weak uint is_text; + } + public struct TextAttributes { + public Gtk.TextAttributes copy (); + public void copy_values (Gtk.TextAttributes dest); + public GLib.Type get_type (); + public construct (); + public Gtk.TextAttributes @ref (); + public void unref (); + } + [ReferenceType ()] + public struct TextBTree { + } + public struct TextIter { + public bool backward_char (); + public bool backward_chars (int count); + public bool backward_cursor_position (); + public bool backward_cursor_positions (int count); + public bool backward_find_char (Gtk.TextCharPredicate pred, pointer user_data, Gtk.TextIter limit); + public bool backward_line (); + public bool backward_lines (int count); + public bool backward_search (string str, Gtk.TextSearchFlags @flags, Gtk.TextIter match_start, Gtk.TextIter match_end, Gtk.TextIter limit); + public bool backward_sentence_start (); + public bool backward_sentence_starts (int count); + public bool backward_to_tag_toggle (Gtk.TextTag tag); + public bool backward_visible_cursor_position (); + public bool backward_visible_cursor_positions (int count); + public bool backward_visible_line (); + public bool backward_visible_lines (int count); + public bool backward_visible_word_start (); + public bool backward_visible_word_starts (int count); + public bool backward_word_start (); + public bool backward_word_starts (int count); + public bool begins_tag (Gtk.TextTag tag); + public bool can_insert (bool default_editability); + public int compare (Gtk.TextIter rhs); + public Gtk.TextIter copy (); + public bool editable (bool default_setting); + public bool ends_line (); + public bool ends_sentence (); + public bool ends_tag (Gtk.TextTag tag); + public bool ends_word (); + public bool equal (Gtk.TextIter rhs); + public bool forward_char (); + public bool forward_chars (int count); + public bool forward_cursor_position (); + public bool forward_cursor_positions (int count); + public bool forward_find_char (Gtk.TextCharPredicate pred, pointer user_data, Gtk.TextIter limit); + public bool forward_line (); + public bool forward_lines (int count); + public bool forward_search (string str, Gtk.TextSearchFlags @flags, Gtk.TextIter match_start, Gtk.TextIter match_end, Gtk.TextIter limit); + public bool forward_sentence_end (); + public bool forward_sentence_ends (int count); + public void forward_to_end (); + public bool forward_to_line_end (); + public bool forward_to_tag_toggle (Gtk.TextTag tag); + public bool forward_visible_cursor_position (); + public bool forward_visible_cursor_positions (int count); + public bool forward_visible_line (); + public bool forward_visible_lines (int count); + public bool forward_visible_word_end (); + public bool forward_visible_word_ends (int count); + public bool forward_word_end (); + public bool forward_word_ends (int count); + public void free (); + public bool get_attributes (Gtk.TextAttributes values); + public Gtk.TextBuffer get_buffer (); + public int get_bytes_in_line (); + public unichar get_char (); + public int get_chars_in_line (); + public Gtk.TextChildAnchor get_child_anchor (); + public Pango.Language get_language (); + public int get_line (); + public int get_line_index (); + public int get_line_offset (); + public GLib.SList get_marks (); + public int get_offset (); + public Gdk.Pixbuf get_pixbuf (); + public string get_slice (Gtk.TextIter end); + public GLib.SList get_tags (); + public string get_text (Gtk.TextIter end); + public GLib.SList get_toggled_tags (bool toggled_on); + public GLib.Type get_type (); + public int get_visible_line_index (); + public int get_visible_line_offset (); + public string get_visible_slice (Gtk.TextIter end); + public string get_visible_text (Gtk.TextIter end); + public bool has_tag (Gtk.TextTag tag); + public bool in_range (Gtk.TextIter start, Gtk.TextIter end); + public bool inside_sentence (); + public bool inside_word (); + public bool is_cursor_position (); + public bool is_end (); + public bool is_start (); + public void order (Gtk.TextIter second); + public void set_line (int line_number); + public void set_line_index (int byte_on_line); + public void set_line_offset (int char_on_line); + public void set_offset (int char_offset); + public void set_visible_line_index (int byte_on_line); + public void set_visible_line_offset (int char_on_line); + public bool starts_line (); + public bool starts_sentence (); + public bool starts_word (); + public bool toggles_tag (Gtk.TextTag tag); + } + [ReferenceType ()] + public struct TextLogAttrCache { + } + [ReferenceType ()] + public struct TextPendingScroll { + } + [ReferenceType ()] + public struct TextWindow { + } + [ReferenceType ()] + public struct ThemeEngine { + } + [ReferenceType ()] + public struct ToggleActionEntry { + public weak string name; + public weak string stock_id; + public weak string label; + public weak string accelerator; + public weak string tooltip; + public weak GLib.Callback @callback; + public weak bool is_active; + } + [ReferenceType ()] + public struct TooltipsData { + public weak Gtk.Tooltips tooltips; + public weak Gtk.Widget widget; + public weak string tip_text; + public weak string tip_private; + public static Gtk.TooltipsData @get (Gtk.Widget widget); + } + public struct TreeIter { + public Gtk.TreeIter copy (); + public void free (); + public GLib.Type get_type (); + } + public struct TreePath { + public void append_index (int index_); + public int compare (Gtk.TreePath b); + public Gtk.TreePath copy (); + public void down (); + public void free (); + public int get_depth (); + public int get_indices (); + public GLib.Type get_type (); + public bool is_ancestor (Gtk.TreePath descendant); + public bool is_descendant (Gtk.TreePath ancestor); + public construct (); + public construct first (); + public construct from_indices (int first_index); + public construct from_string (string path); + public void next (); + public void prepend_index (int index_); + public bool prev (); + public string to_string (); + public bool up (); + } + public struct TreeRowReference { + public Gtk.TreeRowReference copy (); + public static void deleted (GLib.Object proxy, Gtk.TreePath path); + public void free (); + public Gtk.TreeModel get_model (); + public Gtk.TreePath get_path (); + public GLib.Type get_type (); + public static void inserted (GLib.Object proxy, Gtk.TreePath path); + public construct (Gtk.TreeModel model, Gtk.TreePath path); + public construct proxy (GLib.Object proxy, Gtk.TreeModel model, Gtk.TreePath path); + public static void reordered (GLib.Object proxy, Gtk.TreePath path, Gtk.TreeIter iter, int new_order); + public bool valid (); + } + [ReferenceType ()] + public struct WidgetAuxInfo { + public weak int x; + public weak int y; + public weak int width; + public weak int height; + public weak uint x_set; + public weak uint y_set; + } + [ReferenceType ()] + public struct WidgetShapeInfo { + public weak short offset_x; + public weak short offset_y; + public weak Gdk.Bitmap shape_mask; + } + [ReferenceType ()] + public struct WindowGeometryInfo { + } + [ReferenceType ()] + public struct Accel { + public static bool groups_activate (GLib.Object object, uint accel_key, Gdk.ModifierType accel_mods); + public static GLib.SList groups_from_object (GLib.Object object); + } + [ReferenceType ()] + public struct Accelerator { + public uint get_default_mod_mask (); + public static string get_label (uint accelerator_key, Gdk.ModifierType accelerator_mods); + public static string name (uint accelerator_key, Gdk.ModifierType accelerator_mods); + public static void parse (string accelerator, uint accelerator_key, Gdk.ModifierType accelerator_mods); + public static void set_default_mod_mask (Gdk.ModifierType default_mod_mask); + public static bool valid (uint keyval, Gdk.ModifierType modifiers); + } + [ReferenceType ()] + public struct Global { + public static bool _alternative_dialog_button_order (Gdk.Screen screen); + public static uint _binding_parse_binding (GLib.Scanner scanner); + public GLib.Type _cell_type_get_type (); + public static string _check_version (uint required_major, uint required_minor, uint required_micro); + public GLib.Type _clist_drag_pos_get_type (); + public void _disable_setlocale (); + public static void _enumerate_printers (Gtk.PrinterFunc func, pointer data, GLib.DestroyNotify destroy, bool wait); + public bool _events_pending (); + public Gdk.Event _get_current_event (); + public static bool _get_current_event_state (Gdk.ModifierType state); + public uint _get_current_event_time (); + public Pango.Language _get_default_language (); + public static Gtk.Widget _get_event_widget (Gdk.Event event); + public static GLib.OptionGroup _get_option_group (bool open_default_display); + public GLib.Type _identifier_get_type (); + public static void _paint_arrow (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gtk.ArrowType arrow_type, bool fill, int x, int y, int width, int height); + public static void _paint_box (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_box_gap (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + public static void _paint_check (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_diamond (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_expander (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, Gtk.ExpanderStyle expander_style); + public static void _paint_extension (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side); + public static void _paint_flat_box (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_focus (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_handle (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation); + public static void _paint_hline (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x1, int x2, int y); + public static void _paint_layout (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, bool use_text, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, Pango.Layout layout); + public static void _paint_option (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_polygon (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gdk.Point points, int npoints, bool fill); + public static void _paint_resize_grip (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, Gdk.WindowEdge edge, int x, int y, int width, int height); + public static void _paint_shadow (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_shadow_gap (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.PositionType gap_side, int gap_x, int gap_width); + public static void _paint_slider (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height, Gtk.Orientation orientation); + public static void _paint_tab (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gtk.ShadowType shadow_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int x, int y, int width, int height); + public static void _paint_vline (Gtk.Style style, Gdk.Window window, Gtk.StateType state_type, Gdk.Rectangle area, Gtk.Widget widget, string detail, int y1_, int y2_, int x); + public static bool _parse_args (int argc, string argv); + public GLib.Type _private_flags_get_type (); + public static void _propagate_event (Gtk.Widget widget, Gdk.Event event); + public static void _rgb_to_hsv (double r, double g, double b, double h, double s, double v); + public string _set_locale (); + public static void _show_about_dialog (Gtk.Window parent, string first_property_name); + public static void _text_layout_draw (pointer layout, Gtk.Widget widget, Gdk.Drawable drawable, Gdk.GC cursor_gc, int x_offset, int y_offset, int x, int y, int width, int height, GLib.List widgets); + } + [ReferenceType ()] + public struct Bindings { + public static bool activate (Gtk.Object object, uint keyval, Gdk.ModifierType modifiers); + public static bool activate_event (Gtk.Object object, Gdk.EventKey event); + } + [ReferenceType ()] + public struct Ctree { + public GLib.Type expander_style_get_type (); + public GLib.Type expansion_type_get_type (); + public GLib.Type line_style_get_type (); + public GLib.Type pos_get_type (); + } + [ReferenceType ()] + public struct Drag { + public static Gdk.DragContext begin (Gtk.Widget widget, Gtk.TargetList targets, Gdk.DragAction actions, int button, Gdk.Event event); + public static bool check_threshold (Gtk.Widget widget, int start_x, int start_y, int current_x, int current_y); + public static void dest_add_image_targets (Gtk.Widget widget); + public static void dest_add_text_targets (Gtk.Widget widget); + public static void dest_add_uri_targets (Gtk.Widget widget); + public static Gdk.Atom dest_find_target (Gtk.Widget widget, Gdk.DragContext context, Gtk.TargetList target_list); + public static Gtk.TargetList dest_get_target_list (Gtk.Widget widget); + public static bool dest_get_track_motion (Gtk.Widget widget); + public static void dest_set (Gtk.Widget widget, Gtk.DestDefaults @flags, Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public static void dest_set_proxy (Gtk.Widget widget, Gdk.Window proxy_window, Gdk.DragProtocol protocol, bool use_coordinates); + public static void dest_set_target_list (Gtk.Widget widget, Gtk.TargetList target_list); + public static void dest_set_track_motion (Gtk.Widget widget, bool track_motion); + public static void dest_unset (Gtk.Widget widget); + public static void finish (Gdk.DragContext context, bool success, bool del, uint time_); + public static void get_data (Gtk.Widget widget, Gdk.DragContext context, Gdk.Atom target, uint time_); + public static Gtk.Widget get_source_widget (Gdk.DragContext context); + public static void highlight (Gtk.Widget widget); + public static void set_icon_default (Gdk.DragContext context); + public static void set_icon_name (Gdk.DragContext context, string icon_name, int hot_x, int hot_y); + public static void set_icon_pixbuf (Gdk.DragContext context, Gdk.Pixbuf pixbuf, int hot_x, int hot_y); + public static void set_icon_pixmap (Gdk.DragContext context, Gdk.Colormap colormap, Gdk.Pixmap pixmap, Gdk.Bitmap mask, int hot_x, int hot_y); + public static void set_icon_stock (Gdk.DragContext context, string stock_id, int hot_x, int hot_y); + public static void set_icon_widget (Gdk.DragContext context, Gtk.Widget widget, int hot_x, int hot_y); + public static void source_add_image_targets (Gtk.Widget widget); + public static void source_add_text_targets (Gtk.Widget widget); + public static void source_add_uri_targets (Gtk.Widget widget); + public static Gtk.TargetList source_get_target_list (Gtk.Widget widget); + public static void source_set (Gtk.Widget widget, Gdk.ModifierType start_button_mask, Gtk.TargetEntry targets, int n_targets, Gdk.DragAction actions); + public static void source_set_icon (Gtk.Widget widget, Gdk.Colormap colormap, Gdk.Pixmap pixmap, Gdk.Bitmap mask); + public static void source_set_icon_name (Gtk.Widget widget, string icon_name); + public static void source_set_icon_pixbuf (Gtk.Widget widget, Gdk.Pixbuf pixbuf); + public static void source_set_icon_stock (Gtk.Widget widget, string stock_id); + public static void source_set_target_list (Gtk.Widget widget, Gtk.TargetList target_list); + public static void source_unset (Gtk.Widget widget); + public static void unhighlight (Gtk.Widget widget); + } + [ReferenceType ()] + public struct Draw { + public static void insertion_cursor (Gtk.Widget widget, Gdk.Drawable drawable, Gdk.Rectangle area, Gdk.Rectangle location, bool is_primary, Gtk.TextDirection direction, bool draw_arrow); + } + [ReferenceType ()] + public struct Gc { + public static Gdk.GC @get (int depth, Gdk.Colormap colormap, Gdk.GCValues values, Gdk.GCValuesMask values_mask); + public static void release (Gdk.GC gc); + } + [ReferenceType ()] + public struct Grab { + public static void add (Gtk.Widget widget); + public Gtk.Widget get_current (); + public static void remove (Gtk.Widget widget); + } + [ReferenceType ()] + public struct Icon { + public static Gtk.IconSize size_from_name (string name); + public static string size_get_name (Gtk.IconSize size); + public static bool size_lookup (Gtk.IconSize size, int width, int height); + public static bool size_lookup_for_settings (Gtk.Settings settings, Gtk.IconSize size, int width, int height); + public static Gtk.IconSize size_register (string name, int width, int height); + public static void size_register_alias (string alias, Gtk.IconSize target); + } + [ReferenceType ()] + public struct Idle { + } + [ReferenceType ()] + public struct Init { + public static void abi_check (int argc, string argv, int num_checks, ulong sizeof_GtkWindow, ulong sizeof_GtkBox); + public static void add (Gtk.Function function, pointer data); + public static bool check (int argc, string argv); + public static bool check_abi_check (int argc, string argv, int num_checks, ulong sizeof_GtkWindow, ulong sizeof_GtkBox); + public static bool with_args (int argc, string argv, string parameter_string, GLib.OptionEntry entries, string translation_domain, GLib.Error error); + } + [ReferenceType ()] + public struct Input { + } + [ReferenceType ()] + public struct Key { + public static uint snooper_install (Gtk.KeySnoopFunc snooper, pointer func_data); + public static void snooper_remove (uint snooper_handler_id); + } + [ReferenceType ()] + public struct Main { + public static void do_event (Gdk.Event event); + public bool iteration (); + public static bool iteration_do (bool blocking); + public uint level (); + public void quit (); + } + [ReferenceType ()] + public struct Print { + public GLib.Quark error_quark (); + public static Gtk.PageSetup run_page_setup_dialog (Gtk.Window parent, Gtk.PageSetup page_setup, Gtk.PrintSettings settings); + public static void run_page_setup_dialog_async (Gtk.Window parent, Gtk.PageSetup page_setup, Gtk.PrintSettings settings, Gtk.PageSetupDoneFunc done_cb, pointer data); + } + [ReferenceType ()] + public struct Quit { + public static uint add (uint main_level, Gtk.Function function, pointer data); + public static void add_destroy (uint main_level, Gtk.Object object); + public static void remove (uint quit_handler_id); + public static void remove_by_data (pointer data); + } + [ReferenceType ()] + public struct Rc { + public static void add_default_file (string filename); + public static string find_module_in_path (string module_file); + public static string find_pixmap_in_path (Gtk.Settings settings, GLib.Scanner scanner, string pixmap_file); + public string get_default_files (); + public string get_im_module_file (); + public string get_im_module_path (); + public string get_module_dir (); + public static Gtk.Style get_style (Gtk.Widget widget); + public static Gtk.Style get_style_by_paths (Gtk.Settings settings, string widget_path, string class_path, GLib.Type type); + public string get_theme_dir (); + public static void parse (string filename); + public static uint parse_color (GLib.Scanner scanner, Gdk.Color color); + public static uint parse_priority (GLib.Scanner scanner, Gtk.PathPriorityType priority); + public static uint parse_state (GLib.Scanner scanner, Gtk.StateType state); + public static void parse_string (string rc_string); + public bool reparse_all (); + public static bool reparse_all_for_settings (Gtk.Settings settings, bool force_load); + public static void reset_styles (Gtk.Settings settings); + public GLib.Scanner scanner_new (); + public static void set_default_files (string filenames); + } + [ReferenceType ()] + public struct Selection { + public static void add_target (Gtk.Widget widget, Gdk.Atom selection, Gdk.Atom target, uint info); + public static void add_targets (Gtk.Widget widget, Gdk.Atom selection, Gtk.TargetEntry targets, uint ntargets); + public static void clear_targets (Gtk.Widget widget, Gdk.Atom selection); + public static bool convert (Gtk.Widget widget, Gdk.Atom selection, Gdk.Atom target, uint time_); + public static bool owner_set (Gtk.Widget widget, Gdk.Atom selection, uint time_); + public static bool owner_set_for_display (Gdk.Display display, Gtk.Widget widget, Gdk.Atom selection, uint time_); + public static void remove_all (Gtk.Widget widget); + } + [ReferenceType ()] + public struct Signal { + } + [ReferenceType ()] + public struct Stock { + public static void add (Gtk.StockItem items, uint n_items); + public static void add_static (Gtk.StockItem items, uint n_items); + public GLib.SList list_ids (); + public static bool lookup (string stock_id, Gtk.StockItem item); + public static void set_translate_func (string domain, Gtk.TranslateFunc func, pointer data, Gtk.DestroyNotify notify); + } + [ReferenceType ()] + public struct Target { + public static void table_free (Gtk.TargetEntry targets, int n_targets); + public static Gtk.TargetEntry table_new_from_list (Gtk.TargetList list, int n_targets); + } + [ReferenceType ()] + public struct Targets { + public static bool include_image (Gdk.Atom targets, int n_targets, bool writable); + public static bool include_rich_text (Gdk.Atom targets, int n_targets, Gtk.TextBuffer buffer); + public static bool include_text (Gdk.Atom targets, int n_targets); + public static bool include_uri (Gdk.Atom targets, int n_targets); + } + [ReferenceType ()] + public struct Timeout { + } + [ReferenceType ()] + public struct Tree { + public static bool get_row_drag_data (Gtk.SelectionData selection_data, Gtk.TreeModel tree_model, Gtk.TreePath path); + public static bool set_row_drag_data (Gtk.SelectionData selection_data, Gtk.TreeModel tree_model, Gtk.TreePath path); + } + [ReferenceType ()] + public struct Type { + public pointer @class (); + } + [CCode (cprefix = "GTK_ACCEL_")] + public enum AccelFlags { + VISIBLE, + LOCKED, + MASK, + } + [CCode (cprefix = "GTK_ANCHOR_")] + public enum AnchorType { + CENTER, + NORTH, + NORTH_WEST, + NORTH_EAST, + SOUTH, + SOUTH_WEST, + SOUTH_EAST, + WEST, + EAST, + N, + NW, + NE, + S, + SW, + SE, + W, + E, } - + [CCode (cprefix = "GTK_ARG_")] + public enum ArgFlags { + READABLE, + WRITABLE, + CONSTRUCT, + CONSTRUCT_ONLY, + CHILD_ARG, + } + [CCode (cprefix = "GTK_ARROW_")] + public enum ArrowType { + UP, + DOWN, + LEFT, + RIGHT, + NONE, + } + [CCode (cprefix = "GTK_ASSISTANT_PAGE_")] + public enum AssistantPageType { + CONTENT, + INTRO, + CONFIRM, + SUMMARY, + PROGRESS, + } + [CCode (cprefix = "GTK_")] + public enum AttachOptions { + EXPAND, + SHRINK, + FILL, + } + [CCode (cprefix = "GTK_BUTTONBOX_")] + public enum ButtonBoxStyle { + DEFAULT_STYLE, + SPREAD, + EDGE, + START, + END, + } + [CCode (cprefix = "GTK_BUTTONS_")] + public enum ButtonsType { + NONE, + OK, + CLOSE, + CANCEL, + YES_NO, + OK_CANCEL, + } + [CCode (cprefix = "GTK_CALENDAR_")] + public enum CalendarDisplayOptions { + SHOW_HEADING, + SHOW_DAY_NAMES, + NO_MONTH_CHANGE, + SHOW_WEEK_NUMBERS, + WEEK_START_MONDAY, + } + [CCode (cprefix = "GTK_CELL_RENDERER_ACCEL_MODE_")] + public enum CellRendererAccelMode { + GTK, + OTHER, + } + [CCode (cprefix = "GTK_CELL_RENDERER_MODE_")] + public enum CellRendererMode { + INERT, + ACTIVATABLE, + EDITABLE, + } + [CCode (cprefix = "GTK_CELL_RENDERER_")] + public enum CellRendererState { + SELECTED, + PRELIT, + INSENSITIVE, + SORTED, + FOCUSED, + } + [CCode (cprefix = "GTK_CORNER_")] + public enum CornerType { + TOP_LEFT, + BOTTOM_LEFT, + TOP_RIGHT, + BOTTOM_RIGHT, + } + [CCode (cprefix = "GTK_CURVE_TYPE_")] + public enum CurveType { + LINEAR, + SPLINE, + FREE, + } + [CCode (cprefix = "GTK_DEBUG_")] + public enum DebugFlag { + MISC, + PLUGSOCKET, + TEXT, + TREE, + UPDATES, + KEYBINDINGS, + MULTIHEAD, + MODULES, + GEOMETRY, + ICONTHEME, + PRINTING, + } + [CCode (cprefix = "GTK_DELETE_")] + public enum DeleteType { + CHARS, + WORD_ENDS, + WORDS, + DISPLAY_LINES, + DISPLAY_LINE_ENDS, + PARAGRAPH_ENDS, + PARAGRAPHS, + WHITESPACE, + } + [CCode (cprefix = "GTK_DEST_DEFAULT_")] + public enum DestDefaults { + MOTION, + HIGHLIGHT, + DROP, + ALL, + } + [CCode (cprefix = "GTK_DIALOG_")] public enum DialogFlags { MODAL, DESTROY_WITH_PARENT, - NO_SEPARATOR + NO_SEPARATOR, + } + [CCode (cprefix = "GTK_DIR_")] + public enum DirectionType { + TAB_FORWARD, + TAB_BACKWARD, + UP, + DOWN, + LEFT, + RIGHT, + } + [CCode (cprefix = "GTK_EXPANDER_")] + public enum ExpanderStyle { + COLLAPSED, + SEMI_COLLAPSED, + SEMI_EXPANDED, + EXPANDED, + } + [CCode (cprefix = "GTK_FILE_CHOOSER_ACTION_")] + public enum FileChooserAction { + OPEN, + SAVE, + SELECT_FOLDER, + CREATE_FOLDER, + } + [CCode (cprefix = "GTK_FILE_CHOOSER_CONFIRMATION_")] + public enum FileChooserConfirmation { + CONFIRM, + ACCEPT_FILENAME, + SELECT_AGAIN, + } + [CCode (cprefix = "GTK_FILE_CHOOSER_ERROR_")] + public enum FileChooserError { + NONEXISTENT, + BAD_FILENAME, + ALREADY_EXISTS, + } + [CCode (cprefix = "GTK_FILE_FILTER_")] + public enum FileFilterFlags { + FILENAME, + URI, + DISPLAY_NAME, + MIME_TYPE, + } + [CCode (cprefix = "GTK_IM_PREEDIT_")] + public enum IMPreeditStyle { + NOTHING, + CALLBACK, + NONE, + } + [CCode (cprefix = "GTK_IM_STATUS_")] + public enum IMStatusStyle { + NOTHING, + CALLBACK, + NONE, } - - public class MessageDialog : Dialog { - public construct (Window parent, DialogFlags _flags, MessageType type, ButtonsType buttons, string message_format, ...); + [CCode (cprefix = "GTK_ICON_LOOKUP_")] + public enum IconLookupFlags { + NO_SVG, + FORCE_SVG, + USE_BUILTIN, } - + [CCode (cprefix = "GTK_ICON_SIZE_")] + public enum IconSize { + INVALID, + MENU, + SMALL_TOOLBAR, + LARGE_TOOLBAR, + BUTTON, + DND, + DIALOG, + } + [CCode (cprefix = "GTK_ICON_THEME_")] + public enum IconThemeError { + NOT_FOUND, + FAILED, + } + [CCode (cprefix = "GTK_ICON_VIEW_")] + public enum IconViewDropPosition { + NO_DROP, + DROP_INTO, + DROP_LEFT, + DROP_RIGHT, + DROP_ABOVE, + DROP_BELOW, + } + [CCode (cprefix = "GTK_IMAGE_")] + public enum ImageType { + EMPTY, + PIXMAP, + IMAGE, + PIXBUF, + STOCK, + ICON_SET, + ANIMATION, + ICON_NAME, + } + [CCode (cprefix = "GTK_JUSTIFY_")] + public enum Justification { + LEFT, + RIGHT, + CENTER, + FILL, + } + [CCode (cprefix = "GTK_MATCH_")] + public enum MatchType { + ALL, + ALL_TAIL, + HEAD, + TAIL, + EXACT, + LAST, + } + [CCode (cprefix = "GTK_MENU_DIR_")] + public enum MenuDirectionType { + PARENT, + CHILD, + NEXT, + PREV, + } + [CCode (cprefix = "GTK_MESSAGE_")] public enum MessageType { INFO, WARNING, QUESTION, - ERROR + ERROR, + OTHER, } - - public enum ButtonsType { + [CCode (cprefix = "GTK_")] + public enum MetricType { + PIXELS, + INCHES, + CENTIMETERS, + } + [CCode (cprefix = "GTK_MOVEMENT_")] + public enum MovementStep { + LOGICAL_POSITIONS, + VISUAL_POSITIONS, + WORDS, + DISPLAY_LINES, + DISPLAY_LINE_ENDS, + PARAGRAPHS, + PARAGRAPH_ENDS, + PAGES, + BUFFER_ENDS, + HORIZONTAL_PAGES, + } + [CCode (cprefix = "GTK_NOTEBOOK_TAB_")] + public enum NotebookTab { + FIRST, + LAST, + } + [CCode (cprefix = "GTK_")] + public enum ObjectFlags { + IN_DESTRUCTION, + FLOATING, + RESERVED_1, + RESERVED_2, + } + [CCode (cprefix = "GTK_ORIENTATION_")] + public enum Orientation { + HORIZONTAL, + VERTICAL, + } + [CCode (cprefix = "GTK_PACK_DIRECTION_")] + public enum PackDirection { + LTR, + RTL, + TTB, + BTT, + } + [CCode (cprefix = "GTK_PACK_")] + public enum PackType { + START, + END, + } + [CCode (cprefix = "GTK_PAGE_ORIENTATION_")] + public enum PageOrientation { + PORTRAIT, + LANDSCAPE, + REVERSE_PORTRAIT, + REVERSE_LANDSCAPE, + } + [CCode (cprefix = "GTK_PAGE_SET_")] + public enum PageSet { + ALL, + EVEN, + ODD, + } + [CCode (cprefix = "GTK_PATH_PRIO_")] + public enum PathPriorityType { + LOWEST, + GTK, + APPLICATION, + THEME, + RC, + HIGHEST, + } + [CCode (cprefix = "GTK_PATH_")] + public enum PathType { + WIDGET, + WIDGET_CLASS, + CLASS, + } + [CCode (cprefix = "GTK_POLICY_")] + public enum PolicyType { + ALWAYS, + AUTOMATIC, + NEVER, + } + [CCode (cprefix = "GTK_POS_")] + public enum PositionType { + LEFT, + RIGHT, + TOP, + BOTTOM, + } + [CCode (cprefix = "GTK_PREVIEW_")] + public enum PreviewType { + COLOR, + GRAYSCALE, + } + [CCode (cprefix = "GTK_PRINT_BACKEND_ERROR_")] + public enum PrintBackendError { + GENERIC, + } + [CCode (cprefix = "GTK_PRINT_CAPABILITY_")] + public enum PrintCapabilities { + PAGE_SET, + COPIES, + COLLATE, + REVERSE, + SCALE, + GENERATE_PDF, + GENERATE_PS, + PREVIEW, + } + [CCode (cprefix = "GTK_PRINT_DUPLEX_")] + public enum PrintDuplex { + SIMPLEX, + HORIZONTAL, + VERTICAL, + } + [CCode (cprefix = "GTK_PRINT_ERROR_")] + public enum PrintError { + GENERAL, + INTERNAL_ERROR, + NOMEM, + } + [CCode (cprefix = "GTK_PRINT_OPERATION_ACTION_")] + public enum PrintOperationAction { + PRINT_DIALOG, + PRINT, + PREVIEW, + EXPORT, + } + [CCode (cprefix = "GTK_PRINT_OPERATION_RESULT_")] + public enum PrintOperationResult { + ERROR, + APPLY, + CANCEL, + IN_PROGRESS, + } + [CCode (cprefix = "GTK_PRINT_PAGES_")] + public enum PrintPages { + ALL, + CURRENT, + RANGES, + } + [CCode (cprefix = "GTK_PRINT_QUALITY_")] + public enum PrintQuality { + LOW, + NORMAL, + HIGH, + DRAFT, + } + [CCode (cprefix = "GTK_PRINT_STATUS_")] + public enum PrintStatus { + INITIAL, + PREPARING, + GENERATING_DATA, + SENDING_DATA, + PENDING, + PENDING_ISSUE, + PRINTING, + FINISHED, + FINISHED_ABORTED, + } + [CCode (cprefix = "GTK_PRINTER_OPTION_TYPE_")] + public enum PrinterOptionType { + BOOLEAN, + PICKONE, + PICKONE_PASSWORD, + PICKONE_PASSCODE, + PICKONE_REAL, + PICKONE_INT, + PICKONE_STRING, + ALTERNATIVE, + STRING, + FILESAVE, + } + [CCode (cprefix = "GTK_PROGRESS_")] + public enum ProgressBarOrientation { + LEFT_TO_RIGHT, + RIGHT_TO_LEFT, + BOTTOM_TO_TOP, + TOP_TO_BOTTOM, + } + [CCode (cprefix = "GTK_PROGRESS_")] + public enum ProgressBarStyle { + CONTINUOUS, + DISCRETE, + } + [CCode (cprefix = "GTK_RC_")] + public enum RcFlags { + FG, + BG, + TEXT, + BASE, + } + [CCode (cprefix = "GTK_RC_TOKEN_")] + public enum RcTokenType { + INVALID, + INCLUDE, + NORMAL, + ACTIVE, + PRELIGHT, + SELECTED, + INSENSITIVE, + FG, + BG, + TEXT, + BASE, + XTHICKNESS, + YTHICKNESS, + FONT, + FONTSET, + FONT_NAME, + BG_PIXMAP, + PIXMAP_PATH, + STYLE, + BINDING, + BIND, + WIDGET, + WIDGET_CLASS, + CLASS, + LOWEST, + GTK, + APPLICATION, + THEME, + RC, + HIGHEST, + ENGINE, + MODULE_PATH, + IM_MODULE_PATH, + IM_MODULE_FILE, + STOCK, + LTR, + RTL, + COLOR, + LAST, + } + [CCode (cprefix = "GTK_RECENT_CHOOSER_ERROR_")] + public enum RecentChooserError { + NOT_FOUND, + INVALID_URI, + } + [CCode (cprefix = "GTK_RECENT_CHOOSER_PROP_")] + public enum RecentChooserProp { + FIRST, + RECENT_MANAGER, + SHOW_PRIVATE, + SHOW_NOT_FOUND, + SHOW_TIPS, + SHOW_ICONS, + SELECT_MULTIPLE, + LIMIT, + LOCAL_ONLY, + SORT_TYPE, + FILTER, + LAST, + } + [CCode (cprefix = "GTK_RECENT_FILTER_")] + public enum RecentFilterFlags { + URI, + DISPLAY_NAME, + MIME_TYPE, + APPLICATION, + GROUP, + AGE, + } + [CCode (cprefix = "GTK_RECENT_MANAGER_ERROR_")] + public enum RecentManagerError { + NOT_FOUND, + INVALID_URI, + INVALID_ENCODING, + NOT_REGISTERED, + READ, + WRITE, + UNKNOWN, + } + [CCode (cprefix = "GTK_RECENT_SORT_")] + public enum RecentSortType { + NONE, + MRU, + LRU, + CUSTOM, + } + [CCode (cprefix = "GTK_RELIEF_")] + public enum ReliefStyle { + NORMAL, + HALF, + NONE, + } + [CCode (cprefix = "GTK_RESIZE_")] + public enum ResizeMode { + PARENT, + QUEUE, + IMMEDIATE, + } + [CCode (cprefix = "GTK_RESPONSE_")] + public enum ResponseType { NONE, + REJECT, + ACCEPT, + DELETE_EVENT, OK, - CLOSE, CANCEL, - YES_NO, - OK_CANCEL + CLOSE, + YES, + NO, + APPLY, + HELP, } - - public class Window : Container { - public string title { get; set construct; } - public WindowType type { get; construct; } - - public void set_title (string title); + [CCode (cprefix = "GTK_SCROLL_")] + public enum ScrollStep { + STEPS, + PAGES, + ENDS, + HORIZONTAL_STEPS, + HORIZONTAL_PAGES, + HORIZONTAL_ENDS, } - - public class Label : Misc { - public string label { get; set; } - public bool use_markup { get; set; } + [CCode (cprefix = "GTK_SCROLL_")] + public enum ScrollType { + NONE, + JUMP, + STEP_BACKWARD, + STEP_FORWARD, + PAGE_BACKWARD, + PAGE_FORWARD, + STEP_UP, + STEP_DOWN, + PAGE_UP, + PAGE_DOWN, + STEP_LEFT, + STEP_RIGHT, + PAGE_LEFT, + PAGE_RIGHT, + START, + END, } - - public class ProgressBar : Widget { - public void pulse (); + [CCode (cprefix = "GTK_SELECTION_")] + public enum SelectionMode { + NONE, + SINGLE, + BROWSE, + MULTIPLE, + EXTENDED, } - - public class StatusIcon { - public construct from_stock (string! stock_id); - - public bool blinking { get; set; } - public bool visible { get; set; } - - public signal void activate (); - public signal void popup_menu (uint button, uint activate_time); - public signal bool size_changed (int size); + [CCode (cprefix = "GTK_SENSITIVITY_")] + public enum SensitivityType { + AUTO, + ON, + OFF, } - - public class Button : Container { - public construct with_label (string label); - - public string label { get; set construct; } - - public signal void activate (); - public signal void clicked (); - public signal void enter (); + [CCode (cprefix = "GTK_SHADOW_")] + public enum ShadowType { + NONE, + IN, + OUT, + ETCHED_IN, + ETCHED_OUT, } - - public class Entry : Widget { - public construct (); + [CCode (cprefix = "GTK_SIDE_")] + public enum SideType { + TOP, + BOTTOM, + LEFT, + RIGHT, } - - public class TextBuffer { + [CCode (cprefix = "GTK_RUN_")] + public enum SignalRunType { + FIRST, + LAST, + BOTH, + NO_RECURSE, + ACTION, + NO_HOOKS, } - - public class TextView : Container { + [CCode (cprefix = "GTK_SIZE_GROUP_")] + public enum SizeGroupMode { + NONE, + HORIZONTAL, + VERTICAL, + BOTH, } - - public interface TreeModel { - public abstract void get_value (ref TreeIter iter, int column, GLib.Value value); + [CCode (cprefix = "GTK_SORT_")] + public enum SortType { + ASCENDING, + DESCENDING, } - - public class TreeSelection { - public bool get_selected (out TreeModel model, ref TreeIter iter); - - public signal void changed (); + [CCode (cprefix = "GTK_UPDATE_")] + public enum SpinButtonUpdatePolicy { + ALWAYS, + IF_VALID, } - - public struct TreeIter { - public int stamp; - public pointer user_data; - public pointer user_data2; - public pointer user_data3; + [CCode (cprefix = "GTK_SPIN_")] + public enum SpinType { + STEP_FORWARD, + STEP_BACKWARD, + PAGE_FORWARD, + PAGE_BACKWARD, + HOME, + END, + USER_DEFINED, } - - [CCode (cprefix = "GTK_TREE_VIEW_COLUMN_")] - public enum TreeViewColumnSizing { - FIXED + [CCode (cprefix = "GTK_STATE_")] + public enum StateType { + NORMAL, + ACTIVE, + PRELIGHT, + SELECTED, + INSENSITIVE, } - - public class TreeViewColumn : Object { - public construct with_attributes (string title, CellRenderer cell, ...); - - public int fixed_width { get; set; } - public TreeViewColumnSizing sizing { get; set; } + [CCode (cprefix = "GTK_DIRECTION_")] + public enum SubmenuDirection { + LEFT, + RIGHT, } - - public class TreeView : Container { - public TreeModel model { get; set; } - - public TreeSelection get_selection (); - public int append_column (TreeViewColumn column); + [CCode (cprefix = "GTK_")] + public enum SubmenuPlacement { + TOP_BOTTOM, + LEFT_RIGHT, } - - public abstract class CellRenderer : Object { + [CCode (cprefix = "GTK_TARGET_SAME_")] + public enum TargetFlags { + APP, + WIDGET, } - - public class CellRendererText : CellRenderer { - [NoAccessorMethod ()] - public Pango.Style style { get; set; } + [CCode (cprefix = "GTK_TEXT_BUFFER_TARGET_INFO_")] + public enum TextBufferTargetInfo { + BUFFER_CONTENTS, + RICH_TEXT, + TEXT, } - - public class TreeStore : TreeModel { - public construct (int n_columns, ...); - public void @set (ref TreeIter iter, ...); - public void append (ref TreeIter iter, ref TreeIter parent); + [CCode (cprefix = "GTK_TEXT_DIR_")] + public enum TextDirection { + NONE, + LTR, + RTL, } - - public class Menu : MenuShell { - public construct (); + [CCode (cprefix = "GTK_TEXT_SEARCH_")] + public enum TextSearchFlags { + VISIBLE_ONLY, + TEXT_ONLY, } - - public class MenuBar : MenuShell { - public construct (); + [CCode (cprefix = "GTK_TEXT_WINDOW_")] + public enum TextWindowType { + PRIVATE, + WIDGET, + TEXT, + LEFT, + RIGHT, + TOP, + BOTTOM, } - - public class MenuItem : Item { - public construct with_label (string label); - public void set_submenu (Menu submenu); + [CCode (cprefix = "GTK_TOOLBAR_CHILD_")] + public enum ToolbarChildType { + SPACE, + BUTTON, + TOGGLEBUTTON, + RADIOBUTTON, + WIDGET, } - - public abstract class MenuShell : Container { - public void append (MenuItem child); + [CCode (cprefix = "GTK_TOOLBAR_SPACE_")] + public enum ToolbarSpaceStyle { + EMPTY, + LINE, } - - public class Toolbar : Container { - public construct (); + [CCode (cprefix = "GTK_TOOLBAR_")] + public enum ToolbarStyle { + ICONS, + TEXT, + BOTH, + BOTH_HORIZ, } - - public class HBox : Box { - public construct (bool homogeneous, int spacing); + [CCode (cprefix = "GTK_TREE_MODEL_")] + public enum TreeModelFlags { + ITERS_PERSIST, + LIST_ONLY, } - - public class VBox : Box { - public construct (bool homogeneous, int spacing); + [CCode (cprefix = "GTK_TREE_VIEW_COLUMN_")] + public enum TreeViewColumnSizing { + GROW_ONLY, + AUTOSIZE, + FIXED, } - - public class VPaned : Paned { + [CCode (cprefix = "GTK_TREE_VIEW_DROP_")] + public enum TreeViewDropPosition { + BEFORE, + AFTER, + INTO_OR_BEFORE, + INTO_OR_AFTER, + } + [CCode (cprefix = "GTK_TREE_VIEW_GRID_LINES_")] + public enum TreeViewGridLines { + NONE, + HORIZONTAL, + VERTICAL, + BOTH, } - - public class Notebook : Container { - public int append_page (Widget child, Widget tab_label); + [CCode (cprefix = "GTK_UI_MANAGER_")] + public enum UIManagerItemType { + AUTO, + MENUBAR, + MENU, + TOOLBAR, + PLACEHOLDER, + POPUP, + MENUITEM, + TOOLITEM, + SEPARATOR, + ACCELERATOR, } - - public class ScrolledWindow : Bin { + [CCode (cprefix = "GTK_UNIT_")] + public enum Unit { + PIXEL, + POINTS, + INCH, + MM, } - - public abstract class Bin : Container { + [CCode (cprefix = "GTK_UPDATE_")] + public enum UpdateType { + CONTINUOUS, + DISCONTINUOUS, + DELAYED, } - - public abstract class Box : Container { - public bool homogeneous { get; set; } - public int spacing { get; set; } - - public void pack_start (Widget child, bool expand, bool fill, uint padding); - public void pack_start_defaults (Widget widget); + [CCode (cprefix = "GTK_VISIBILITY_")] + public enum Visibility { + NONE, + PARTIAL, + FULL, } - - public abstract class Container : Widget { - public void add (Widget w); + [CCode (cprefix = "GTK_")] + public enum WidgetFlags { + TOPLEVEL, + NO_WINDOW, + REALIZED, + MAPPED, + VISIBLE, + SENSITIVE, + PARENT_SENSITIVE, + CAN_FOCUS, + HAS_FOCUS, + CAN_DEFAULT, + HAS_DEFAULT, + HAS_GRAB, + RC_STYLE, + COMPOSITE_CHILD, + NO_REPARENT, + APP_PAINTABLE, + RECEIVES_DEFAULT, + DOUBLE_BUFFERED, + NO_SHOW_ALL, } - - public abstract class Item : Bin { + [CCode (cprefix = "GTK_WIDGET_HELP_")] + public enum WidgetHelpType { + TOOLTIP, + WHATS_THIS, } - - public abstract class Misc : Widget { + [CCode (cprefix = "GTK_WIN32_EMBED_")] + public enum Win32EmbedMessageType { + WINDOW_ACTIVATE, + WINDOW_DEACTIVATE, + FOCUS_IN, + FOCUS_OUT, + MODALITY_ON, + MODALITY_OFF, + PARENT_NOTIFY, + EVENT_PLUG_MAPPED, + PLUG_RESIZED, + REQUEST_FOCUS, + FOCUS_NEXT, + FOCUS_PREV, + GRAB_KEY, + UNGRAB_KEY, + LAST, } - - public abstract class Object : GLib.InitiallyUnowned { - public signal void destroy (); + [CCode (cprefix = "GTK_WIN_POS_")] + public enum WindowPosition { + NONE, + CENTER, + MOUSE, + CENTER_ALWAYS, + CENTER_ON_PARENT, } - - public abstract class Paned : Container { - public void pack2 (Widget! child, bool resize, bool shrink); + [CCode (cprefix = "GTK_WINDOW_")] + public enum WindowType { + TOPLEVEL, + POPUP, } - - public abstract class Widget : Object { - public void show (); - public void show_all (); - public void hide (); - - [NoAccessorMethod ()] - public bool visible { get; set; } + [CCode (cprefix = "GTK_WRAP_")] + public enum WrapMode { + NONE, + CHAR, + WORD, + WORD_CHAR, } + public callback void AboutDialogActivateLinkFunc (Gtk.AboutDialog about, string link, pointer data); + public callback bool AccelGroupActivate (Gtk.AccelGroup accel_group, GLib.Object acceleratable, uint keyval, Gdk.ModifierType modifier); + public callback bool AccelGroupFindFunc (Gtk.AccelKey key, GLib.Closure closure, pointer data); + public callback void AccelMapForeach (pointer data, string accel_path, uint accel_key, Gdk.ModifierType accel_mods, bool changed); + public callback int AssistantPageFunc (int current_page, pointer data); + public callback void Callback (Gtk.Widget widget, pointer data); + public callback void CellLayoutDataFunc (Gtk.CellLayout cell_layout, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter, pointer data); + public callback void ClipboardClearFunc (Gtk.Clipboard clipboard, pointer user_data_or_owner); + public callback void ClipboardGetFunc (Gtk.Clipboard clipboard, Gtk.SelectionData selection_data, uint info, pointer user_data_or_owner); + public callback void ClipboardImageReceivedFunc (Gtk.Clipboard clipboard, Gdk.Pixbuf pixbuf, pointer data); + public callback void ClipboardReceivedFunc (Gtk.Clipboard clipboard, Gtk.SelectionData selection_data, pointer data); + public callback void ClipboardRichTextReceivedFunc (Gtk.Clipboard clipboard, Gdk.Atom format, uchar text, ulong length, pointer data); + public callback void ClipboardTargetsReceivedFunc (Gtk.Clipboard clipboard, Gdk.Atom atoms, int n_atoms, pointer data); + public callback void ClipboardTextReceivedFunc (Gtk.Clipboard clipboard, string text, pointer data); + public callback void ColorSelectionChangePaletteFunc (Gdk.Color colors, int n_colors); + public callback void ColorSelectionChangePaletteWithScreenFunc (Gdk.Screen screen, Gdk.Color colors, int n_colors); + public callback void DestroyNotify (pointer data); + public callback bool EntryCompletionMatchFunc (Gtk.EntryCompletion completion, string key, Gtk.TreeIter iter, pointer user_data); + public callback bool FileFilterFunc (Gtk.FileFilterInfo filter_info, pointer data); + public callback bool Function (pointer data); + public callback void IconViewForeachFunc (Gtk.IconView icon_view, Gtk.TreePath path, pointer data); + public callback void ItemFactoryCallback (); + public callback void ItemFactoryCallback1 (pointer callback_data, uint callback_action, Gtk.Widget widget); + public callback void ItemFactoryCallback2 (); + public callback int KeySnoopFunc (Gtk.Widget grab_widget, Gdk.EventKey event, pointer func_data); + public callback void LinkButtonUriFunc (Gtk.LinkButton button, string link, pointer user_data); + public callback void MenuCallback (Gtk.Widget widget, pointer user_data); + public callback void MenuDetachFunc (Gtk.Widget attach_widget, Gtk.Menu menu); + public callback void MenuPositionFunc (Gtk.Menu menu, int x, int y, bool push_in, pointer user_data); + public callback void MnemonicHashForeach (uint keyval, GLib.SList targets, pointer data); + public callback void ModuleDisplayInitFunc (Gdk.Display display); + public callback void ModuleInitFunc (int argc, string argv); + public callback Gtk.Notebook NotebookWindowCreationFunc (Gtk.Notebook source, Gtk.Widget page, int x, int y, pointer data); + public callback void PageSetupDoneFunc (Gtk.PageSetup page_setup, pointer data); + public callback void PrintFunc (pointer func_data, string str); + public callback void PrintJobCompleteFunc (Gtk.PrintJob print_job, pointer user_data, GLib.Error error); + public callback void PrintSettingsFunc (string key, string value, pointer user_data); + public callback bool PrinterFunc (Gtk.Printer printer, pointer data); + public callback void PrinterOptionSetFunc (Gtk.PrinterOption option, pointer user_data); + public callback bool RcPropertyParser (GLib.ParamSpec pspec, GLib.String rc_string, GLib.Value property_value); + public callback bool RecentFilterFunc (Gtk.RecentFilterInfo filter_info, pointer user_data); + public callback int RecentSortFunc (Gtk.RecentInfo a, Gtk.RecentInfo b, pointer user_data); + public callback void SignalFunc (); + public callback bool TextBufferDeserializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter iter, uchar data, ulong length, bool create_tags, pointer user_data, GLib.Error error); + public callback uchar TextBufferSerializeFunc (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter start, Gtk.TextIter end, ulong length, pointer user_data); + public callback bool TextCharPredicate (unichar ch, pointer user_data); + public callback void TextTagTableForeach (Gtk.TextTag tag, pointer data); + public callback string TranslateFunc (string path, pointer func_data); + public callback void TreeCellDataFunc (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter, pointer data); + public callback void TreeDestroyCountFunc (Gtk.TreeView tree_view, Gtk.TreePath path, int children, pointer user_data); + public callback int TreeIterCompareFunc (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b, pointer user_data); + public callback void TreeModelFilterModifyFunc (Gtk.TreeModel model, Gtk.TreeIter iter, GLib.Value value, int column, pointer data); + public callback bool TreeModelFilterVisibleFunc (Gtk.TreeModel model, Gtk.TreeIter iter, pointer data); + public callback bool TreeModelForeachFunc (Gtk.TreeModel model, Gtk.TreePath path, Gtk.TreeIter iter, pointer data); + public callback void TreeSelectionForeachFunc (Gtk.TreeModel model, Gtk.TreePath path, Gtk.TreeIter iter, pointer data); + public callback bool TreeSelectionFunc (Gtk.TreeSelection selection, Gtk.TreeModel model, Gtk.TreePath path, bool path_currently_selected, pointer data); + public callback bool TreeViewColumnDropFunc (Gtk.TreeView tree_view, Gtk.TreeViewColumn column, Gtk.TreeViewColumn prev_column, Gtk.TreeViewColumn next_column, pointer data); + public callback void TreeViewMappingFunc (Gtk.TreeView tree_view, Gtk.TreePath path, pointer user_data); + public callback bool TreeViewRowSeparatorFunc (Gtk.TreeModel model, Gtk.TreeIter iter, pointer data); + public callback bool TreeViewSearchEqualFunc (Gtk.TreeModel model, int column, string key, Gtk.TreeIter iter, pointer search_data); + public callback void TreeViewSearchPositionFunc (Gtk.TreeView tree_view, Gtk.Widget search_dialog, pointer user_data); + public callback void WindowKeysForeachFunc (Gtk.Window window, uint keyval, Gdk.ModifierType modifiers, bool is_mnemonic, pointer data); + public const string STOCK_ABOUT; + public const string STOCK_ADD; + public const string STOCK_APPLY; + public const string STOCK_BOLD; + public const string STOCK_CANCEL; + public const string STOCK_CDROM; + public const string STOCK_CLEAR; + public const string STOCK_CLOSE; + public const string STOCK_COLOR_PICKER; + public const string STOCK_CONNECT; + public const string STOCK_CONVERT; + public const string STOCK_COPY; + public const string STOCK_CUT; + public const string STOCK_DELETE; + public const string STOCK_DIALOG_ERROR; + public const string STOCK_DIALOG_INFO; + public const string STOCK_DIALOG_QUESTION; + public const string STOCK_DIALOG_WARNING; + public const string STOCK_DIRECTORY; + public const string STOCK_DISCONNECT; + public const string STOCK_DND; + public const string STOCK_DND_MULTIPLE; + public const string STOCK_EDIT; + public const string STOCK_EXECUTE; + public const string STOCK_FILE; + public const string STOCK_FIND; + public const string STOCK_FIND_AND_REPLACE; + public const string STOCK_FLOPPY; + public const string STOCK_FULLSCREEN; + public const string STOCK_GOTO_BOTTOM; + public const string STOCK_GOTO_FIRST; + public const string STOCK_GOTO_LAST; + public const string STOCK_GOTO_TOP; + public const string STOCK_GO_BACK; + public const string STOCK_GO_DOWN; + public const string STOCK_GO_FORWARD; + public const string STOCK_GO_UP; + public const string STOCK_HARDDISK; + public const string STOCK_HELP; + public const string STOCK_HOME; + public const string STOCK_INDENT; + public const string STOCK_INDEX; + public const string STOCK_INFO; + public const string STOCK_ITALIC; + public const string STOCK_JUMP_TO; + public const string STOCK_JUSTIFY_CENTER; + public const string STOCK_JUSTIFY_FILL; + public const string STOCK_JUSTIFY_LEFT; + public const string STOCK_JUSTIFY_RIGHT; + public const string STOCK_LEAVE_FULLSCREEN; + public const string STOCK_MEDIA_FORWARD; + public const string STOCK_MEDIA_NEXT; + public const string STOCK_MEDIA_PAUSE; + public const string STOCK_MEDIA_PLAY; + public const string STOCK_MEDIA_PREVIOUS; + public const string STOCK_MEDIA_RECORD; + public const string STOCK_MEDIA_REWIND; + public const string STOCK_MEDIA_STOP; + public const string STOCK_MISSING_IMAGE; + public const string STOCK_NETWORK; + public const string STOCK_NEW; + public const string STOCK_NO; + public const string STOCK_OK; + public const string STOCK_OPEN; + public const string STOCK_ORIENTATION_LANDSCAPE; + public const string STOCK_ORIENTATION_PORTRAIT; + public const string STOCK_ORIENTATION_REVERSE_LANDSCAPE; + public const string STOCK_ORIENTATION_REVERSE_PORTRAIT; + public const string STOCK_PASTE; + public const string STOCK_PREFERENCES; + public const string STOCK_PRINT; + public const string STOCK_PRINT_PREVIEW; + public const string STOCK_PROPERTIES; + public const string STOCK_QUIT; + public const string STOCK_REDO; + public const string STOCK_REFRESH; + public const string STOCK_REMOVE; + public const string STOCK_REVERT_TO_SAVED; + public const string STOCK_SAVE; + public const string STOCK_SAVE_AS; + public const string STOCK_SELECT_ALL; + public const string STOCK_SELECT_COLOR; + public const string STOCK_SELECT_FONT; + public const string STOCK_SORT_ASCENDING; + public const string STOCK_SORT_DESCENDING; + public const string STOCK_SPELL_CHECK; + public const string STOCK_STOP; + public const string STOCK_STRIKETHROUGH; + public const string STOCK_UNDELETE; + public const string STOCK_UNDERLINE; + public const string STOCK_UNDO; + public const string STOCK_UNINDENT; + public const string STOCK_YES; + public const string STOCK_ZOOM_100; + public const string STOCK_ZOOM_FIT; + public const string STOCK_ZOOM_IN; + public const string STOCK_ZOOM_OUT; +} +[CCode (cheader_filename = "gtk/gtk.h")] +namespace Gtk { + public static void init (ref int argc, out string[] argv); + public static void main (); + public static void main_quit (); } diff --git a/vala/vapi/pango.vala b/vala/vapi/pango.vala index 9638e2682..72e712d0b 100644 --- a/vala/vapi/pango.vala +++ b/vala/vapi/pango.vala @@ -1,30 +1,668 @@ -/* pango.vala - * - * Copyright (C) 2006 Jürg Billeter - * - * This library 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 of the License, or (at your option) any later version. - - * This library 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 this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Author: - * Jürg Billeter - */ - [CCode (cheader_filename = "pango/pango.h")] namespace Pango { + public class Context : GLib.Object { + public Pango.Direction get_base_dir (); + public Pango.FontDescription get_font_description (); + public Pango.FontMap get_font_map (); + public Pango.Language get_language (); + public Pango.Matrix get_matrix (); + public Pango.FontMetrics get_metrics (Pango.FontDescription desc, Pango.Language language); + public GLib.Type get_type (); + public void list_families (Pango.FontFamily families, int n_families); + public Pango.Font load_font (Pango.FontDescription desc); + public Pango.Fontset load_fontset (Pango.FontDescription desc, Pango.Language language); + public void set_base_dir (Pango.Direction direction); + public void set_font_description (Pango.FontDescription desc); + public void set_language (Pango.Language language); + public void set_matrix (Pango.Matrix matrix); + } + public class Font : GLib.Object { + public Pango.FontDescription describe (); + public Pango.FontDescription describe_with_absolute_size (); + public static void descriptions_free (Pango.FontDescription descs, int n_descs); + public Pango.EngineShape find_shaper (Pango.Language language, uint ch); + public Pango.Coverage get_coverage (Pango.Language language); + public Pango.FontMap get_font_map (); + public void get_glyph_extents (uint glyph, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public Pango.FontMetrics get_metrics (Pango.Language language); + public GLib.Type get_type (); + } + public class Fontset : GLib.Object { + public void @foreach (Pango.FontsetForeachFunc func, pointer data); + public Pango.Font get_font (uint wc); + public Pango.FontMetrics get_metrics (); + public GLib.Type get_type (); + } + public class FontFace : GLib.Object { + public Pango.FontDescription describe (); + public string get_face_name (); + public GLib.Type get_type (); + public void list_sizes (int sizes, int n_sizes); + } + public class FontFamily : GLib.Object { + public string get_name (); + public GLib.Type get_type (); + public bool is_monospace (); + public void list_faces (Pango.FontFace faces, int n_faces); + } + public class FontMap : GLib.Object { + public GLib.Type get_type (); + public void list_families (Pango.FontFamily families, int n_families); + public Pango.Font load_font (Pango.Context context, Pango.FontDescription desc); + public Pango.Fontset load_fontset (Pango.Context context, Pango.FontDescription desc, Pango.Language language); + } + public class Layout : GLib.Object { + public void context_changed (); + public Pango.Layout copy (); + public Pango.Alignment get_alignment (); + public Pango.AttrList get_attributes (); + public bool get_auto_dir (); + public Pango.Context get_context (); + public void get_cursor_pos (int index_, Pango.Rectangle strong_pos, Pango.Rectangle weak_pos); + public Pango.EllipsizeMode get_ellipsize (); + public void get_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public Pango.FontDescription get_font_description (); + public int get_indent (); + public Pango.LayoutIter get_iter (); + public bool get_justify (); + public Pango.LayoutLine get_line (int line); + public int get_line_count (); + public GLib.SList get_lines (); + public void get_log_attrs (Pango.LogAttr attrs, int n_attrs); + public void get_pixel_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public void get_pixel_size (int width, int height); + public bool get_single_paragraph_mode (); + public void get_size (int width, int height); + public int get_spacing (); + public Pango.TabArray get_tabs (); + public string get_text (); + public GLib.Type get_type (); + public int get_width (); + public Pango.WrapMode get_wrap (); + public void index_to_line_x (int index_, bool trailing, int line, int x_pos); + public void index_to_pos (int index_, Pango.Rectangle pos); + public void move_cursor_visually (bool strong, int old_index, int old_trailing, int direction, int new_index, int new_trailing); + public construct (Pango.Context context); + public void set_alignment (Pango.Alignment alignment); + public void set_attributes (Pango.AttrList attrs); + public void set_auto_dir (bool auto_dir); + public void set_ellipsize (Pango.EllipsizeMode ellipsize); + public void set_font_description (Pango.FontDescription desc); + public void set_indent (int indent); + public void set_justify (bool justify); + public void set_markup (string markup, int length); + public void set_markup_with_accel (string markup, int length, unichar accel_marker, unichar accel_char); + public void set_single_paragraph_mode (bool setting); + public void set_spacing (int spacing); + public void set_tabs (Pango.TabArray tabs); + public void set_text (string text, int length); + public void set_width (int width); + public void set_wrap (Pango.WrapMode wrap); + public bool xy_to_index (int x, int y, int index_, int trailing); + } + public class Renderer : GLib.Object { + public weak Pango.Matrix matrix; + public void activate (); + public void deactivate (); + public void draw_error_underline (int x, int y, int width, int height); + public void draw_glyph (Pango.Font font, uint glyph, double x, double y); + public void draw_glyphs (Pango.Font font, Pango.GlyphString glyphs, int x, int y); + public void draw_layout (Pango.Layout layout, int x, int y); + public void draw_layout_line (Pango.LayoutLine line, int x, int y); + public void draw_rectangle (Pango.RenderPart part, int x, int y, int width, int height); + public void draw_trapezoid (Pango.RenderPart part, double y1_, double x11, double x21, double y2, double x12, double x22); + public Pango.Color get_color (Pango.RenderPart part); + public Pango.Matrix get_matrix (); + public GLib.Type get_type (); + public void part_changed (Pango.RenderPart part); + public void set_color (Pango.RenderPart part, Pango.Color color); + public void set_matrix (Pango.Matrix matrix); + } + [ReferenceType ()] + public struct Analysis { + public weak Pango.EngineShape shape_engine; + public weak Pango.EngineLang lang_engine; + public weak Pango.Font font; + public weak uchar level; + public weak Pango.Language language; + public weak GLib.SList extra_attrs; + } + [ReferenceType ()] + public struct AttrClass { + public weak Pango.AttrType type; + } + [ReferenceType ()] + public struct AttrColor { + public weak Pango.Attribute attr; + public weak Pango.Color color; + } + [ReferenceType ()] + public struct AttrFloat { + public weak Pango.Attribute attr; + public weak double value; + } + [ReferenceType ()] + public struct AttrFontDesc { + public weak Pango.Attribute attr; + public weak Pango.FontDescription desc; + public construct (Pango.FontDescription desc); + } + [ReferenceType ()] + public struct AttrInt { + public weak Pango.Attribute attr; + public weak int value; + } + [ReferenceType ()] + public struct AttrIterator { + public Pango.AttrIterator copy (); + public void destroy (); + public Pango.Attribute @get (Pango.AttrType type); + public GLib.SList get_attrs (); + public void get_font (Pango.FontDescription desc, Pango.Language language, GLib.SList extra_attrs); + public bool next (); + public void range (int start, int end); + } + [ReferenceType ()] + public struct AttrLanguage { + public weak Pango.Attribute attr; + public weak Pango.Language value; + public construct (Pango.Language language); + } + public struct AttrList { + public void change (Pango.Attribute attr); + public Pango.AttrList copy (); + public Pango.AttrList filter (Pango.AttrFilterFunc func, pointer data); + public Pango.AttrIterator get_iterator (); + public GLib.Type get_type (); + public void insert (Pango.Attribute attr); + public void insert_before (Pango.Attribute attr); + public construct (); + public Pango.AttrList @ref (); + public void splice (Pango.AttrList other, int pos, int len); + public void unref (); + } + [ReferenceType ()] + public struct AttrShape { + public weak Pango.Attribute attr; + public weak Pango.Rectangle ink_rect; + public weak Pango.Rectangle logical_rect; + public weak pointer data; + public weak Pango.AttrDataCopyFunc copy_func; + public weak GLib.DestroyNotify destroy_func; + public construct (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public construct with_data (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect, pointer data, Pango.AttrDataCopyFunc copy_func, GLib.DestroyNotify destroy_func); + } + [ReferenceType ()] + public struct AttrSize { + public weak Pango.Attribute attr; + public weak int size; + public weak uint absolute; + public construct (int size); + } + [ReferenceType ()] + public struct AttrString { + public weak Pango.Attribute attr; + public weak string value; + } + [ReferenceType ()] + public struct Attribute { + public weak pointer klass; + public weak uint start_index; + public weak uint end_index; + public Pango.Attribute copy (); + public void destroy (); + public bool equal (Pango.Attribute attr2); + } + public struct Color { + public Pango.Color copy (); + public void free (); + public GLib.Type get_type (); + public bool parse (string spec); + } + [ReferenceType ()] + public struct Coverage { + public Pango.Coverage copy (); + public static Pango.Coverage from_bytes (uchar bytes, int n_bytes); + public Pango.CoverageLevel @get (int index_); + public void max (Pango.Coverage other); + public construct (); + public Pango.Coverage @ref (); + public void @set (int index_, Pango.CoverageLevel level); + public void to_bytes (uchar bytes, int n_bytes); + public void unref (); + } + [ReferenceType ()] + public struct EngineLang { + } + [ReferenceType ()] + public struct EngineShape { + } + public struct FontDescription { + public bool better_match (Pango.FontDescription old_match, Pango.FontDescription new_match); + public Pango.FontDescription copy (); + public Pango.FontDescription copy_static (); + public bool equal (Pango.FontDescription desc2); + public void free (); + public static Pango.FontDescription from_string (string str); + public string get_family (); + public Pango.FontMask get_set_fields (); + public int get_size (); + public bool get_size_is_absolute (); + public Pango.Stretch get_stretch (); + public Pango.Style get_style (); + public GLib.Type get_type (); + public Pango.Variant get_variant (); + public Pango.Weight get_weight (); + public uint hash (); + public void merge (Pango.FontDescription desc_to_merge, bool replace_existing); + public void merge_static (Pango.FontDescription desc_to_merge, bool replace_existing); + public construct (); + public void set_absolute_size (double size); + public void set_family (string family); + public void set_family_static (string family); + public void set_size (int size); + public void set_stretch (Pango.Stretch stretch); + public void set_style (Pango.Style style); + public void set_variant (Pango.Variant variant); + public void set_weight (Pango.Weight weight); + public string to_filename (); + public string to_string (); + public void unset_fields (Pango.FontMask to_unset); + } + public struct FontMetrics { + public int get_approximate_char_width (); + public int get_approximate_digit_width (); + public int get_ascent (); + public int get_descent (); + public int get_strikethrough_position (); + public int get_strikethrough_thickness (); + public GLib.Type get_type (); + public int get_underline_position (); + public int get_underline_thickness (); + public Pango.FontMetrics @ref (); + public void unref (); + } + [ReferenceType ()] + public struct GlyphGeometry { + public weak int width; + public weak int x_offset; + public weak int y_offset; + } + [ReferenceType ()] + public struct GlyphInfo { + public weak uint glyph; + public weak Pango.GlyphGeometry geometry; + public weak Pango.GlyphVisAttr attr; + } + [ReferenceType ()] + public struct GlyphItem { + public weak Pango.Item item; + public weak Pango.GlyphString glyphs; + public GLib.SList apply_attrs (string text, Pango.AttrList list); + public void free (); + public void letter_space (string text, Pango.LogAttr log_attrs, int letter_spacing); + public Pango.GlyphItem split (string text, int split_index); + } + public struct GlyphString { + public Pango.GlyphString copy (); + public void extents (Pango.Font font, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public void extents_range (int start, int end, Pango.Font font, Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public void free (); + public void get_logical_widths (string text, int length, int embedding_level, int logical_widths); + public GLib.Type get_type (); + public int get_width (); + public void index_to_x (string text, int length, Pango.Analysis analysis, int index_, bool trailing, int x_pos); + public construct (); + public void set_size (int new_len); + public void x_to_index (string text, int length, Pango.Analysis analysis, int x_pos, int index_, int trailing); + } + [ReferenceType ()] + public struct GlyphVisAttr { + public weak uint is_cluster_start; + } + public struct Item { + public Pango.Item copy (); + public void free (); + public GLib.Type get_type (); + public construct (); + public Pango.Item split (int split_index, int split_offset); + } + public struct Language { + public static Pango.Language from_string (string language); + public string get_sample_string (); + public GLib.Type get_type (); + public bool includes_script (Pango.Script script); + public bool matches (string range_list); + } + public struct LayoutIter { + public bool at_last_line (); + public void free (); + public int get_baseline (); + public void get_char_extents (Pango.Rectangle logical_rect); + public void get_cluster_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public int get_index (); + public void get_layout_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public Pango.LayoutLine get_line (); + public void get_line_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public void get_line_yrange (int y0_, int y1_); + public Pango.LayoutRun get_run (); + public void get_run_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public GLib.Type get_type (); + public bool next_char (); + public bool next_cluster (); + public bool next_line (); + public bool next_run (); + } + public struct LayoutLine { + public void get_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public void get_pixel_extents (Pango.Rectangle ink_rect, Pango.Rectangle logical_rect); + public GLib.Type get_type (); + public void get_x_ranges (int start_index, int end_index, int ranges, int n_ranges); + public void index_to_x (int index_, bool trailing, int x_pos); + public Pango.LayoutLine @ref (); + public void unref (); + public bool x_to_index (int x_pos, int index_, int trailing); + } + [ReferenceType ()] + public struct LayoutRun { + public weak Pango.Item item; + public weak Pango.GlyphString glyphs; + } + [ReferenceType ()] + public struct LogAttr { + public weak uint is_line_break; + public weak uint is_mandatory_break; + public weak uint is_char_break; + public weak uint is_white; + public weak uint is_cursor_position; + public weak uint is_word_start; + public weak uint is_word_end; + public weak uint is_sentence_boundary; + public weak uint is_sentence_start; + public weak uint is_sentence_end; + public weak uint backspace_deletes_character; + } + public struct Matrix { + public void concat (Pango.Matrix new_matrix); + public Pango.Matrix copy (); + public void free (); + public double get_font_scale_factor (); + public GLib.Type get_type (); + public void rotate (double degrees); + public void scale (double scale_x, double scale_y); + public void translate (double tx, double ty); + } + [ReferenceType ()] + public struct Rectangle { + public weak int x; + public weak int y; + public weak int width; + public weak int height; + } + [ReferenceType ()] + public struct ScriptIter { + public void free (); + public void get_range (string start, string end, Pango.Script script); + public construct (string text, int length); + public bool next (); + } + public struct TabArray { + public Pango.TabArray copy (); + public void free (); + public bool get_positions_in_pixels (); + public int get_size (); + public void get_tab (int tab_index, Pango.TabAlign alignment, int location); + public void get_tabs (Pango.TabAlign alignments, int locations); + public GLib.Type get_type (); + public construct (int initial_size, bool positions_in_pixels); + public construct with_positions (int size, bool positions_in_pixels, Pango.TabAlign first_alignment, int first_position); + public void resize (int new_size); + public void set_tab (int tab_index, Pango.TabAlign alignment, int location); + } + [ReferenceType ()] + public struct Win32FontCache { + public void free (); + public pointer load (pointer logfont); + public construct (); + public void unload (pointer hfont); + } + [ReferenceType ()] + public struct Attr { + public static Pango.Attribute background_new (ushort red, ushort green, ushort blue); + public static Pango.Attribute fallback_new (bool enable_fallback); + public static Pango.Attribute family_new (string family); + public static Pango.Attribute foreground_new (ushort red, ushort green, ushort blue); + public static Pango.Attribute letter_spacing_new (int letter_spacing); + public static Pango.Attribute rise_new (int rise); + public static Pango.Attribute scale_new (double scale_factor); + public static Pango.Attribute stretch_new (Pango.Stretch stretch); + public static Pango.Attribute strikethrough_color_new (ushort red, ushort green, ushort blue); + public static Pango.Attribute strikethrough_new (bool strikethrough); + public static Pango.Attribute style_new (Pango.Style style); + public static Pango.AttrType type_register (string name); + public static Pango.Attribute underline_color_new (ushort red, ushort green, ushort blue); + public static Pango.Attribute underline_new (Pango.Underline underline); + public static Pango.Attribute variant_new (Pango.Variant variant); + public static Pango.Attribute weight_new (Pango.Weight weight); + } + [ReferenceType ()] + public struct Global { + public static Pango.Direction _find_base_dir (string text, int length); + public static void _find_paragraph_boundary (string text, int length, int paragraph_delimiter_index, int next_paragraph_start); + public static void _get_log_attrs (string text, int length, int level, Pango.Language language, Pango.LogAttr log_attrs, int attrs_len); + public static bool _is_zero_width (unichar ch); + public static GLib.List _itemize_with_base_dir (Pango.Context context, Pango.Direction base_dir, string text, int start_index, int length, Pango.AttrList attrs, Pango.AttrIterator cached_iter); + public static bool _parse_markup (string markup_text, int length, unichar accel_marker, Pango.AttrList attr_list, string text, unichar accel_char, GLib.Error error); + public static bool _parse_stretch (string str, Pango.Stretch stretch, bool warn); + public static bool _parse_style (string str, Pango.Style style, bool warn); + public static bool _parse_variant (string str, Pango.Variant variant, bool warn); + public static bool _parse_weight (string str, Pango.Weight weight, bool warn); + public static void _quantize_line_geometry (int thickness, int position); + public static int _read_line (GLib.File stream, GLib.String str); + public static GLib.List _reorder_items (GLib.List logical_items); + public static bool _scan_int (string pos, int @out); + public static bool _scan_string (string pos, GLib.String @out); + public static bool _scan_word (string pos, GLib.String @out); + public static Pango.Script _script_for_unichar (unichar ch); + public static Pango.Language _script_get_sample_language (Pango.Script script); + public static bool _skip_space (string pos); + public static string _split_file_list (string str); + public static string _trim_string (string str); + public static Pango.Direction _unichar_direction (unichar ch); + } + [CCode (cprefix = "PANGO_ALIGN_")] + public enum Alignment { + LEFT, + CENTER, + RIGHT, + } + [CCode (cprefix = "PANGO_ATTR_")] + public enum AttrType { + INVALID, + LANGUAGE, + FAMILY, + STYLE, + WEIGHT, + VARIANT, + STRETCH, + SIZE, + FONT_DESC, + FOREGROUND, + BACKGROUND, + UNDERLINE, + STRIKETHROUGH, + RISE, + SHAPE, + SCALE, + FALLBACK, + LETTER_SPACING, + UNDERLINE_COLOR, + STRIKETHROUGH_COLOR, + ABSOLUTE_SIZE, + } + [CCode (cprefix = "PANGO_COVERAGE_")] + public enum CoverageLevel { + NONE, + FALLBACK, + APPROXIMATE, + EXACT, + } + [CCode (cprefix = "PANGO_DIRECTION_")] + public enum Direction { + LTR, + RTL, + TTB_LTR, + TTB_RTL, + WEAK_LTR, + WEAK_RTL, + NEUTRAL, + } + [CCode (cprefix = "PANGO_ELLIPSIZE_")] + public enum EllipsizeMode { + NONE, + START, + MIDDLE, + END, + } + [CCode (cprefix = "PANGO_FONT_MASK_")] + public enum FontMask { + FAMILY, + STYLE, + VARIANT, + WEIGHT, + STRETCH, + SIZE, + } + [CCode (cprefix = "PANGO_RENDER_PART_")] + public enum RenderPart { + FOREGROUND, + BACKGROUND, + UNDERLINE, + STRIKETHROUGH, + } + [CCode (cprefix = "PANGO_SCRIPT_")] + public enum Script { + INVALID_CODE, + COMMON, + INHERITED, + ARABIC, + ARMENIAN, + BENGALI, + BOPOMOFO, + CHEROKEE, + COPTIC, + CYRILLIC, + DESERET, + DEVANAGARI, + ETHIOPIC, + GEORGIAN, + GOTHIC, + GREEK, + GUJARATI, + GURMUKHI, + HAN, + HANGUL, + HEBREW, + HIRAGANA, + KANNADA, + KATAKANA, + KHMER, + LAO, + LATIN, + MALAYALAM, + MONGOLIAN, + MYANMAR, + OGHAM, + OLD_ITALIC, + ORIYA, + RUNIC, + SINHALA, + SYRIAC, + TAMIL, + TELUGU, + THAANA, + THAI, + TIBETAN, + CANADIAN_ABORIGINAL, + YI, + TAGALOG, + HANUNOO, + BUHID, + TAGBANWA, + BRAILLE, + CYPRIOT, + LIMBU, + OSMANYA, + SHAVIAN, + LINEAR_B, + TAI_LE, + UGARITIC, + NEW_TAI_LUE, + BUGINESE, + GLAGOLITIC, + TIFINAGH, + SYLOTI_NAGRI, + OLD_PERSIAN, + KHAROSHTHI, + UNKNOWN, + BALINESE, + CUNEIFORM, + PHOENICIAN, + PHAGS_PA, + NKO, + } + [CCode (cprefix = "PANGO_STRETCH_")] + public enum Stretch { + ULTRA_CONDENSED, + EXTRA_CONDENSED, + CONDENSED, + SEMI_CONDENSED, + NORMAL, + SEMI_EXPANDED, + EXPANDED, + EXTRA_EXPANDED, + ULTRA_EXPANDED, + } + [CCode (cprefix = "PANGO_STYLE_")] public enum Style { NORMAL, OBLIQUE, - ITALIC + ITALIC, + } + [CCode (cprefix = "PANGO_TAB_")] + public enum TabAlign { + LEFT, + } + [CCode (cprefix = "PANGO_UNDERLINE_")] + public enum Underline { + NONE, + SINGLE, + DOUBLE, + LOW, + ERROR, + } + [CCode (cprefix = "PANGO_VARIANT_")] + public enum Variant { + NORMAL, + SMALL_CAPS, + } + [CCode (cprefix = "PANGO_WEIGHT_")] + public enum Weight { + ULTRALIGHT, + LIGHT, + NORMAL, + SEMIBOLD, + BOLD, + ULTRABOLD, + HEAVY, + } + [CCode (cprefix = "PANGO_WRAP_")] + public enum WrapMode { + WORD, + CHAR, + WORD_CHAR, } + public callback pointer AttrDataCopyFunc (pointer data); + public callback bool AttrFilterFunc (Pango.Attribute attribute, pointer data); + public callback bool FontsetForeachFunc (Pango.Fontset fontset, Pango.Font font, pointer data); }