]> git.ipfire.org Git - thirdparty/vala.git/commitdiff
hildon-1: update to Fremantle bindings
authorPhilipp Zabel <philipp.zabel@gmail.com>
Tue, 6 Oct 2009 10:05:19 +0000 (12:05 +0200)
committerEvan Nemerson <evan@coeus-group.com>
Sat, 7 Nov 2009 19:45:50 +0000 (11:45 -0800)
Partially fixes bug 598656.

vapi/hildon-1.vapi
vapi/packages/hildon-1/hildon-1.gi
vapi/packages/hildon-1/hildon-1.metadata

index 09256d69ea9f1047127af33915e85726805ef348..c3de38c1e00a973b32c4e673480943622addabef 100644 (file)
@@ -2,6 +2,38 @@
 
 [CCode (cprefix = "Hildon", lower_case_cprefix = "hildon_")]
 namespace Hildon {
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class AnimationActor : Gtk.Window, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public AnimationActor ();
+               public void send_message (uint32 message_type, uint32 l0, uint32 l1, uint32 l2, uint32 l3, uint32 l4);
+               public void set_anchor (int x, int y);
+               public void set_anchor_from_gravity (uint gravity);
+               public void set_depth (int depth);
+               public void set_opacity (int opacity);
+               public void set_parent (Gtk.Window parent);
+               public void set_position (int x, int y);
+               public void set_position_full (int x, int y, int depth);
+               public void set_rotation (int axis, double degrees, int x, int y, int z);
+               public void set_rotationx (int axis, int32 degrees, int x, int y, int z);
+               public void set_scale (double x_scale, double y_scale);
+               public void set_scalex (int32 x_scale, int32 y_scale);
+               public void set_show (int show);
+               public void set_show_full (int show, int opacity);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class AppMenu : Gtk.Window, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public AppMenu ();
+               public void add_filter (Gtk.Button filter);
+               public void append (Gtk.Button item);
+               public unowned GLib.List get_filters ();
+               public unowned GLib.List get_items ();
+               public void insert (Gtk.Button item, int position);
+               public void popup (Gtk.Window parent_window);
+               public void prepend (Gtk.Button item);
+               public void reorder_child (Gtk.Button item, int position);
+       }
        [CCode (cheader_filename = "hildon/hildon.h")]
        public class Banner : Gtk.Window, Atk.Implementor, Gtk.Buildable {
                public void set_fraction (double fraction);
@@ -11,8 +43,9 @@ namespace Hildon {
                public void set_text (string text);
                public void set_timeout (uint timeout);
                public static unowned Gtk.Widget show_animation (Gtk.Widget widget, string animation_name, string text);
-               public static unowned Gtk.Widget show_information (Gtk.Widget widget, string icon_name, string text);
-               public static unowned Gtk.Widget show_information_with_markup (Gtk.Widget widget, string icon_name, string markup);
+               public static unowned Gtk.Widget show_information (Gtk.Widget widget, string? icon_name, string text);
+               public static unowned Gtk.Widget show_information_override_dnd (Gtk.Widget widget, string text);
+               public static unowned Gtk.Widget show_information_with_markup (Gtk.Widget widget, string? icon_name, string markup);
                public static unowned Gtk.Widget show_informationf (Gtk.Widget widget, string icon_name, string format);
                public static unowned Gtk.Widget show_progress (Gtk.Widget widget, Gtk.ProgressBar bar, string text);
                [NoAccessorMethod]
@@ -28,13 +61,43 @@ namespace Hildon {
                public BreadCrumbTrail ();
                public void clear ();
                public void pop ();
-               public void push (Hildon.BreadCrumb item, void* id, GLib.DestroyNotify notify);
+               public void push (Hildon.BreadCrumb item, void* id, GLib.DestroyNotify destroy);
                public void push_icon (string text, Gtk.Widget icon, void* id, GLib.DestroyNotify destroy);
-               public void push_text (string text, void* id, GLib.DestroyNotify notify);
+               public void push_text (string text, void* id, GLib.DestroyNotify destroy);
                public virtual signal bool crumb_clicked (void* id);
                public virtual signal void move_parent ();
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class Button : Gtk.Button, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public Button (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
+               public void add_image_size_group (Gtk.SizeGroup size_group);
+               public void add_size_groups (Gtk.SizeGroup title_size_group, Gtk.SizeGroup value_size_group, Gtk.SizeGroup image_size_group);
+               public void add_title_size_group (Gtk.SizeGroup size_group);
+               public void add_value_size_group (Gtk.SizeGroup size_group);
+               public unowned Gtk.Widget get_image ();
+               public Hildon.ButtonStyle get_style ();
+               public unowned string get_title ();
+               public unowned string get_value ();
+               public void set_alignment (float xalign, float yalign, float xscale, float yscale);
+               public void set_image (Gtk.Widget image);
+               public void set_image_alignment (float xalign, float yalign);
+               public void set_image_position (Gtk.PositionType position);
+               public void set_style (Hildon.ButtonStyle style);
+               public void set_text (string title, string value);
+               public void set_title (string title);
+               public void set_title_alignment (float xalign, float yalign);
+               public void set_value (string value);
+               public void set_value_alignment (float xalign, float yalign);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public Button.with_text (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, string title, string value);
+               public Hildon.ButtonArrangement arrangement { construct; }
+               public Hildon.SizeType size { construct; }
+               public Hildon.ButtonStyle style { get; set; }
+               public string title { get; set; }
+               public string value { get; set; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class Calendar : Gtk.Widget, Atk.Implementor, Gtk.Buildable {
                [CCode (array_length = false)]
                public weak int[] day_month;
@@ -148,6 +211,16 @@ namespace Hildon {
                public virtual signal void activate ();
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class CheckButton : Gtk.Button, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public CheckButton (Hildon.SizeType size);
+               public bool get_active ();
+               public void set_active (bool is_active);
+               [NoAccessorMethod]
+               public Hildon.SizeType size { set; }
+               public virtual signal void toggled ();
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class CodeDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public CodeDialog ();
@@ -169,6 +242,7 @@ namespace Hildon {
                public ColorButton.with_color (Gdk.Color color);
                public Gdk.Color color { get; set; }
                public bool popup_shown { get; }
+               public virtual signal void setup_dialog (Hildon.ColorChooserDialog p0);
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
        public class ColorChooser : Gtk.Widget, Atk.Implementor, Gtk.Buildable {
@@ -203,6 +277,15 @@ namespace Hildon {
                public virtual signal void end_reached (bool end);
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class DateButton : Hildon.PickerButton, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public DateButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
+               public void get_date (uint year, uint month, uint day);
+               public void set_date (uint year, uint month, uint day);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public DateButton.with_year_range (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, int min_year, int max_year);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class DateEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public DateEditor ();
@@ -224,7 +307,52 @@ namespace Hildon {
                public virtual signal bool date_error (Hildon.DateTimeError type);
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
-       public class FindToolbar : Gtk.Toolbar, Atk.Implementor, Gtk.Buildable {
+       public class DateSelector : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public DateSelector ();
+               public void get_date (uint year, uint month, uint day);
+               public bool select_current_date (uint year, uint month, uint day);
+               public void select_day (uint day);
+               public bool select_month (uint month, uint year);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public DateSelector.with_year_range (int min_year, int max_year);
+               [NoAccessorMethod]
+               public int max_year { get; construct; }
+               [NoAccessorMethod]
+               public int min_year { get; construct; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class Dialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public Dialog ();
+               public unowned Gtk.Widget add_button (string button_text, int response_id);
+               public void add_buttons (...);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public Dialog.with_buttons (string title, Gtk.Window parent, Gtk.DialogFlags flags, ...);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class EditToolbar : Gtk.HBox, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public EditToolbar ();
+               public void set_button_label (string label);
+               public void set_label (string label);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public EditToolbar.with_text (string label, string button);
+               public virtual signal void arrow_clicked ();
+               public virtual signal void button_clicked ();
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class Entry : Gtk.Entry, Atk.Implementor, Gtk.Buildable, Gtk.Editable, Gtk.CellEditable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public Entry (Hildon.SizeType size);
+               public unowned string get_text ();
+               public void set_placeholder (string text);
+               public void set_text (string text);
+               [NoAccessorMethod]
+               public Hildon.SizeType size { set construct; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class FindToolbar : Gtk.Toolbar, Atk.Implementor, Gtk.Buildable, Gtk.ToolShell {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public FindToolbar (string label);
                public int get_active ();
@@ -374,15 +502,115 @@ namespace Hildon {
                public virtual signal bool range_error (Hildon.NumberEditorErrorType type);
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class PannableArea : Gtk.Bin, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public PannableArea ();
+               public void add_with_viewport (Gtk.Widget child);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public PannableArea.full (int mode, bool enabled, double vel_min, double vel_max, double decel, uint sps);
+               public unowned Gtk.Adjustment get_hadjustment ();
+               public Hildon.SizeRequestPolicy get_size_request_policy ();
+               public unowned Gtk.Adjustment get_vadjustment ();
+               public void jump_to (int x, int y);
+               public void jump_to_child (Gtk.Widget child);
+               public void scroll_to (int x, int y);
+               public void scroll_to_child (Gtk.Widget child);
+               public void set_size_request_policy (Hildon.SizeRequestPolicy size_request_policy);
+               [NoAccessorMethod]
+               public uint bounce_steps { get; set construct; }
+               [NoAccessorMethod]
+               public double deceleration { get; set construct; }
+               [NoAccessorMethod]
+               public uint direction_error_margin { get; set construct; }
+               [NoAccessorMethod]
+               public double drag_inertia { get; set construct; }
+               [NoAccessorMethod]
+               public bool enabled { get; set construct; }
+               [NoAccessorMethod]
+               public uint force { get; set construct; }
+               public Gtk.Adjustment hadjustment { get; }
+               [NoAccessorMethod]
+               public int hovershoot_max { get; set construct; }
+               [NoAccessorMethod]
+               public Gtk.PolicyType hscrollbar_policy { get; set construct; }
+               [NoAccessorMethod]
+               public bool initial_hint { get; set construct; }
+               [NoAccessorMethod]
+               public bool low_friction_mode { get; set construct; }
+               [NoAccessorMethod]
+               public Hildon.PannableAreaMode mode { get; set construct; }
+               [NoAccessorMethod]
+               public Hildon.MovementMode mov_mode { get; set construct; }
+               [NoAccessorMethod]
+               public uint panning_threshold { get; set construct; }
+               [NoAccessorMethod]
+               public double scroll_time { get; set construct; }
+               [NoAccessorMethod]
+               public uint scrollbar_fade_delay { get; set construct; }
+               public Hildon.SizeRequestPolicy size_request_policy { get; set construct; }
+               [NoAccessorMethod]
+               public uint sps { get; set construct; }
+               public Gtk.Adjustment vadjustment { get; }
+               [NoAccessorMethod]
+               public double velocity_fast_factor { get; set construct; }
+               [NoAccessorMethod]
+               public double velocity_max { get; set construct; }
+               [NoAccessorMethod]
+               public double velocity_min { get; set construct; }
+               [NoAccessorMethod]
+               public double velocity_overshooting_max { get; set construct; }
+               [NoAccessorMethod]
+               public int vovershoot_max { get; set construct; }
+               [NoAccessorMethod]
+               public Gtk.PolicyType vscrollbar_policy { get; set construct; }
+               public virtual signal void horizontal_movement (int direction, double x, double y);
+               public virtual signal void panning_finished ();
+               public virtual signal bool panning_started ();
+               public virtual signal void vertical_movement (int direction, double x, double y);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class PickerButton : Hildon.Button, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public PickerButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
+               public int get_active ();
+               public unowned string get_done_button_text ();
+               public unowned Hildon.TouchSelector get_selector ();
+               public void set_active (int index);
+               public void set_done_button_text (string done_button_text);
+               public void set_selector (Hildon.TouchSelector selector);
+               public string done_button_text { get; set; }
+               [NoAccessorMethod]
+               public Hildon.TouchSelector touch_selector { owned get; set; }
+               public virtual signal void value_changed ();
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class PickerDialog : Hildon.Dialog, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public PickerDialog (Gtk.Window parent);
+               public unowned string get_done_label ();
+               public unowned Hildon.TouchSelector get_selector ();
+               public void set_done_label (string label);
+               public virtual bool set_selector (Hildon.TouchSelector selector);
+               [NoAccessorMethod]
+               public bool center_on_show { get; set construct; }
+               [NoAccessorMethod]
+               public string done_button_text { owned get; set construct; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class Program : GLib.Object {
                public void add_window (Hildon.Window window);
                public bool get_can_hibernate ();
+               public unowned Hildon.AppMenu get_common_app_menu ();
                public unowned Gtk.Menu get_common_menu ();
                public unowned Gtk.Toolbar get_common_toolbar ();
                public static unowned Hildon.Program get_instance ();
                public bool get_is_topmost ();
+               public void go_to_root_window ();
+               public unowned Hildon.StackableWindow peek_window_stack ();
+               public unowned Hildon.StackableWindow pop_window_stack ();
                public void remove_window (Hildon.Window window);
                public void set_can_hibernate (bool can_hibernate);
+               public void set_common_app_menu (Hildon.AppMenu menu);
                public void set_common_menu (Gtk.Menu menu);
                public void set_common_toolbar (Gtk.Toolbar toolbar);
                public bool can_hibernate { get; set; }
@@ -414,6 +642,21 @@ namespace Hildon {
                public string separator { get; set construct; }
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class RemoteTexture : Gtk.Window, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public RemoteTexture ();
+               public void send_message (uint32 message_type, uint32 l0, uint32 l1, uint32 l2, uint32 l3, uint32 l4);
+               public void set_image (uint32 key, uint width, uint height, uint bpp);
+               public void set_offset (double x, double y);
+               public void set_opacity (int opacity);
+               public void set_parent (Gtk.Window parent);
+               public void set_position (int x, int y, int width, int height);
+               public void set_scale (double x_scale, double y_scale);
+               public void set_show (int show);
+               public void set_show_full (int show, int opacity);
+               public void update_area (int x, int y, int width, int height);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class Seekbar : Gtk.Scale, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public Seekbar ();
@@ -457,6 +700,30 @@ namespace Hildon {
                public Gtk.SortType sort_order { get; set; }
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class StackableWindow : Hildon.Window, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public StackableWindow ();
+               public unowned Hildon.WindowStack get_stack ();
+               public void set_main_menu (Hildon.AppMenu menu);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TextView : Gtk.TextView, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TextView ();
+               public unowned Gtk.TextBuffer get_buffer ();
+               public void set_buffer (Gtk.TextBuffer buffer);
+               public void set_placeholder (string text);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TimeButton : Hildon.PickerButton, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TimeButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
+               public void get_time (uint hours, uint minutes);
+               public void set_time (uint hours, uint minutes);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TimeButton.step (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, uint minutes_step);
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class TimeEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public TimeEditor ();
@@ -495,6 +762,81 @@ namespace Hildon {
                public uint minutes { get; set; }
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TimeSelector : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TimeSelector ();
+               public void get_time (uint hours, uint minutes);
+               public bool set_time (uint hours, uint minutes);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TimeSelector.step (uint minutes_step);
+               [NoAccessorMethod]
+               public uint minutes_step { get; construct; }
+               [NoAccessorMethod]
+               public Hildon.TimeSelectorFormatPolicy time_format_policy { get; set construct; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TouchSelector : Gtk.VBox, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TouchSelector ();
+               public unowned Hildon.TouchSelectorColumn append_column (Gtk.TreeModel model, Gtk.CellRenderer cell_renderer);
+               public void append_text (string text);
+               public unowned Hildon.TouchSelectorColumn append_text_column (Gtk.TreeModel model, bool center);
+               public void center_on_selected ();
+               public int get_active (int column);
+               public unowned Hildon.TouchSelectorColumn get_column (int column);
+               public Hildon.TouchSelectorSelectionMode get_column_selection_mode ();
+               public unowned string get_current_text ();
+               public Hildon.UIMode get_hildon_ui_mode ();
+               public unowned Gtk.TreePath get_last_activated_row (int column);
+               public unowned Gtk.TreeModel get_model (int column);
+               public int get_num_columns ();
+               public unowned Hildon.TouchSelectorPrintFunc get_print_func ();
+               public bool get_selected (int column, Gtk.TreeIter iter);
+               public unowned GLib.List get_selected_rows (int column);
+               public void insert_text (int position, string text);
+               public void optimal_size_request (Gtk.Requisition requisition);
+               public void prepend_text (string text);
+               public bool remove_column (int column);
+               public void select_iter (int column, Gtk.TreeIter iter, bool scroll_to);
+               public void set_active (int column, int index);
+               public void set_column_attributes (int num_column, Gtk.CellRenderer cell_renderer);
+               public void set_column_selection_mode (Hildon.TouchSelectorSelectionMode mode);
+               public bool set_hildon_ui_mode (Hildon.UIMode mode);
+               public virtual void set_model (int column, Gtk.TreeModel model);
+               public void set_print_func (Hildon.TouchSelectorPrintFunc func);
+               public void set_print_func_full (Hildon.TouchSelectorPrintFunc func, GLib.DestroyNotify destroy_func);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TouchSelector.text ();
+               public void unselect_all (int column);
+               public void unselect_iter (int column, Gtk.TreeIter iter);
+               [NoAccessorMethod]
+               public bool has_multiple_selection { get; }
+               public Hildon.UIMode hildon_ui_mode { get; set; }
+               [NoAccessorMethod]
+               public bool initial_scroll { get; set construct; }
+               public virtual signal void changed (int column);
+               public virtual signal void columns_changed ();
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TouchSelectorColumn : GLib.Object, Gtk.CellLayout {
+               public int get_text_column ();
+               public void set_text_column (int text_column);
+               public int text_column { get; set; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public class TouchSelectorEntry : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TouchSelectorEntry ();
+               public unowned Hildon.Entry get_entry ();
+               public Hildon.GtkInputMode get_input_mode ();
+               public int get_text_column ();
+               public void set_input_mode (Hildon.GtkInputMode input_mode);
+               public void set_text_column (int text_column);
+               [CCode (type = "GtkWidget*", has_construct_function = false)]
+               public TouchSelectorEntry.text ();
+               public int text_column { get; set; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class VVolumebar : Hildon.Volumebar, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public VVolumebar ();
@@ -509,8 +851,6 @@ namespace Hildon {
                public void set_range_insensitive_message (string message);
                public void set_range_insensitive_messagef (string format);
                [NoAccessorMethod]
-               public bool can_focus { get; set construct; }
-               [NoAccessorMethod]
                public bool has_mute { get; set construct; }
                public double level { get; set; }
                public bool mute { get; set; }
@@ -543,17 +883,46 @@ namespace Hildon {
                public Window ();
                public void add_toolbar (Gtk.Toolbar toolbar);
                public void add_with_scrollbar (Gtk.Widget child);
+               public unowned Hildon.AppMenu get_app_menu ();
                public bool get_is_topmost ();
+               public unowned Gtk.Menu get_main_menu ();
+               public unowned string get_markup ();
                public unowned Gtk.Menu get_menu ();
                public void remove_toolbar (Gtk.Toolbar toolbar);
+               public void set_app_menu (Hildon.AppMenu menu);
+               public void set_edit_toolbar (Hildon.EditToolbar toolbar);
+               public void set_main_menu (Gtk.Menu menu);
+               public void set_markup (string markup);
                public void set_menu (Gtk.Menu menu);
+               [NoWrapper]
+               public virtual bool toggle_menu (uint button, uint32 time);
                public bool is_topmost { get; }
+               public string markup { get; set; }
                public virtual signal void clipboard_operation (int operation);
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public class WindowStack : GLib.Object {
+               [CCode (has_construct_function = false)]
+               public WindowStack ();
+               public static unowned Hildon.WindowStack get_default ();
+               public unowned GLib.List get_windows ();
+               public unowned Gtk.Widget peek ();
+               public void pop (int nwindows, GLib.List popped_windows);
+               public unowned Gtk.Widget pop_1 ();
+               public void pop_and_push (int nwindows, GLib.List popped_windows, Hildon.StackableWindow win1);
+               public void pop_and_push_list (int nwindows, GLib.List popped_windows, GLib.List list);
+               public void push (Hildon.StackableWindow win1);
+               public void push_1 (Hildon.StackableWindow win);
+               public void push_list (GLib.List list);
+               public int size ();
+               [NoAccessorMethod]
+               public Gtk.WindowGroup window_group { owned get; construct; }
+       }
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public class WizardDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
                [CCode (type = "GtkWidget*", has_construct_function = false)]
                public WizardDialog (Gtk.Window parent, string wizard_name, Gtk.Notebook notebook);
+               public void set_forward_page_func (Hildon.WizardDialogPageFunc page_func, void* data, GLib.DestroyNotify destroy);
                [NoAccessorMethod]
                public bool autotitle { get; set; }
                [NoAccessorMethod]
@@ -567,7 +936,17 @@ namespace Hildon {
                public abstract void get_natural_size (int width, int height);
                public signal void crumb_activated ();
        }
-       [CCode (cprefix = "HILDON_CALENDAR_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_BUTTON_ARRANGEMENT_", cheader_filename = "hildon/hildon.h")]
+       public enum ButtonArrangement {
+               HORIZONTAL,
+               VERTICAL
+       }
+       [CCode (cprefix = "HILDON_BUTTON_STYLE_", cheader_filename = "hildon/hildon.h")]
+       public enum ButtonStyle {
+               NORMAL,
+               PICKER
+       }
+       [CCode (cprefix = "HILDON_CALENDAR_", cheader_filename = "hildon/hildon.h")]
        [Flags]
        public enum CalendarDisplayOptions {
                SHOW_HEADING,
@@ -576,17 +955,17 @@ namespace Hildon {
                SHOW_WEEK_NUMBERS,
                WEEK_START_MONDAY
        }
-       [CCode (cprefix = "HILDON_CAPTION_POSITION_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_CAPTION_POSITION_", cheader_filename = "hildon/hildon.h")]
        public enum CaptionIconPosition {
                LEFT,
                RIGHT
        }
-       [CCode (cprefix = "HILDON_CAPTION_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_CAPTION_", cheader_filename = "hildon/hildon.h")]
        public enum CaptionStatus {
                OPTIONAL,
                MANDATORY
        }
-       [CCode (cprefix = "HILDON_DATE_TIME_ERROR_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_DATE_TIME_ERROR_", cheader_filename = "hildon/hildon.h")]
        public enum DateTimeError {
                NO_ERROR,
                MAX_HOURS,
@@ -631,7 +1010,21 @@ namespace Hildon {
                DIABLO,
                FREMANTLE
        }
-       [CCode (cprefix = "HILDON_NOTE_TYPE_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_MOVEMENT_", cheader_filename = "hildon/hildon.h")]
+       public enum MovementDirection {
+               UP,
+               DOWN,
+               LEFT,
+               RIGHT
+       }
+       [CCode (cprefix = "HILDON_MOVEMENT_MODE_", cheader_filename = "hildon/hildon.h")]
+       [Flags]
+       public enum MovementMode {
+               HORIZ,
+               VERT,
+               BOTH
+       }
+       [CCode (cprefix = "HILDON_NOTE_TYPE_", cheader_filename = "hildon/hildon.h")]
        public enum NoteType {
                CONFIRMATION,
                CONFIRMATION_BUTTON,
@@ -639,12 +1032,29 @@ namespace Hildon {
                INFORMATION_THEME,
                PROGRESSBAR
        }
-       [CCode (cprefix = "HILDON_NUMBER_EDITOR_ERROR_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_NUMBER_EDITOR_ERROR_", cheader_filename = "hildon/hildon.h")]
        public enum NumberEditorErrorType {
                MAXIMUM_VALUE_EXCEED,
                MINIMUM_VALUE_EXCEED,
                ERRONEOUS_VALUE
        }
+       [CCode (cprefix = "HILDON_PANNABLE_AREA_MODE_", cheader_filename = "hildon/hildon.h")]
+       public enum PannableAreaMode {
+               PUSH,
+               ACCEL,
+               AUTO
+       }
+       [CCode (cprefix = "HILDON_PORTRAIT_MODE_", cheader_filename = "hildon/hildon.h")]
+       [Flags]
+       public enum PortraitFlags {
+               REQUEST,
+               SUPPORT
+       }
+       [CCode (cprefix = "HILDON_SIZE_REQUEST_", cheader_filename = "hildon/hildon.h")]
+       public enum SizeRequestPolicy {
+               MINIMUM,
+               CHILDREN
+       }
        [CCode (cprefix = "HILDON_SIZE_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
        public enum SizeType {
                AUTO_WIDTH,
@@ -655,18 +1065,29 @@ namespace Hildon {
                THUMB_HEIGHT,
                AUTO
        }
+       [CCode (cprefix = "HILDON_TIME_SELECTOR_FORMAT_POLICY_", cheader_filename = "hildon/hildon.h")]
+       public enum TimeSelectorFormatPolicy {
+               AMPM,
+               @24H,
+               AUTOMATIC
+       }
+       [CCode (cprefix = "HILDON_TOUCH_SELECTOR_SELECTION_MODE_", cheader_filename = "hildon/hildon.h")]
+       public enum TouchSelectorSelectionMode {
+               SINGLE,
+               MULTIPLE
+       }
        [CCode (cprefix = "HILDON_UI_MODE_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
        public enum UIMode {
                NORMAL,
                EDIT
        }
-       [CCode (cprefix = "HILDON_WINDOW_CO_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_WINDOW_CO_", cheader_filename = "hildon/hildon.h")]
        public enum WindowClipboardOperation {
                COPY,
                CUT,
                PASTE
        }
-       [CCode (cprefix = "HILDON_WIZARD_DIALOG_", has_type_id = "0", cheader_filename = "hildon/hildon.h")]
+       [CCode (cprefix = "HILDON_WIZARD_DIALOG_", cheader_filename = "hildon/hildon.h")]
        public enum WizardDialogResponse {
                CANCEL,
                PREVIOUS,
@@ -674,6 +1095,34 @@ namespace Hildon {
                FINISH
        }
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public delegate unowned string TouchSelectorPrintFunc (Hildon.TouchSelector selector);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public delegate bool WizardDialogPageFunc (Gtk.Notebook notebook, int current_page);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_CENTER_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_E_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_NE_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_NW_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_N_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_SE_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_SW_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_S_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_W_GRAVITY;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_X_AXIS;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_Y_AXIS;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int AA_Z_AXIS;
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public const int MAJOR_VERSION;
        [CCode (cheader_filename = "hildon/hildon.h")]
        public const int MARGIN_DEFAULT;
@@ -690,10 +1139,50 @@ namespace Hildon {
        [CCode (cheader_filename = "hildon/hildon.h")]
        public const int WINDOW_LONG_PRESS_TIME;
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public const int WINDOW_TITLEBAR_HEIGHT;
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned string format_file_size_for_display (int64 size);
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public static int get_icon_pixel_size (Gtk.IconSize size);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_button_new (Hildon.SizeType size);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_hscale_new ();
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_icon_view_new (Hildon.UIMode mode);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_icon_view_new_with_model (Hildon.UIMode mode, Gtk.TreeModel model);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_icon_view_set_ui_mode (Gtk.IconView iconview, Hildon.UIMode mode);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_init (int argc, out unowned string argv);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_menu_new ();
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_radio_button_new (Hildon.SizeType size, GLib.SList group);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_radio_button_new_from_widget (Hildon.SizeType size, Gtk.RadioButton radio_group_member);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_toggle_button_new (Hildon.SizeType size);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_tree_view_new (Hildon.UIMode mode);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_tree_view_new_with_model (Hildon.UIMode mode, Gtk.TreeModel model);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_tree_view_set_ui_mode (Gtk.TreeView treeview, Hildon.UIMode mode);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget gtk_vscale_new ();
        [CCode (cheader_filename = "gtk/gtk.h")]
        public static void gtk_widget_set_theme_size (Gtk.Widget widget, Hildon.SizeType size);
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_window_set_do_not_disturb (Gtk.Window window, bool dndflag);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_window_set_portrait_flags (Gtk.Window window, Hildon.PortraitFlags portrait_flags);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_window_set_progress_indicator (Gtk.Window window, uint state);
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void gtk_window_take_screenshot (Gtk.Window window, bool take);
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public static bool helper_event_button_is_finger (Gdk.EventButton event);
        [CCode (cheader_filename = "hildon/hildon.h")]
        public static void helper_set_insensitive_message (Gtk.Widget widget, string message);
@@ -706,5 +1195,9 @@ namespace Hildon {
        [CCode (cheader_filename = "hildon/hildon.h")]
        public static void helper_set_thumb_scrollbar (Gtk.ScrolledWindow win, bool thumb);
        [CCode (cheader_filename = "hildon/hildon.h")]
+       public static void init ();
+       [CCode (cheader_filename = "hildon/hildon.h")]
+       public static unowned Gtk.Widget pannable_get_child_widget_at (Hildon.PannableArea area, double x, double y);
+       [CCode (cheader_filename = "hildon/hildon.h")]
        public static void play_system_sound (string sample);
 }
index 9daf04c222fe9575b9cf40537ebe940c570ebb72..38f80b0599c905bd9f355a680d7a7d15275d3811 100644 (file)
 <?xml version="1.0"?>
 <api version="1.0">
        <namespace name="Hildon">
+               <function name="format_file_size_for_display" symbol="hildon_format_file_size_for_display">
+                       <return-type type="gchar*"/>
+                       <parameters>
+                               <parameter name="size" type="goffset"/>
+                       </parameters>
+               </function>
                <function name="get_icon_pixel_size" symbol="hildon_get_icon_pixel_size">
                        <return-type type="gint"/>
                        <parameters>
                                <parameter name="size" type="GtkIconSize"/>
                        </parameters>
                </function>
+               <function name="gtk_button_new" symbol="hildon_gtk_button_new">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="size" type="HildonSizeType"/>
+                       </parameters>
+               </function>
+               <function name="gtk_hscale_new" symbol="hildon_gtk_hscale_new">
+                       <return-type type="GtkWidget*"/>
+               </function>
+               <function name="gtk_icon_view_new" symbol="hildon_gtk_icon_view_new">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="mode" type="HildonUIMode"/>
+                       </parameters>
+               </function>
+               <function name="gtk_icon_view_new_with_model" symbol="hildon_gtk_icon_view_new_with_model">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="mode" type="HildonUIMode"/>
+                               <parameter name="model" type="GtkTreeModel*"/>
+                       </parameters>
+               </function>
+               <function name="gtk_icon_view_set_ui_mode" symbol="hildon_gtk_icon_view_set_ui_mode">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="iconview" type="GtkIconView*"/>
+                               <parameter name="mode" type="HildonUIMode"/>
+                       </parameters>
+               </function>
+               <function name="gtk_init" symbol="hildon_gtk_init">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="argc" type="int*"/>
+                               <parameter name="argv" type="char***"/>
+                       </parameters>
+               </function>
+               <function name="gtk_menu_new" symbol="hildon_gtk_menu_new">
+                       <return-type type="GtkWidget*"/>
+               </function>
+               <function name="gtk_radio_button_new" symbol="hildon_gtk_radio_button_new">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="size" type="HildonSizeType"/>
+                               <parameter name="group" type="GSList*"/>
+                       </parameters>
+               </function>
+               <function name="gtk_radio_button_new_from_widget" symbol="hildon_gtk_radio_button_new_from_widget">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="size" type="HildonSizeType"/>
+                               <parameter name="radio_group_member" type="GtkRadioButton*"/>
+                       </parameters>
+               </function>
+               <function name="gtk_toggle_button_new" symbol="hildon_gtk_toggle_button_new">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="size" type="HildonSizeType"/>
+                       </parameters>
+               </function>
+               <function name="gtk_tree_view_new" symbol="hildon_gtk_tree_view_new">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="mode" type="HildonUIMode"/>
+                       </parameters>
+               </function>
+               <function name="gtk_tree_view_new_with_model" symbol="hildon_gtk_tree_view_new_with_model">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="mode" type="HildonUIMode"/>
+                               <parameter name="model" type="GtkTreeModel*"/>
+                       </parameters>
+               </function>
+               <function name="gtk_tree_view_set_ui_mode" symbol="hildon_gtk_tree_view_set_ui_mode">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="treeview" type="GtkTreeView*"/>
+                               <parameter name="mode" type="HildonUIMode"/>
+                       </parameters>
+               </function>
+               <function name="gtk_vscale_new" symbol="hildon_gtk_vscale_new">
+                       <return-type type="GtkWidget*"/>
+               </function>
+               <function name="gtk_window_set_do_not_disturb" symbol="hildon_gtk_window_set_do_not_disturb">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="window" type="GtkWindow*"/>
+                               <parameter name="dndflag" type="gboolean"/>
+                       </parameters>
+               </function>
+               <function name="gtk_window_set_portrait_flags" symbol="hildon_gtk_window_set_portrait_flags">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="window" type="GtkWindow*"/>
+                               <parameter name="portrait_flags" type="HildonPortraitFlags"/>
+                       </parameters>
+               </function>
+               <function name="gtk_window_set_progress_indicator" symbol="hildon_gtk_window_set_progress_indicator">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="window" type="GtkWindow*"/>
+                               <parameter name="state" type="guint"/>
+                       </parameters>
+               </function>
+               <function name="gtk_window_take_screenshot" symbol="hildon_gtk_window_take_screenshot">
+                       <return-type type="void"/>
+                       <parameters>
+                               <parameter name="window" type="GtkWindow*"/>
+                               <parameter name="take" type="gboolean"/>
+                       </parameters>
+               </function>
                <function name="helper_event_button_is_finger" symbol="hildon_helper_event_button_is_finger">
                        <return-type type="gboolean"/>
                        <parameters>
                                <parameter name="thumb" type="gboolean"/>
                        </parameters>
                </function>
+               <function name="init" symbol="hildon_init">
+                       <return-type type="void"/>
+               </function>
+               <function name="pannable_get_child_widget_at" symbol="hildon_pannable_get_child_widget_at">
+                       <return-type type="GtkWidget*"/>
+                       <parameters>
+                               <parameter name="area" type="HildonPannableArea*"/>
+                               <parameter name="x" type="gdouble"/>
+                               <parameter name="y" type="gdouble"/>
+                       </parameters>
+               </function>
                <function name="play_system_sound" symbol="hildon_play_system_sound">
                        <return-type type="void"/>
                        <parameters>
                                <parameter name="sample" type="gchar*"/>
                        </parameters>
                </function>
-               <enum name="HildonCaptionIconPosition">
+               <callback name="HildonTouchSelectorPrintFunc">
+                       <return-type type="gchar*"/>
+                       <parameters>
+                               <parameter name="selector" type="HildonTouchSelector*"/>
+                               <parameter name="user_data" type="gpointer"/>
+                       </parameters>
+               </callback>
+               <callback name="HildonWizardDialogPageFunc">
+                       <return-type type="gboolean"/>
+                       <parameters>
+                               <parameter name="notebook" type="GtkNotebook*"/>
+                               <parameter name="current_page" type="gint"/>
+                               <parameter name="data" type="gpointer"/>
+                       </parameters>
+               </callback>
+               <enum name="HildonButtonArrangement" type-name="HildonButtonArrangement" get-type="hildon_button_arrangement_get_type">
+                       <member name="HILDON_BUTTON_ARRANGEMENT_HORIZONTAL" value="0"/>
+                       <member name="HILDON_BUTTON_ARRANGEMENT_VERTICAL" value="1"/>
+               </enum>
+               <enum name="HildonButtonStyle" type-name="HildonButtonStyle" get-type="hildon_button_style_get_type">
+                       <member name="HILDON_BUTTON_STYLE_NORMAL" value="0"/>
+                       <member name="HILDON_BUTTON_STYLE_PICKER" value="1"/>
+               </enum>
+               <enum name="HildonCaptionIconPosition" type-name="HildonCaptionIconPosition" get-type="hildon_caption_icon_position_get_type">
                        <member name="HILDON_CAPTION_POSITION_LEFT" value="0"/>
                        <member name="HILDON_CAPTION_POSITION_RIGHT" value="1"/>
                </enum>
-               <enum name="HildonCaptionStatus">
+               <enum name="HildonCaptionStatus" type-name="HildonCaptionStatus" get-type="hildon_caption_status_get_type">
                        <member name="HILDON_CAPTION_OPTIONAL" value="0"/>
                        <member name="HILDON_CAPTION_MANDATORY" value="1"/>
                </enum>
-               <enum name="HildonDateTimeError">
+               <enum name="HildonDateTimeError" type-name="HildonDateTimeError" get-type="hildon_date_time_error_get_type">
                        <member name="HILDON_DATE_TIME_ERROR_NO_ERROR" value="-1"/>
                        <member name="HILDON_DATE_TIME_ERROR_MAX_HOURS" value="0"/>
                        <member name="HILDON_DATE_TIME_ERROR_MAX_MINS" value="1"/>
                        <member name="HILDON_DATE_TIME_ERROR_INVALID_DATE" value="21"/>
                        <member name="HILDON_DATE_TIME_ERROR_INVALID_TIME" value="22"/>
                </enum>
-               <enum name="HildonNoteType">
+               <enum name="HildonMovementDirection" type-name="HildonMovementDirection" get-type="hildon_movement_direction_get_type">
+                       <member name="HILDON_MOVEMENT_UP" value="0"/>
+                       <member name="HILDON_MOVEMENT_DOWN" value="1"/>
+                       <member name="HILDON_MOVEMENT_LEFT" value="2"/>
+                       <member name="HILDON_MOVEMENT_RIGHT" value="3"/>
+               </enum>
+               <enum name="HildonNoteType" type-name="HildonNoteType" get-type="hildon_note_type_get_type">
                        <member name="HILDON_NOTE_TYPE_CONFIRMATION" value="0"/>
                        <member name="HILDON_NOTE_TYPE_CONFIRMATION_BUTTON" value="1"/>
                        <member name="HILDON_NOTE_TYPE_INFORMATION" value="2"/>
                        <member name="HILDON_NOTE_TYPE_INFORMATION_THEME" value="3"/>
                        <member name="HILDON_NOTE_TYPE_PROGRESSBAR" value="4"/>
                </enum>
-               <enum name="HildonNumberEditorErrorType">
+               <enum name="HildonNumberEditorErrorType" type-name="HildonNumberEditorErrorType" get-type="hildon_number_editor_error_type_get_type">
                        <member name="HILDON_NUMBER_EDITOR_ERROR_MAXIMUM_VALUE_EXCEED" value="0"/>
                        <member name="HILDON_NUMBER_EDITOR_ERROR_MINIMUM_VALUE_EXCEED" value="1"/>
                        <member name="HILDON_NUMBER_EDITOR_ERROR_ERRONEOUS_VALUE" value="2"/>
                </enum>
-               <enum name="HildonWindowClipboardOperation">
+               <enum name="HildonPannableAreaMode" type-name="HildonPannableAreaMode" get-type="hildon_pannable_area_mode_get_type">
+                       <member name="HILDON_PANNABLE_AREA_MODE_PUSH" value="0"/>
+                       <member name="HILDON_PANNABLE_AREA_MODE_ACCEL" value="1"/>
+                       <member name="HILDON_PANNABLE_AREA_MODE_AUTO" value="2"/>
+               </enum>
+               <enum name="HildonSizeRequestPolicy" type-name="HildonSizeRequestPolicy" get-type="hildon_size_request_policy_get_type">
+                       <member name="HILDON_SIZE_REQUEST_MINIMUM" value="0"/>
+                       <member name="HILDON_SIZE_REQUEST_CHILDREN" value="1"/>
+               </enum>
+               <enum name="HildonTimeSelectorFormatPolicy" type-name="HildonTimeSelectorFormatPolicy" get-type="hildon_time_selector_format_policy_get_type">
+                       <member name="HILDON_TIME_SELECTOR_FORMAT_POLICY_AMPM" value="0"/>
+                       <member name="HILDON_TIME_SELECTOR_FORMAT_POLICY_24H" value="1"/>
+                       <member name="HILDON_TIME_SELECTOR_FORMAT_POLICY_AUTOMATIC" value="2"/>
+               </enum>
+               <enum name="HildonTouchSelectorSelectionMode" type-name="HildonTouchSelectorSelectionMode" get-type="hildon_touch_selector_selection_mode_get_type">
+                       <member name="HILDON_TOUCH_SELECTOR_SELECTION_MODE_SINGLE" value="0"/>
+                       <member name="HILDON_TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE" value="1"/>
+               </enum>
+               <enum name="HildonWindowClipboardOperation" type-name="HildonWindowClipboardOperation" get-type="hildon_window_clipboard_operation_get_type">
                        <member name="HILDON_WINDOW_CO_COPY" value="0"/>
                        <member name="HILDON_WINDOW_CO_CUT" value="1"/>
                        <member name="HILDON_WINDOW_CO_PASTE" value="2"/>
                </enum>
-               <enum name="HildonWizardDialogResponse">
+               <enum name="HildonWizardDialogResponse" type-name="HildonWizardDialogResponse" get-type="hildon_wizard_dialog_response_get_type">
                        <member name="HILDON_WIZARD_DIALOG_CANCEL" value="-6"/>
                        <member name="HILDON_WIZARD_DIALOG_PREVIOUS" value="0"/>
                        <member name="HILDON_WIZARD_DIALOG_NEXT" value="1"/>
                        <member name="HILDON_WIZARD_DIALOG_FINISH" value="2"/>
                </enum>
-               <flags name="HildonCalendarDisplayOptions">
+               <flags name="HildonCalendarDisplayOptions" type-name="HildonCalendarDisplayOptions" get-type="hildon_calendar_display_options_get_type">
                        <member name="HILDON_CALENDAR_SHOW_HEADING" value="1"/>
                        <member name="HILDON_CALENDAR_SHOW_DAY_NAMES" value="2"/>
                        <member name="HILDON_CALENDAR_NO_MONTH_CHANGE" value="4"/>
                        <member name="HILDON_CALENDAR_SHOW_WEEK_NUMBERS" value="8"/>
                        <member name="HILDON_CALENDAR_WEEK_START_MONDAY" value="16"/>
                </flags>
+               <flags name="HildonMovementMode" type-name="HildonMovementMode" get-type="hildon_movement_mode_get_type">
+                       <member name="HILDON_MOVEMENT_MODE_HORIZ" value="2"/>
+                       <member name="HILDON_MOVEMENT_MODE_VERT" value="4"/>
+                       <member name="HILDON_MOVEMENT_MODE_BOTH" value="6"/>
+               </flags>
+               <flags name="HildonPortraitFlags" type-name="HildonPortraitFlags" get-type="hildon_portrait_flags_get_type">
+                       <member name="HILDON_PORTRAIT_MODE_REQUEST" value="1"/>
+                       <member name="HILDON_PORTRAIT_MODE_SUPPORT" value="2"/>
+               </flags>
+               <object name="HildonAnimationActor" parent="GtkWindow" type-name="HildonAnimationActor" get-type="hildon_animation_actor_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <constructor name="new" symbol="hildon_animation_actor_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="send_message" symbol="hildon_animation_actor_send_message">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="message_type" type="guint32"/>
+                                       <parameter name="l0" type="guint32"/>
+                                       <parameter name="l1" type="guint32"/>
+                                       <parameter name="l2" type="guint32"/>
+                                       <parameter name="l3" type="guint32"/>
+                                       <parameter name="l4" type="guint32"/>
+                               </parameters>
+                       </method>
+                       <method name="set_anchor" symbol="hildon_animation_actor_set_anchor">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_anchor_from_gravity" symbol="hildon_animation_actor_set_anchor_from_gravity">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="gravity" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_depth" symbol="hildon_animation_actor_set_depth">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="depth" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_opacity" symbol="hildon_animation_actor_set_opacity">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="opacity" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_parent" symbol="hildon_animation_actor_set_parent">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_position" symbol="hildon_animation_actor_set_position">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_position_full" symbol="hildon_animation_actor_set_position_full">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                                       <parameter name="depth" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_rotation" symbol="hildon_animation_actor_set_rotation">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="axis" type="gint"/>
+                                       <parameter name="degrees" type="double"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                                       <parameter name="z" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_rotationx" symbol="hildon_animation_actor_set_rotationx">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="axis" type="gint"/>
+                                       <parameter name="degrees" type="gint32"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                                       <parameter name="z" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_scale" symbol="hildon_animation_actor_set_scale">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="x_scale" type="double"/>
+                                       <parameter name="y_scale" type="double"/>
+                               </parameters>
+                       </method>
+                       <method name="set_scalex" symbol="hildon_animation_actor_set_scalex">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="x_scale" type="gint32"/>
+                                       <parameter name="y_scale" type="gint32"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show" symbol="hildon_animation_actor_set_show">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="show" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show_full" symbol="hildon_animation_actor_set_show_full">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonAnimationActor*"/>
+                                       <parameter name="show" type="gint"/>
+                                       <parameter name="opacity" type="gint"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="HildonAppMenu" parent="GtkWindow" type-name="HildonAppMenu" get-type="hildon_app_menu_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="add_filter" symbol="hildon_app_menu_add_filter">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="filter" type="GtkButton*"/>
+                               </parameters>
+                       </method>
+                       <method name="append" symbol="hildon_app_menu_append">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="item" type="GtkButton*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_filters" symbol="hildon_app_menu_get_filters">
+                               <return-type type="GList*"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_items" symbol="hildon_app_menu_get_items">
+                               <return-type type="GList*"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                               </parameters>
+                       </method>
+                       <method name="insert" symbol="hildon_app_menu_insert">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="item" type="GtkButton*"/>
+                                       <parameter name="position" type="gint"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_app_menu_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="popup" symbol="hildon_app_menu_popup">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="parent_window" type="GtkWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="prepend" symbol="hildon_app_menu_prepend">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="item" type="GtkButton*"/>
+                               </parameters>
+                       </method>
+                       <method name="reorder_child" symbol="hildon_app_menu_reorder_child">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                                       <parameter name="item" type="GtkButton*"/>
+                                       <parameter name="position" type="gint"/>
+                               </parameters>
+                       </method>
+               </object>
                <object name="HildonBanner" parent="GtkWindow" type-name="HildonBanner" get-type="hildon_banner_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                        <parameter name="text" type="gchar*"/>
                                </parameters>
                        </method>
+                       <method name="show_information_override_dnd" symbol="hildon_banner_show_information_override_dnd">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="widget" type="GtkWidget*"/>
+                                       <parameter name="text" type="gchar*"/>
+                               </parameters>
+                       </method>
                        <method name="show_information_with_markup" symbol="hildon_banner_show_information_with_markup">
                                <return-type type="GtkWidget*"/>
                                <parameters>
                                        <parameter name="bct" type="HildonBreadCrumbTrail*"/>
                                        <parameter name="item" type="HildonBreadCrumb*"/>
                                        <parameter name="id" type="gpointer"/>
-                                       <parameter name="notify" type="GDestroyNotify"/>
+                                       <parameter name="destroy" type="GDestroyNotify"/>
                                </parameters>
                        </method>
                        <method name="push_icon" symbol="hildon_bread_crumb_trail_push_icon">
                                        <parameter name="bct" type="HildonBreadCrumbTrail*"/>
                                        <parameter name="text" type="gchar*"/>
                                        <parameter name="id" type="gpointer"/>
-                                       <parameter name="notify" type="GDestroyNotify"/>
+                                       <parameter name="destroy" type="GDestroyNotify"/>
                                </parameters>
                        </method>
                        <signal name="crumb-clicked" when="LAST">
                                </parameters>
                        </signal>
                </object>
-               <object name="HildonCalendar" parent="GtkWidget" type-name="HildonCalendar" get-type="hildon_calendar_get_type">
+               <object name="HildonButton" parent="GtkButton" type-name="HildonButton" get-type="hildon_button_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                <interface name="GtkBuildable"/>
                        </implements>
-                       <method name="clear_marks" symbol="hildon_calendar_clear_marks">
+                       <method name="add_image_size_group" symbol="hildon_button_add_image_size_group">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="size_group" type="GtkSizeGroup*"/>
                                </parameters>
                        </method>
-                       <method name="freeze" symbol="hildon_calendar_freeze">
+                       <method name="add_size_groups" symbol="hildon_button_add_size_groups">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="title_size_group" type="GtkSizeGroup*"/>
+                                       <parameter name="value_size_group" type="GtkSizeGroup*"/>
+                                       <parameter name="image_size_group" type="GtkSizeGroup*"/>
                                </parameters>
                        </method>
-                       <method name="get_date" symbol="hildon_calendar_get_date">
+                       <method name="add_title_size_group" symbol="hildon_button_add_title_size_group">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="year" type="guint*"/>
-                                       <parameter name="month" type="guint*"/>
-                                       <parameter name="day" type="guint*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="size_group" type="GtkSizeGroup*"/>
                                </parameters>
                        </method>
-                       <method name="get_display_options" symbol="hildon_calendar_get_display_options">
-                               <return-type type="HildonCalendarDisplayOptions"/>
+                       <method name="add_value_size_group" symbol="hildon_button_add_value_size_group">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="size_group" type="GtkSizeGroup*"/>
                                </parameters>
                        </method>
-                       <method name="mark_day" symbol="hildon_calendar_mark_day">
-                               <return-type type="gboolean"/>
+                       <method name="get_image" symbol="hildon_button_get_image">
+                               <return-type type="GtkWidget*"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="day" type="guint"/>
+                                       <parameter name="button" type="HildonButton*"/>
                                </parameters>
                        </method>
-                       <constructor name="new" symbol="hildon_calendar_new">
-                               <return-type type="GtkWidget*"/>
-                       </constructor>
-                       <method name="select_day" symbol="hildon_calendar_select_day">
-                               <return-type type="void"/>
+                       <method name="get_style" symbol="hildon_button_get_style">
+                               <return-type type="HildonButtonStyle"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="day" type="guint"/>
+                                       <parameter name="button" type="HildonButton*"/>
                                </parameters>
                        </method>
-                       <method name="select_month" symbol="hildon_calendar_select_month">
-                               <return-type type="gboolean"/>
+                       <method name="get_title" symbol="hildon_button_get_title">
+                               <return-type type="gchar*"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="month" type="guint"/>
-                                       <parameter name="year" type="guint"/>
+                                       <parameter name="button" type="HildonButton*"/>
                                </parameters>
                        </method>
-                       <method name="set_display_options" symbol="hildon_calendar_set_display_options">
-                               <return-type type="void"/>
+                       <method name="get_value" symbol="hildon_button_get_value">
+                               <return-type type="gchar*"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="flags" type="HildonCalendarDisplayOptions"/>
+                                       <parameter name="button" type="HildonButton*"/>
                                </parameters>
                        </method>
-                       <method name="thaw" symbol="hildon_calendar_thaw">
+                       <constructor name="new" symbol="hildon_button_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_with_text" symbol="hildon_button_new_with_text">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                                       <parameter name="title" type="gchar*"/>
+                                       <parameter name="value" type="gchar*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_alignment" symbol="hildon_button_set_alignment">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="xalign" type="gfloat"/>
+                                       <parameter name="yalign" type="gfloat"/>
+                                       <parameter name="xscale" type="gfloat"/>
+                                       <parameter name="yscale" type="gfloat"/>
                                </parameters>
                        </method>
-                       <method name="unmark_day" symbol="hildon_calendar_unmark_day">
-                               <return-type type="gboolean"/>
+                       <method name="set_image" symbol="hildon_button_set_image">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
-                                       <parameter name="day" type="guint"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="image" type="GtkWidget*"/>
                                </parameters>
                        </method>
-                       <property name="day" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="max-year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="min-year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="month" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="no-month-change" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="show-day-names" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="show-heading" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="show-week-numbers" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="week-start" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <signal name="day-selected" when="FIRST">
+                       <method name="set_image_alignment" symbol="hildon_button_set_image_alignment">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="xalign" type="gfloat"/>
+                                       <parameter name="yalign" type="gfloat"/>
                                </parameters>
-                       </signal>
-                       <signal name="day-selected-double-click" when="FIRST">
+                       </method>
+                       <method name="set_image_position" symbol="hildon_button_set_image_position">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="position" type="GtkPositionType"/>
+                               </parameters>
+                       </method>
+                       <method name="set_style" symbol="hildon_button_set_style">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="style" type="HildonButtonStyle"/>
+                               </parameters>
+                       </method>
+                       <method name="set_text" symbol="hildon_button_set_text">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="title" type="gchar*"/>
+                                       <parameter name="value" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_title" symbol="hildon_button_set_title">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="title" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_title_alignment" symbol="hildon_button_set_title_alignment">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="xalign" type="gfloat"/>
+                                       <parameter name="yalign" type="gfloat"/>
+                               </parameters>
+                       </method>
+                       <method name="set_value" symbol="hildon_button_set_value">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="value" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_value_alignment" symbol="hildon_button_set_value_alignment">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonButton*"/>
+                                       <parameter name="xalign" type="gfloat"/>
+                                       <parameter name="yalign" type="gfloat"/>
+                               </parameters>
+                       </method>
+                       <property name="arrangement" type="HildonButtonArrangement" readable="0" writable="1" construct="0" construct-only="1"/>
+                       <property name="size" type="HildonSizeType" readable="0" writable="1" construct="0" construct-only="1"/>
+                       <property name="style" type="HildonButtonStyle" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="title" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="value" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+               </object>
+               <object name="HildonCalendar" parent="GtkWidget" type-name="HildonCalendar" get-type="hildon_calendar_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="clear_marks" symbol="hildon_calendar_clear_marks">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                               </parameters>
+                       </method>
+                       <method name="freeze" symbol="hildon_calendar_freeze">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_date" symbol="hildon_calendar_get_date">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="year" type="guint*"/>
+                                       <parameter name="month" type="guint*"/>
+                                       <parameter name="day" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_display_options" symbol="hildon_calendar_get_display_options">
+                               <return-type type="HildonCalendarDisplayOptions"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                               </parameters>
+                       </method>
+                       <method name="mark_day" symbol="hildon_calendar_mark_day">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="day" type="guint"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_calendar_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="select_day" symbol="hildon_calendar_select_day">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="day" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="select_month" symbol="hildon_calendar_select_month">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="month" type="guint"/>
+                                       <parameter name="year" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_display_options" symbol="hildon_calendar_set_display_options">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="flags" type="HildonCalendarDisplayOptions"/>
+                               </parameters>
+                       </method>
+                       <method name="thaw" symbol="hildon_calendar_thaw">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                               </parameters>
+                       </method>
+                       <method name="unmark_day" symbol="hildon_calendar_unmark_day">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                                       <parameter name="day" type="guint"/>
+                               </parameters>
+                       </method>
+                       <property name="day" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="max-year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="min-year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="month" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="no-month-change" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="show-day-names" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="show-heading" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="show-week-numbers" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="week-start" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="year" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <signal name="day-selected" when="FIRST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
+                               </parameters>
+                       </signal>
+                       <signal name="day-selected-double-click" when="FIRST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="calendar" type="HildonCalendar*"/>
                                </parameters>
                        </signal>
                        <signal name="erroneous-date" when="FIRST">
                                </parameters>
                        </signal>
                </object>
+               <object name="HildonCheckButton" parent="GtkButton" type-name="HildonCheckButton" get-type="hildon_check_button_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_active" symbol="hildon_check_button_get_active">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonCheckButton*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_check_button_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_active" symbol="hildon_check_button_set_active">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonCheckButton*"/>
+                                       <parameter name="is_active" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <property name="size" type="HildonSizeType" readable="0" writable="1" construct="0" construct-only="0"/>
+                       <signal name="toggled" when="FIRST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonCheckButton*"/>
+                               </parameters>
+                       </signal>
+               </object>
                <object name="HildonCodeDialog" parent="GtkDialog" type-name="HildonCodeDialog" get-type="hildon_code_dialog_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                        </method>
                        <property name="color" type="GdkColor*" readable="1" writable="1" construct="0" construct-only="0"/>
                        <property name="popup-shown" type="gboolean" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <signal name="setup-dialog" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="object" type="HildonColorButton*"/>
+                                       <parameter name="p0" type="HildonColorChooserDialog*"/>
+                               </parameters>
+                       </signal>
                </object>
                <object name="HildonColorChooser" parent="GtkWidget" type-name="HildonColorChooser" get-type="hildon_color_chooser_get_type">
                        <implements>
                                </parameters>
                        </signal>
                </object>
+               <object name="HildonDateButton" parent="HildonPickerButton" type-name="HildonDateButton" get-type="hildon_date_button_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_date" symbol="hildon_date_button_get_date">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonDateButton*"/>
+                                       <parameter name="year" type="guint*"/>
+                                       <parameter name="month" type="guint*"/>
+                                       <parameter name="day" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_date_button_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_with_year_range" symbol="hildon_date_button_new_with_year_range">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                                       <parameter name="min_year" type="gint"/>
+                                       <parameter name="max_year" type="gint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_date" symbol="hildon_date_button_set_date">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonDateButton*"/>
+                                       <parameter name="year" type="guint"/>
+                                       <parameter name="month" type="guint"/>
+                                       <parameter name="day" type="guint"/>
+                               </parameters>
+                       </method>
+               </object>
                <object name="HildonDateEditor" parent="GtkContainer" type-name="HildonDateEditor" get-type="hildon_date_editor_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                </parameters>
                        </signal>
                </object>
-               <object name="HildonFindToolbar" parent="GtkToolbar" type-name="HildonFindToolbar" get-type="hildon_find_toolbar_get_type">
+               <object name="HildonDateSelector" parent="HildonTouchSelector" type-name="HildonDateSelector" get-type="hildon_date_selector_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                <interface name="GtkBuildable"/>
                        </implements>
-                       <method name="get_active" symbol="hildon_find_toolbar_get_active">
-                               <return-type type="gint"/>
+                       <method name="get_date" symbol="hildon_date_selector_get_date">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="selector" type="HildonDateSelector*"/>
+                                       <parameter name="year" type="guint*"/>
+                                       <parameter name="month" type="guint*"/>
+                                       <parameter name="day" type="guint*"/>
                                </parameters>
                        </method>
-                       <method name="get_active_iter" symbol="hildon_find_toolbar_get_active_iter">
+                       <constructor name="new" symbol="hildon_date_selector_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_with_year_range" symbol="hildon_date_selector_new_with_year_range">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="min_year" type="gint"/>
+                                       <parameter name="max_year" type="gint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="select_current_date" symbol="hildon_date_selector_select_current_date">
                                <return-type type="gboolean"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
-                                       <parameter name="iter" type="GtkTreeIter*"/>
+                                       <parameter name="selector" type="HildonDateSelector*"/>
+                                       <parameter name="year" type="guint"/>
+                                       <parameter name="month" type="guint"/>
+                                       <parameter name="day" type="guint"/>
                                </parameters>
                        </method>
-                       <method name="get_last_index" symbol="hildon_find_toolbar_get_last_index">
-                               <return-type type="gint32"/>
+                       <method name="select_day" symbol="hildon_date_selector_select_day">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="selector" type="HildonDateSelector*"/>
+                                       <parameter name="day" type="guint"/>
                                </parameters>
                        </method>
-                       <method name="highlight_entry" symbol="hildon_find_toolbar_highlight_entry">
+                       <method name="select_month" symbol="hildon_date_selector_select_month">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonDateSelector*"/>
+                                       <parameter name="month" type="guint"/>
+                                       <parameter name="year" type="guint"/>
+                               </parameters>
+                       </method>
+                       <property name="max-year" type="gint" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="min-year" type="gint" readable="1" writable="1" construct="0" construct-only="1"/>
+               </object>
+               <object name="HildonDialog" parent="GtkDialog" type-name="HildonDialog" get-type="hildon_dialog_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="add_button" symbol="hildon_dialog_add_button">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonDialog*"/>
+                                       <parameter name="button_text" type="gchar*"/>
+                                       <parameter name="response_id" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="add_buttons" symbol="hildon_dialog_add_buttons">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="ftb" type="HildonFindToolbar*"/>
-                                       <parameter name="get_focus" type="gboolean"/>
+                                       <parameter name="dialog" type="HildonDialog*"/>
+                                       <parameter name="first_button_text" type="gchar*"/>
                                </parameters>
                        </method>
-                       <constructor name="new" symbol="hildon_find_toolbar_new">
+                       <constructor name="new" symbol="hildon_dialog_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_with_buttons" symbol="hildon_dialog_new_with_buttons">
                                <return-type type="GtkWidget*"/>
                                <parameters>
-                                       <parameter name="label" type="gchar*"/>
+                                       <parameter name="title" type="gchar*"/>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                                       <parameter name="flags" type="GtkDialogFlags"/>
+                                       <parameter name="first_button_text" type="gchar*"/>
                                </parameters>
                        </constructor>
-                       <constructor name="new_with_model" symbol="hildon_find_toolbar_new_with_model">
+               </object>
+               <object name="HildonEditToolbar" parent="GtkHBox" type-name="HildonEditToolbar" get-type="hildon_edit_toolbar_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <constructor name="new" symbol="hildon_edit_toolbar_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_with_text" symbol="hildon_edit_toolbar_new_with_text">
                                <return-type type="GtkWidget*"/>
                                <parameters>
                                        <parameter name="label" type="gchar*"/>
-                                       <parameter name="model" type="GtkListStore*"/>
-                                       <parameter name="column" type="gint"/>
+                                       <parameter name="button" type="gchar*"/>
                                </parameters>
                        </constructor>
-                       <method name="set_active" symbol="hildon_find_toolbar_set_active">
+                       <method name="set_button_label" symbol="hildon_edit_toolbar_set_button_label">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
-                                       <parameter name="index" type="gint"/>
+                                       <parameter name="toolbar" type="HildonEditToolbar*"/>
+                                       <parameter name="label" type="gchar*"/>
                                </parameters>
                        </method>
-                       <method name="set_active_iter" symbol="hildon_find_toolbar_set_active_iter">
+                       <method name="set_label" symbol="hildon_edit_toolbar_set_label">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
-                                       <parameter name="iter" type="GtkTreeIter*"/>
+                                       <parameter name="toolbar" type="HildonEditToolbar*"/>
+                                       <parameter name="label" type="gchar*"/>
                                </parameters>
                        </method>
-                       <property name="column" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="history-limit" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
-                       <property name="label" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
-                       <property name="list" type="GtkListStore*" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="max-characters" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
-                       <property name="prefix" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <signal name="close" when="LAST">
+                       <signal name="arrow-clicked" when="FIRST">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="object" type="HildonEditToolbar*"/>
                                </parameters>
                        </signal>
-                       <signal name="history-append" when="LAST">
+                       <signal name="button-clicked" when="FIRST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="object" type="HildonEditToolbar*"/>
+                               </parameters>
+                       </signal>
+               </object>
+               <object name="HildonEntry" parent="GtkEntry" type-name="HildonEntry" get-type="hildon_entry_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                               <interface name="GtkEditable"/>
+                               <interface name="GtkCellEditable"/>
+                       </implements>
+                       <method name="get_text" symbol="hildon_entry_get_text">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="entry" type="HildonEntry*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_entry_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_placeholder" symbol="hildon_entry_set_placeholder">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="entry" type="HildonEntry*"/>
+                                       <parameter name="text" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_text" symbol="hildon_entry_set_text">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="entry" type="HildonEntry*"/>
+                                       <parameter name="text" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <property name="size" type="HildonSizeType" readable="0" writable="1" construct="1" construct-only="0"/>
+               </object>
+               <object name="HildonFindToolbar" parent="GtkToolbar" type-name="HildonFindToolbar" get-type="hildon_find_toolbar_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                               <interface name="GtkToolShell"/>
+                       </implements>
+                       <method name="get_active" symbol="hildon_find_toolbar_get_active">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_active_iter" symbol="hildon_find_toolbar_get_active_iter">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="iter" type="GtkTreeIter*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_last_index" symbol="hildon_find_toolbar_get_last_index">
+                               <return-type type="gint32"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                               </parameters>
+                       </method>
+                       <method name="highlight_entry" symbol="hildon_find_toolbar_highlight_entry">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="ftb" type="HildonFindToolbar*"/>
+                                       <parameter name="get_focus" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_find_toolbar_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="label" type="gchar*"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_with_model" symbol="hildon_find_toolbar_new_with_model">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="label" type="gchar*"/>
+                                       <parameter name="model" type="GtkListStore*"/>
+                                       <parameter name="column" type="gint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_active" symbol="hildon_find_toolbar_set_active">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="index" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_active_iter" symbol="hildon_find_toolbar_set_active_iter">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                                       <parameter name="iter" type="GtkTreeIter*"/>
+                               </parameters>
+                       </method>
+                       <property name="column" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="history-limit" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="label" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="list" type="GtkListStore*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="max-characters" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="prefix" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <signal name="close" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="toolbar" type="HildonFindToolbar*"/>
+                               </parameters>
+                       </signal>
+                       <signal name="history-append" when="LAST">
                                <return-type type="gboolean"/>
                                <parameters>
                                        <parameter name="tooblar" type="HildonFindToolbar*"/>
                                </parameters>
                        </signal>
                </object>
+               <object name="HildonPannableArea" parent="GtkBin" type-name="HildonPannableArea" get-type="hildon_pannable_area_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="add_with_viewport" symbol="hildon_pannable_area_add_with_viewport">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="child" type="GtkWidget*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_hadjustment" symbol="hildon_pannable_area_get_hadjustment">
+                               <return-type type="GtkAdjustment*"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_size_request_policy" symbol="hildon_pannable_area_get_size_request_policy">
+                               <return-type type="HildonSizeRequestPolicy"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_vadjustment" symbol="hildon_pannable_area_get_vadjustment">
+                               <return-type type="GtkAdjustment*"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                               </parameters>
+                       </method>
+                       <method name="jump_to" symbol="hildon_pannable_area_jump_to">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="jump_to_child" symbol="hildon_pannable_area_jump_to_child">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="child" type="GtkWidget*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_pannable_area_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_full" symbol="hildon_pannable_area_new_full">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="mode" type="gint"/>
+                                       <parameter name="enabled" type="gboolean"/>
+                                       <parameter name="vel_min" type="gdouble"/>
+                                       <parameter name="vel_max" type="gdouble"/>
+                                       <parameter name="decel" type="gdouble"/>
+                                       <parameter name="sps" type="guint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="scroll_to" symbol="hildon_pannable_area_scroll_to">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="scroll_to_child" symbol="hildon_pannable_area_scroll_to_child">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="child" type="GtkWidget*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_size_request_policy" symbol="hildon_pannable_area_set_size_request_policy">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="size_request_policy" type="HildonSizeRequestPolicy"/>
+                               </parameters>
+                       </method>
+                       <property name="bounce-steps" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="deceleration" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="direction-error-margin" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="drag-inertia" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="enabled" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="force" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="hadjustment" type="GtkAdjustment*" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="hovershoot-max" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="hscrollbar-policy" type="GtkPolicyType" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="initial-hint" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="low-friction-mode" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="mode" type="HildonPannableAreaMode" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="mov-mode" type="HildonMovementMode" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="panning-threshold" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="scroll-time" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="scrollbar-fade-delay" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="size-request-policy" type="HildonSizeRequestPolicy" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="sps" type="guint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="vadjustment" type="GtkAdjustment*" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="velocity-fast-factor" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="velocity-max" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="velocity-min" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="velocity-overshooting-max" type="gdouble" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="vovershoot-max" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="vscrollbar-policy" type="GtkPolicyType" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <signal name="horizontal-movement" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="direction" type="gint"/>
+                                       <parameter name="x" type="gdouble"/>
+                                       <parameter name="y" type="gdouble"/>
+                               </parameters>
+                       </signal>
+                       <signal name="panning-finished" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="object" type="HildonPannableArea*"/>
+                               </parameters>
+                       </signal>
+                       <signal name="panning-started" when="LAST">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="object" type="HildonPannableArea*"/>
+                               </parameters>
+                       </signal>
+                       <signal name="vertical-movement" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="area" type="HildonPannableArea*"/>
+                                       <parameter name="direction" type="gint"/>
+                                       <parameter name="x" type="gdouble"/>
+                                       <parameter name="y" type="gdouble"/>
+                               </parameters>
+                       </signal>
+               </object>
+               <object name="HildonPickerButton" parent="HildonButton" type-name="HildonPickerButton" get-type="hildon_picker_button_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_active" symbol="hildon_picker_button_get_active">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_done_button_text" symbol="hildon_picker_button_get_done_button_text">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_selector" symbol="hildon_picker_button_get_selector">
+                               <return-type type="HildonTouchSelector*"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_picker_button_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_active" symbol="hildon_picker_button_set_active">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                                       <parameter name="index" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_done_button_text" symbol="hildon_picker_button_set_done_button_text">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                                       <parameter name="done_button_text" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_selector" symbol="hildon_picker_button_set_selector">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonPickerButton*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <property name="done-button-text" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="touch-selector" type="HildonTouchSelector*" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <signal name="value-changed" when="LAST">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="object" type="HildonPickerButton*"/>
+                               </parameters>
+                       </signal>
+               </object>
+               <object name="HildonPickerDialog" parent="HildonDialog" type-name="HildonPickerDialog" get-type="hildon_picker_dialog_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_done_label" symbol="hildon_picker_dialog_get_done_label">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonPickerDialog*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_selector" symbol="hildon_picker_dialog_get_selector">
+                               <return-type type="HildonTouchSelector*"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonPickerDialog*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_picker_dialog_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_done_label" symbol="hildon_picker_dialog_set_done_label">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonPickerDialog*"/>
+                                       <parameter name="label" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_selector" symbol="hildon_picker_dialog_set_selector">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonPickerDialog*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <property name="center-on-show" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <property name="done-button-text" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <vfunc name="set_selector">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonPickerDialog*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </vfunc>
+               </object>
                <object name="HildonProgram" parent="GObject" type-name="HildonProgram" get-type="hildon_program_get_type">
                        <method name="add_window" symbol="hildon_program_add_window">
                                <return-type type="void"/>
                                        <parameter name="self" type="HildonProgram*"/>
                                </parameters>
                        </method>
+                       <method name="get_common_app_menu" symbol="hildon_program_get_common_app_menu">
+                               <return-type type="HildonAppMenu*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonProgram*"/>
+                               </parameters>
+                       </method>
                        <method name="get_common_menu" symbol="hildon_program_get_common_menu">
                                <return-type type="GtkMenu*"/>
                                <parameters>
                                        <parameter name="self" type="HildonProgram*"/>
                                </parameters>
                        </method>
+                       <method name="go_to_root_window" symbol="hildon_program_go_to_root_window">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonProgram*"/>
+                               </parameters>
+                       </method>
+                       <method name="peek_window_stack" symbol="hildon_program_peek_window_stack">
+                               <return-type type="HildonStackableWindow*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonProgram*"/>
+                               </parameters>
+                       </method>
+                       <method name="pop_window_stack" symbol="hildon_program_pop_window_stack">
+                               <return-type type="HildonStackableWindow*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonProgram*"/>
+                               </parameters>
+                       </method>
                        <method name="remove_window" symbol="hildon_program_remove_window">
                                <return-type type="void"/>
                                <parameters>
                                        <parameter name="can_hibernate" type="gboolean"/>
                                </parameters>
                        </method>
+                       <method name="set_common_app_menu" symbol="hildon_program_set_common_app_menu">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonProgram*"/>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                               </parameters>
+                       </method>
                        <method name="set_common_menu" symbol="hildon_program_set_common_menu">
                                <return-type type="void"/>
                                <parameters>
                        <property name="min" type="gint" readable="1" writable="1" construct="1" construct-only="0"/>
                        <property name="separator" type="char*" readable="1" writable="1" construct="1" construct-only="0"/>
                </object>
-               <object name="HildonSeekbar" parent="GtkScale" type-name="HildonSeekbar" get-type="hildon_seekbar_get_type">
+               <object name="HildonRemoteTexture" parent="GtkWindow" type-name="HildonRemoteTexture" get-type="hildon_remote_texture_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                <interface name="GtkBuildable"/>
                        </implements>
-                       <method name="get_fraction" symbol="hildon_seekbar_get_fraction">
-                               <return-type type="guint"/>
+                       <constructor name="new" symbol="hildon_remote_texture_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="send_message" symbol="hildon_remote_texture_send_message">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="seekbar" type="HildonSeekbar*"/>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="message_type" type="guint32"/>
+                                       <parameter name="l0" type="guint32"/>
+                                       <parameter name="l1" type="guint32"/>
+                                       <parameter name="l2" type="guint32"/>
+                                       <parameter name="l3" type="guint32"/>
+                                       <parameter name="l4" type="guint32"/>
                                </parameters>
                        </method>
-                       <method name="get_position" symbol="hildon_seekbar_get_position">
+                       <method name="set_image" symbol="hildon_remote_texture_set_image">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="key" type="guint32"/>
+                                       <parameter name="width" type="guint"/>
+                                       <parameter name="height" type="guint"/>
+                                       <parameter name="bpp" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_offset" symbol="hildon_remote_texture_set_offset">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="x" type="double"/>
+                                       <parameter name="y" type="double"/>
+                               </parameters>
+                       </method>
+                       <method name="set_opacity" symbol="hildon_remote_texture_set_opacity">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="opacity" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_parent" symbol="hildon_remote_texture_set_parent">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_position" symbol="hildon_remote_texture_set_position">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                                       <parameter name="width" type="gint"/>
+                                       <parameter name="height" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_scale" symbol="hildon_remote_texture_set_scale">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="x_scale" type="double"/>
+                                       <parameter name="y_scale" type="double"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show" symbol="hildon_remote_texture_set_show">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="show" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show_full" symbol="hildon_remote_texture_set_show_full">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="show" type="gint"/>
+                                       <parameter name="opacity" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="update_area" symbol="hildon_remote_texture_update_area">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonRemoteTexture*"/>
+                                       <parameter name="x" type="gint"/>
+                                       <parameter name="y" type="gint"/>
+                                       <parameter name="width" type="gint"/>
+                                       <parameter name="height" type="gint"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="HildonSeekbar" parent="GtkScale" type-name="HildonSeekbar" get-type="hildon_seekbar_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_fraction" symbol="hildon_seekbar_get_fraction">
+                               <return-type type="guint"/>
+                               <parameters>
+                                       <parameter name="seekbar" type="HildonSeekbar*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_position" symbol="hildon_seekbar_get_position">
                                <return-type type="gint"/>
                                <parameters>
                                        <parameter name="seekbar" type="HildonSeekbar*"/>
                                        <parameter name="sort_key" type="gchar*"/>
                                </parameters>
                        </method>
-                       <method name="add_sort_key_reversed" symbol="hildon_sort_dialog_add_sort_key_reversed">
-                               <return-type type="gint"/>
+                       <method name="add_sort_key_reversed" symbol="hildon_sort_dialog_add_sort_key_reversed">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                                       <parameter name="sort_key" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_sort_key" symbol="hildon_sort_dialog_get_sort_key">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_sort_order" symbol="hildon_sort_dialog_get_sort_order">
+                               <return-type type="GtkSortType"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_sort_dialog_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_sort_key" symbol="hildon_sort_dialog_set_sort_key">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                                       <parameter name="key" type="int"/>
+                               </parameters>
+                       </method>
+                       <method name="set_sort_order" symbol="hildon_sort_dialog_set_sort_order">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                                       <parameter name="order" type="GtkSortType"/>
+                               </parameters>
+                       </method>
+                       <property name="sort-key" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="sort-order" type="GtkSortType" readable="1" writable="1" construct="0" construct-only="0"/>
+               </object>
+               <object name="HildonStackableWindow" parent="HildonWindow" type-name="HildonStackableWindow" get-type="hildon_stackable_window_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_stack" symbol="hildon_stackable_window_get_stack">
+                               <return-type type="HildonWindowStack*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonStackableWindow*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_stackable_window_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="set_main_menu" symbol="hildon_stackable_window_set_main_menu">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonStackableWindow*"/>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="HildonTextView" parent="GtkTextView" type-name="HildonTextView" get-type="hildon_text_view_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_buffer" symbol="hildon_text_view_get_buffer">
+                               <return-type type="GtkTextBuffer*"/>
+                               <parameters>
+                                       <parameter name="text_view" type="HildonTextView*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_text_view_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="set_buffer" symbol="hildon_text_view_set_buffer">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="text_view" type="HildonTextView*"/>
+                                       <parameter name="buffer" type="GtkTextBuffer*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_placeholder" symbol="hildon_text_view_set_placeholder">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="text_view" type="HildonTextView*"/>
+                                       <parameter name="text" type="gchar*"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="HildonTimeButton" parent="HildonPickerButton" type-name="HildonTimeButton" get-type="hildon_time_button_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_time" symbol="hildon_time_button_get_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonTimeButton*"/>
+                                       <parameter name="hours" type="guint*"/>
+                                       <parameter name="minutes" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_time_button_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                               </parameters>
+                       </constructor>
+                       <constructor name="new_step" symbol="hildon_time_button_new_step">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="size" type="HildonSizeType"/>
+                                       <parameter name="arrangement" type="HildonButtonArrangement"/>
+                                       <parameter name="minutes_step" type="guint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_time" symbol="hildon_time_button_set_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="button" type="HildonTimeButton*"/>
+                                       <parameter name="hours" type="guint"/>
+                                       <parameter name="minutes" type="guint"/>
+                               </parameters>
+                       </method>
+               </object>
+               <object name="HildonTimeEditor" parent="GtkContainer" type-name="HildonTimeEditor" get-type="hildon_time_editor_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_duration_max" symbol="hildon_time_editor_get_duration_max">
+                               <return-type type="guint"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_duration_min" symbol="hildon_time_editor_get_duration_min">
+                               <return-type type="guint"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_duration_mode" symbol="hildon_time_editor_get_duration_mode">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_duration_range" symbol="hildon_time_editor_get_duration_range">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="min_seconds" type="guint*"/>
+                                       <parameter name="max_seconds" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_show_hours" symbol="hildon_time_editor_get_show_hours">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_show_seconds" symbol="hildon_time_editor_get_show_seconds">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_ticks" symbol="hildon_time_editor_get_ticks">
+                               <return-type type="guint"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_time" symbol="hildon_time_editor_get_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="hours" type="guint*"/>
+                                       <parameter name="minutes" type="guint*"/>
+                                       <parameter name="seconds" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_time_separators" symbol="hildon_time_editor_get_time_separators">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="hm_sep_label" type="GtkLabel*"/>
+                                       <parameter name="ms_sep_label" type="GtkLabel*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_time_editor_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="set_duration_max" symbol="hildon_time_editor_set_duration_max">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="duration_max" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_duration_min" symbol="hildon_time_editor_set_duration_min">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="duration_min" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_duration_mode" symbol="hildon_time_editor_set_duration_mode">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="duration_mode" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="set_duration_range" symbol="hildon_time_editor_set_duration_range">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="min_seconds" type="guint"/>
+                                       <parameter name="max_seconds" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show_hours" symbol="hildon_time_editor_set_show_hours">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="show_hours" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="set_show_seconds" symbol="hildon_time_editor_set_show_seconds">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="show_seconds" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="set_ticks" symbol="hildon_time_editor_set_ticks">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="ticks" type="guint"/>
+                               </parameters>
+                       </method>
+                       <method name="set_time" symbol="hildon_time_editor_set_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="hours" type="guint"/>
+                                       <parameter name="minutes" type="guint"/>
+                                       <parameter name="seconds" type="guint"/>
+                               </parameters>
+                       </method>
+                       <property name="duration-max" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="duration-min" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="duration-mode" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="show-hours" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="show-seconds" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="ticks" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <signal name="time-error" when="LAST">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="type" type="HildonDateTimeError"/>
+                               </parameters>
+                       </signal>
+               </object>
+               <object name="HildonTimePicker" parent="GtkDialog" type-name="HildonTimePicker" get-type="hildon_time_picker_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_time" symbol="hildon_time_picker_get_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="picker" type="HildonTimePicker*"/>
+                                       <parameter name="hours" type="guint*"/>
+                                       <parameter name="minutes" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_time_picker_new">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="parent" type="GtkWindow*"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_time" symbol="hildon_time_picker_set_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="picker" type="HildonTimePicker*"/>
+                                       <parameter name="hours" type="guint"/>
+                                       <parameter name="minutes" type="guint"/>
+                               </parameters>
+                       </method>
+                       <property name="minutes" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
+               </object>
+               <object name="HildonTimeSelector" parent="HildonTouchSelector" type-name="HildonTimeSelector" get-type="hildon_time_selector_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="get_time" symbol="hildon_time_selector_get_time">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTimeSelector*"/>
+                                       <parameter name="hours" type="guint*"/>
+                                       <parameter name="minutes" type="guint*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_time_selector_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_step" symbol="hildon_time_selector_new_step">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="minutes_step" type="guint"/>
+                               </parameters>
+                       </constructor>
+                       <method name="set_time" symbol="hildon_time_selector_set_time">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTimeSelector*"/>
+                                       <parameter name="hours" type="guint"/>
+                                       <parameter name="minutes" type="guint"/>
+                               </parameters>
+                       </method>
+                       <property name="minutes-step" type="guint" readable="1" writable="1" construct="0" construct-only="1"/>
+                       <property name="time-format-policy" type="HildonTimeSelectorFormatPolicy" readable="1" writable="1" construct="1" construct-only="0"/>
+               </object>
+               <object name="HildonTouchSelector" parent="GtkVBox" type-name="HildonTouchSelector" get-type="hildon_touch_selector_get_type">
+                       <implements>
+                               <interface name="AtkImplementor"/>
+                               <interface name="GtkBuildable"/>
+                       </implements>
+                       <method name="append_column" symbol="hildon_touch_selector_append_column">
+                               <return-type type="HildonTouchSelectorColumn*"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="model" type="GtkTreeModel*"/>
+                                       <parameter name="cell_renderer" type="GtkCellRenderer*"/>
+                               </parameters>
+                       </method>
+                       <method name="append_text" symbol="hildon_touch_selector_append_text">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="text" type="gchar*"/>
+                               </parameters>
+                       </method>
+                       <method name="append_text_column" symbol="hildon_touch_selector_append_text_column">
+                               <return-type type="HildonTouchSelectorColumn*"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="model" type="GtkTreeModel*"/>
+                                       <parameter name="center" type="gboolean"/>
+                               </parameters>
+                       </method>
+                       <method name="center_on_selected" symbol="hildon_touch_selector_center_on_selected">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_active" symbol="hildon_touch_selector_get_active">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="get_column" symbol="hildon_touch_selector_get_column">
+                               <return-type type="HildonTouchSelectorColumn*"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="get_column_selection_mode" symbol="hildon_touch_selector_get_column_selection_mode">
+                               <return-type type="HildonTouchSelectorSelectionMode"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_current_text" symbol="hildon_touch_selector_get_current_text">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_hildon_ui_mode" symbol="hildon_touch_selector_get_hildon_ui_mode">
+                               <return-type type="HildonUIMode"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_last_activated_row" symbol="hildon_touch_selector_get_last_activated_row">
+                               <return-type type="GtkTreePath*"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                               </parameters>
+                       </method>
+                       <method name="get_model" symbol="hildon_touch_selector_get_model">
+                               <return-type type="GtkTreeModel*"/>
                                <parameters>
-                                       <parameter name="dialog" type="HildonSortDialog*"/>
-                                       <parameter name="sort_key" type="gchar*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
                                </parameters>
                        </method>
-                       <method name="get_sort_key" symbol="hildon_sort_dialog_get_sort_key">
+                       <method name="get_num_columns" symbol="hildon_touch_selector_get_num_columns">
                                <return-type type="gint"/>
                                <parameters>
-                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
                                </parameters>
                        </method>
-                       <method name="get_sort_order" symbol="hildon_sort_dialog_get_sort_order">
-                               <return-type type="GtkSortType"/>
+                       <method name="get_print_func" symbol="hildon_touch_selector_get_print_func">
+                               <return-type type="HildonTouchSelectorPrintFunc"/>
                                <parameters>
-                                       <parameter name="dialog" type="HildonSortDialog*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
                                </parameters>
                        </method>
-                       <constructor name="new" symbol="hildon_sort_dialog_new">
-                               <return-type type="GtkWidget*"/>
+                       <method name="get_selected" symbol="hildon_touch_selector_get_selected">
+                               <return-type type="gboolean"/>
                                <parameters>
-                                       <parameter name="parent" type="GtkWindow*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="iter" type="GtkTreeIter*"/>
                                </parameters>
-                       </constructor>
-                       <method name="set_sort_key" symbol="hildon_sort_dialog_set_sort_key">
-                               <return-type type="void"/>
+                       </method>
+                       <method name="get_selected_rows" symbol="hildon_touch_selector_get_selected_rows">
+                               <return-type type="GList*"/>
                                <parameters>
-                                       <parameter name="dialog" type="HildonSortDialog*"/>
-                                       <parameter name="key" type="int"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
                                </parameters>
                        </method>
-                       <method name="set_sort_order" symbol="hildon_sort_dialog_set_sort_order">
+                       <method name="insert_text" symbol="hildon_touch_selector_insert_text">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="dialog" type="HildonSortDialog*"/>
-                                       <parameter name="order" type="GtkSortType"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="position" type="gint"/>
+                                       <parameter name="text" type="gchar*"/>
                                </parameters>
                        </method>
-                       <property name="sort-key" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="sort-order" type="GtkSortType" readable="1" writable="1" construct="0" construct-only="0"/>
-               </object>
-               <object name="HildonTimeEditor" parent="GtkContainer" type-name="HildonTimeEditor" get-type="hildon_time_editor_get_type">
-                       <implements>
-                               <interface name="AtkImplementor"/>
-                               <interface name="GtkBuildable"/>
-                       </implements>
-                       <method name="get_duration_max" symbol="hildon_time_editor_get_duration_max">
-                               <return-type type="guint"/>
+                       <constructor name="new" symbol="hildon_touch_selector_new">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <constructor name="new_text" symbol="hildon_touch_selector_new_text">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="optimal_size_request" symbol="hildon_touch_selector_optimal_size_request">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="requisition" type="GtkRequisition*"/>
                                </parameters>
                        </method>
-                       <method name="get_duration_min" symbol="hildon_time_editor_get_duration_min">
-                               <return-type type="guint"/>
+                       <method name="prepend_text" symbol="hildon_touch_selector_prepend_text">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="text" type="gchar*"/>
                                </parameters>
                        </method>
-                       <method name="get_duration_mode" symbol="hildon_time_editor_get_duration_mode">
+                       <method name="remove_column" symbol="hildon_touch_selector_remove_column">
                                <return-type type="gboolean"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
                                </parameters>
                        </method>
-                       <method name="get_duration_range" symbol="hildon_time_editor_get_duration_range">
+                       <method name="select_iter" symbol="hildon_touch_selector_select_iter">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="min_seconds" type="guint*"/>
-                                       <parameter name="max_seconds" type="guint*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="iter" type="GtkTreeIter*"/>
+                                       <parameter name="scroll_to" type="gboolean"/>
                                </parameters>
                        </method>
-                       <method name="get_show_hours" symbol="hildon_time_editor_get_show_hours">
-                               <return-type type="gboolean"/>
+                       <method name="set_active" symbol="hildon_touch_selector_set_active">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="index" type="gint"/>
                                </parameters>
                        </method>
-                       <method name="get_show_seconds" symbol="hildon_time_editor_get_show_seconds">
-                               <return-type type="gboolean"/>
+                       <method name="set_column_attributes" symbol="hildon_touch_selector_set_column_attributes">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="num_column" type="gint"/>
+                                       <parameter name="cell_renderer" type="GtkCellRenderer*"/>
                                </parameters>
                        </method>
-                       <method name="get_ticks" symbol="hildon_time_editor_get_ticks">
-                               <return-type type="guint"/>
+                       <method name="set_column_selection_mode" symbol="hildon_touch_selector_set_column_selection_mode">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="mode" type="HildonTouchSelectorSelectionMode"/>
                                </parameters>
                        </method>
-                       <method name="get_time" symbol="hildon_time_editor_get_time">
-                               <return-type type="void"/>
+                       <method name="set_hildon_ui_mode" symbol="hildon_touch_selector_set_hildon_ui_mode">
+                               <return-type type="gboolean"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="hours" type="guint*"/>
-                                       <parameter name="minutes" type="guint*"/>
-                                       <parameter name="seconds" type="guint*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="mode" type="HildonUIMode"/>
                                </parameters>
                        </method>
-                       <method name="get_time_separators" symbol="hildon_time_editor_get_time_separators">
+                       <method name="set_model" symbol="hildon_touch_selector_set_model">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="hm_sep_label" type="GtkLabel*"/>
-                                       <parameter name="ms_sep_label" type="GtkLabel*"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="model" type="GtkTreeModel*"/>
                                </parameters>
                        </method>
-                       <constructor name="new" symbol="hildon_time_editor_new">
-                               <return-type type="GtkWidget*"/>
-                       </constructor>
-                       <method name="set_duration_max" symbol="hildon_time_editor_set_duration_max">
+                       <method name="set_print_func" symbol="hildon_touch_selector_set_print_func">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="duration_max" type="guint"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="func" type="HildonTouchSelectorPrintFunc"/>
                                </parameters>
                        </method>
-                       <method name="set_duration_min" symbol="hildon_time_editor_set_duration_min">
+                       <method name="set_print_func_full" symbol="hildon_touch_selector_set_print_func_full">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="duration_min" type="guint"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="func" type="HildonTouchSelectorPrintFunc"/>
+                                       <parameter name="user_data" type="gpointer"/>
+                                       <parameter name="destroy_func" type="GDestroyNotify"/>
                                </parameters>
                        </method>
-                       <method name="set_duration_mode" symbol="hildon_time_editor_set_duration_mode">
+                       <method name="unselect_all" symbol="hildon_touch_selector_unselect_all">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="duration_mode" type="gboolean"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
                                </parameters>
                        </method>
-                       <method name="set_duration_range" symbol="hildon_time_editor_set_duration_range">
+                       <method name="unselect_iter" symbol="hildon_touch_selector_unselect_iter">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="min_seconds" type="guint"/>
-                                       <parameter name="max_seconds" type="guint"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="iter" type="GtkTreeIter*"/>
                                </parameters>
                        </method>
-                       <method name="set_show_hours" symbol="hildon_time_editor_set_show_hours">
+                       <property name="has-multiple-selection" type="gboolean" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="hildon-ui-mode" type="HildonUIMode" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <property name="initial-scroll" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
+                       <signal name="changed" when="LAST">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="show_hours" type="gboolean"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
                                </parameters>
-                       </method>
-                       <method name="set_show_seconds" symbol="hildon_time_editor_set_show_seconds">
+                       </signal>
+                       <signal name="columns-changed" when="LAST">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="show_seconds" type="gboolean"/>
+                                       <parameter name="object" type="HildonTouchSelector*"/>
                                </parameters>
-                       </method>
-                       <method name="set_ticks" symbol="hildon_time_editor_set_ticks">
+                       </signal>
+                       <vfunc name="set_model">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="ticks" type="guint"/>
+                                       <parameter name="selector" type="HildonTouchSelector*"/>
+                                       <parameter name="column" type="gint"/>
+                                       <parameter name="model" type="GtkTreeModel*"/>
                                </parameters>
-                       </method>
-                       <method name="set_time" symbol="hildon_time_editor_set_time">
-                               <return-type type="void"/>
+                       </vfunc>
+               </object>
+               <object name="HildonTouchSelectorColumn" parent="GObject" type-name="HildonTouchSelectorColumn" get-type="hildon_touch_selector_column_get_type">
+                       <implements>
+                               <interface name="GtkCellLayout"/>
+                       </implements>
+                       <method name="get_text_column" symbol="hildon_touch_selector_column_get_text_column">
+                               <return-type type="gint"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="hours" type="guint"/>
-                                       <parameter name="minutes" type="guint"/>
-                                       <parameter name="seconds" type="guint"/>
+                                       <parameter name="column" type="HildonTouchSelectorColumn*"/>
                                </parameters>
                        </method>
-                       <property name="duration-max" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="duration-min" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="duration-mode" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="show-hours" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="show-seconds" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <property name="ticks" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
-                       <signal name="time-error" when="LAST">
-                               <return-type type="gboolean"/>
+                       <method name="set_text_column" symbol="hildon_touch_selector_column_set_text_column">
+                               <return-type type="void"/>
                                <parameters>
-                                       <parameter name="editor" type="HildonTimeEditor*"/>
-                                       <parameter name="type" type="HildonDateTimeError"/>
+                                       <parameter name="column" type="HildonTouchSelectorColumn*"/>
+                                       <parameter name="text_column" type="gint"/>
                                </parameters>
-                       </signal>
+                       </method>
+                       <property name="text-column" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
                </object>
-               <object name="HildonTimePicker" parent="GtkDialog" type-name="HildonTimePicker" get-type="hildon_time_picker_get_type">
+               <object name="HildonTouchSelectorEntry" parent="HildonTouchSelector" type-name="HildonTouchSelectorEntry" get-type="hildon_touch_selector_entry_get_type">
                        <implements>
                                <interface name="AtkImplementor"/>
                                <interface name="GtkBuildable"/>
                        </implements>
-                       <method name="get_time" symbol="hildon_time_picker_get_time">
-                               <return-type type="void"/>
+                       <method name="get_entry" symbol="hildon_touch_selector_entry_get_entry">
+                               <return-type type="HildonEntry*"/>
                                <parameters>
-                                       <parameter name="picker" type="HildonTimePicker*"/>
-                                       <parameter name="hours" type="guint*"/>
-                                       <parameter name="minutes" type="guint*"/>
+                                       <parameter name="selector" type="HildonTouchSelectorEntry*"/>
                                </parameters>
                        </method>
-                       <constructor name="new" symbol="hildon_time_picker_new">
-                               <return-type type="GtkWidget*"/>
+                       <method name="get_input_mode" symbol="hildon_touch_selector_entry_get_input_mode">
+                               <return-type type="HildonGtkInputMode"/>
                                <parameters>
-                                       <parameter name="parent" type="GtkWindow*"/>
+                                       <parameter name="selector" type="HildonTouchSelectorEntry*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_text_column" symbol="hildon_touch_selector_entry_get_text_column">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelectorEntry*"/>
                                </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_touch_selector_entry_new">
+                               <return-type type="GtkWidget*"/>
                        </constructor>
-                       <method name="set_time" symbol="hildon_time_picker_set_time">
+                       <constructor name="new_text" symbol="hildon_touch_selector_entry_new_text">
+                               <return-type type="GtkWidget*"/>
+                       </constructor>
+                       <method name="set_input_mode" symbol="hildon_touch_selector_entry_set_input_mode">
                                <return-type type="void"/>
                                <parameters>
-                                       <parameter name="picker" type="HildonTimePicker*"/>
-                                       <parameter name="hours" type="guint"/>
-                                       <parameter name="minutes" type="guint"/>
+                                       <parameter name="selector" type="HildonTouchSelectorEntry*"/>
+                                       <parameter name="input_mode" type="HildonGtkInputMode"/>
                                </parameters>
                        </method>
-                       <property name="minutes" type="guint" readable="1" writable="1" construct="0" construct-only="0"/>
+                       <method name="set_text_column" symbol="hildon_touch_selector_entry_set_text_column">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="selector" type="HildonTouchSelectorEntry*"/>
+                                       <parameter name="text_column" type="gint"/>
+                               </parameters>
+                       </method>
+                       <property name="text-column" type="gint" readable="1" writable="1" construct="0" construct-only="0"/>
                </object>
                <object name="HildonVVolumebar" parent="HildonVolumebar" type-name="HildonVVolumebar" get-type="hildon_vvolumebar_get_type">
                        <implements>
                                        <parameter name="format" type="gchar*"/>
                                </parameters>
                        </method>
-                       <property name="can-focus" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
                        <property name="has-mute" type="gboolean" readable="1" writable="1" construct="1" construct-only="0"/>
                        <property name="level" type="gdouble" readable="1" writable="1" construct="0" construct-only="0"/>
                        <property name="mute" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
                                        <parameter name="child" type="GtkWidget*"/>
                                </parameters>
                        </method>
+                       <method name="get_app_menu" symbol="hildon_window_get_app_menu">
+                               <return-type type="HildonAppMenu*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                               </parameters>
+                       </method>
                        <method name="get_is_topmost" symbol="hildon_window_get_is_topmost">
                                <return-type type="gboolean"/>
                                <parameters>
                                        <parameter name="self" type="HildonWindow*"/>
                                </parameters>
                        </method>
+                       <method name="get_main_menu" symbol="hildon_window_get_main_menu">
+                               <return-type type="GtkMenu*"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="get_markup" symbol="hildon_window_get_markup">
+                               <return-type type="gchar*"/>
+                               <parameters>
+                                       <parameter name="window" type="HildonWindow*"/>
+                               </parameters>
+                       </method>
                        <method name="get_menu" symbol="hildon_window_get_menu">
                                <return-type type="GtkMenu*"/>
                                <parameters>
                                        <parameter name="toolbar" type="GtkToolbar*"/>
                                </parameters>
                        </method>
+                       <method name="set_app_menu" symbol="hildon_window_set_app_menu">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                                       <parameter name="menu" type="HildonAppMenu*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_edit_toolbar" symbol="hildon_window_set_edit_toolbar">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                                       <parameter name="toolbar" type="HildonEditToolbar*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_main_menu" symbol="hildon_window_set_main_menu">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                                       <parameter name="menu" type="GtkMenu*"/>
+                               </parameters>
+                       </method>
+                       <method name="set_markup" symbol="hildon_window_set_markup">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="window" type="HildonWindow*"/>
+                                       <parameter name="markup" type="gchar*"/>
+                               </parameters>
+                       </method>
                        <method name="set_menu" symbol="hildon_window_set_menu">
                                <return-type type="void"/>
                                <parameters>
                                </parameters>
                        </method>
                        <property name="is-topmost" type="gboolean" readable="1" writable="0" construct="0" construct-only="0"/>
+                       <property name="markup" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
                        <signal name="clipboard-operation" when="FIRST">
                                <return-type type="void"/>
                                <parameters>
                                        <parameter name="operation" type="gint"/>
                                </parameters>
                        </signal>
+                       <vfunc name="toggle_menu">
+                               <return-type type="gboolean"/>
+                               <parameters>
+                                       <parameter name="self" type="HildonWindow*"/>
+                                       <parameter name="button" type="guint"/>
+                                       <parameter name="time" type="guint32"/>
+                               </parameters>
+                       </vfunc>
+               </object>
+               <object name="HildonWindowStack" parent="GObject" type-name="HildonWindowStack" get-type="hildon_window_stack_get_type">
+                       <method name="get_default" symbol="hildon_window_stack_get_default">
+                               <return-type type="HildonWindowStack*"/>
+                       </method>
+                       <method name="get_windows" symbol="hildon_window_stack_get_windows">
+                               <return-type type="GList*"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                               </parameters>
+                       </method>
+                       <constructor name="new" symbol="hildon_window_stack_new">
+                               <return-type type="HildonWindowStack*"/>
+                       </constructor>
+                       <method name="peek" symbol="hildon_window_stack_peek">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                               </parameters>
+                       </method>
+                       <method name="pop" symbol="hildon_window_stack_pop">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="nwindows" type="gint"/>
+                                       <parameter name="popped_windows" type="GList**"/>
+                               </parameters>
+                       </method>
+                       <method name="pop_1" symbol="hildon_window_stack_pop_1">
+                               <return-type type="GtkWidget*"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                               </parameters>
+                       </method>
+                       <method name="pop_and_push" symbol="hildon_window_stack_pop_and_push">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="nwindows" type="gint"/>
+                                       <parameter name="popped_windows" type="GList**"/>
+                                       <parameter name="win1" type="HildonStackableWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="pop_and_push_list" symbol="hildon_window_stack_pop_and_push_list">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="nwindows" type="gint"/>
+                                       <parameter name="popped_windows" type="GList**"/>
+                                       <parameter name="list" type="GList*"/>
+                               </parameters>
+                       </method>
+                       <method name="push" symbol="hildon_window_stack_push">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="win1" type="HildonStackableWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="push_1" symbol="hildon_window_stack_push_1">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="win" type="HildonStackableWindow*"/>
+                               </parameters>
+                       </method>
+                       <method name="push_list" symbol="hildon_window_stack_push_list">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                                       <parameter name="list" type="GList*"/>
+                               </parameters>
+                       </method>
+                       <method name="size" symbol="hildon_window_stack_size">
+                               <return-type type="gint"/>
+                               <parameters>
+                                       <parameter name="stack" type="HildonWindowStack*"/>
+                               </parameters>
+                       </method>
+                       <property name="window-group" type="GtkWindowGroup*" readable="1" writable="1" construct="0" construct-only="1"/>
                </object>
                <object name="HildonWizardDialog" parent="GtkDialog" type-name="HildonWizardDialog" get-type="hildon_wizard_dialog_get_type">
                        <implements>
                                        <parameter name="notebook" type="GtkNotebook*"/>
                                </parameters>
                        </constructor>
+                       <method name="set_forward_page_func" symbol="hildon_wizard_dialog_set_forward_page_func">
+                               <return-type type="void"/>
+                               <parameters>
+                                       <parameter name="wizard_dialog" type="HildonWizardDialog*"/>
+                                       <parameter name="page_func" type="HildonWizardDialogPageFunc"/>
+                                       <parameter name="data" type="gpointer"/>
+                                       <parameter name="destroy" type="GDestroyNotify"/>
+                               </parameters>
+                       </method>
                        <property name="autotitle" type="gboolean" readable="1" writable="1" construct="0" construct-only="0"/>
                        <property name="wizard-name" type="char*" readable="1" writable="1" construct="0" construct-only="0"/>
                        <property name="wizard-notebook" type="GtkNotebook*" readable="1" writable="1" construct="0" construct-only="0"/>
                                </parameters>
                        </vfunc>
                </interface>
-               <constant name="HILDON_MAJOR_VERSION" type="int" value="1"/>
-               <constant name="HILDON_MARGIN_DEFAULT" type="int" value="6"/>
-               <constant name="HILDON_MARGIN_DOUBLE" type="int" value="12"/>
-               <constant name="HILDON_MARGIN_HALF" type="int" value="3"/>
-               <constant name="HILDON_MARGIN_TRIPLE" type="int" value="18"/>
-               <constant name="HILDON_MICRO_VERSION" type="int" value="0"/>
-               <constant name="HILDON_MINOR_VERSION" type="int" value="99"/>
+               <constant name="HILDON_AA_CENTER_GRAVITY" type="int" value="9"/>
+               <constant name="HILDON_AA_E_GRAVITY" type="int" value="3"/>
+               <constant name="HILDON_AA_NE_GRAVITY" type="int" value="2"/>
+               <constant name="HILDON_AA_NW_GRAVITY" type="int" value="8"/>
+               <constant name="HILDON_AA_N_GRAVITY" type="int" value="1"/>
+               <constant name="HILDON_AA_SE_GRAVITY" type="int" value="4"/>
+               <constant name="HILDON_AA_SW_GRAVITY" type="int" value="6"/>
+               <constant name="HILDON_AA_S_GRAVITY" type="int" value="5"/>
+               <constant name="HILDON_AA_W_GRAVITY" type="int" value="7"/>
+               <constant name="HILDON_AA_X_AXIS" type="int" value="0"/>
+               <constant name="HILDON_AA_Y_AXIS" type="int" value="1"/>
+               <constant name="HILDON_AA_Z_AXIS" type="int" value="2"/>
+               <constant name="HILDON_MAJOR_VERSION" type="int" value="2"/>
+               <constant name="HILDON_MARGIN_DEFAULT" type="int" value="8"/>
+               <constant name="HILDON_MARGIN_DOUBLE" type="int" value="16"/>
+               <constant name="HILDON_MARGIN_HALF" type="int" value="4"/>
+               <constant name="HILDON_MARGIN_TRIPLE" type="int" value="24"/>
+               <constant name="HILDON_MICRO_VERSION" type="int" value="86"/>
+               <constant name="HILDON_MINOR_VERSION" type="int" value="1"/>
                <constant name="HILDON_WINDOW_LONG_PRESS_TIME" type="int" value="800"/>
+               <constant name="HILDON_WINDOW_TITLEBAR_HEIGHT" type="int" value="56"/>
        </namespace>
 </api>
index 9db768056b532684c3ded5b6fea81c51fba1efaa..769db75f815cdcbb734c0917215a6ac84e204797 100644 (file)
@@ -1,4 +1,6 @@
 Hildon cprefix="Hildon" lower_case_cprefix="hildon_" cheader_filename="hildon/hildon.h"
+hildon_banner_show_information.icon_name nullable="1"
+hildon_banner_show_information_with_markup.icon_name nullable="1"
 hildon_color_button_get_color.color is_out="1"
 hildon_color_chooser_get_color.color is_out="1"
 hildon_color_chooser_dialog_get_color.color is_out="1"