git.maemo.org Git - beifahrer/blob - vapi/hildon-1.vapi

   1 /* hildon-1.vapi generated by vapigen, do not modify. */
   2
   3 [CCode (cprefix = "Hildon", lower_case_cprefix = "hildon_")]
   4 namespace Hildon {
   5         [CCode (cheader_filename = "hildon/hildon.h")]
   6         public class AnimationActor : Gtk.Window, Atk.Implementor, Gtk.Buildable {
   7                 [CCode (type = "GtkWidget*", has_construct_function = false)]
   8                 public AnimationActor ();
   9                 public void send_message (uint32 message_type, uint32 l0, uint32 l1, uint32 l2, uint32 l3, uint32 l4);
  10                 public void set_anchor (int x, int y);
  11                 public void set_anchor_from_gravity (uint gravity);
  12                 public void set_depth (int depth);
  13                 public void set_opacity (int opacity);
  14                 public void set_parent (Gtk.Window parent);
  15                 public void set_position (int x, int y);
  16                 public void set_position_full (int x, int y, int depth);
  17                 public void set_rotation (int axis, double degrees, int x, int y, int z);
  18                 public void set_rotationx (int axis, int32 degrees, int x, int y, int z);
  19                 public void set_scale (double x_scale, double y_scale);
  20                 public void set_scalex (int32 x_scale, int32 y_scale);
  21                 public void set_show (int show);
  22                 public void set_show_full (int show, int opacity);
  23         }
  24         [CCode (cheader_filename = "hildon/hildon.h")]
  25         public class AppMenu : Gtk.Window, Atk.Implementor, Gtk.Buildable {
  26                 [CCode (type = "GtkWidget*", has_construct_function = false)]
  27                 public AppMenu ();
  28                 public void add_filter (Gtk.Button filter);
  29                 public void append (Gtk.Button item);
  30                 public unowned GLib.List get_filters ();
  31                 public unowned GLib.List get_items ();
  32                 public void insert (Gtk.Button item, int position);
  33                 public void popup (Gtk.Window parent_window);
  34                 public void prepend (Gtk.Button item);
  35                 public void reorder_child (Gtk.Button item, int position);
  36         }
  37         [CCode (cheader_filename = "hildon/hildon.h")]
  38         public class Banner : Gtk.Window, Atk.Implementor, Gtk.Buildable {
  39                 public void set_fraction (double fraction);
  40                 public void set_icon (string icon_name);
  41                 public void set_icon_from_file (string icon_file);
  42                 public void set_markup (string markup);
  43                 public void set_text (string text);
  44                 public void set_timeout (uint timeout);
  45                 public static unowned Gtk.Widget show_animation (Gtk.Widget? widget, string animation_name, string text);
  46                 public static unowned Gtk.Widget show_information (Gtk.Widget? widget, string? icon_name, string text);
  47                 public static unowned Gtk.Widget show_information_override_dnd (Gtk.Widget? widget, string text);
  48                 public static unowned Gtk.Widget show_information_with_markup (Gtk.Widget? widget, string? icon_name, string markup);
  49                 public static unowned Gtk.Widget show_informationf (Gtk.Widget? widget, string icon_name, string format);
  50                 public static unowned Gtk.Widget show_progress (Gtk.Widget? widget, Gtk.ProgressBar bar, string text);
  51                 [NoAccessorMethod]
  52                 public bool is_timed { get; construct; }
  53                 [NoAccessorMethod]
  54                 public Gtk.Window parent_window { owned get; construct; }
  55                 [NoAccessorMethod]
  56                 public uint timeout { get; construct; }
  57         }
  58         [CCode (cheader_filename = "hildon/hildon.h")]
  59         public class BreadCrumbTrail : Gtk.Container, Atk.Implementor, Gtk.Buildable {
  60                 [CCode (type = "GtkWidget*", has_construct_function = false)]
  61                 public BreadCrumbTrail ();
  62                 public void clear ();
  63                 public void pop ();
  64                 public void push (Hildon.BreadCrumb item, void* id, GLib.DestroyNotify destroy);
  65                 public void push_icon (string text, Gtk.Widget icon, void* id, GLib.DestroyNotify destroy);
  66                 public void push_text (string text, void* id, GLib.DestroyNotify destroy);
  67                 public virtual signal bool crumb_clicked (void* id);
  68                 public virtual signal void move_parent ();
  69         }
  70         [CCode (cheader_filename = "hildon/hildon.h")]
  71         public class Button : Gtk.Button, Atk.Implementor, Gtk.Buildable {
  72                 [CCode (type = "GtkWidget*", has_construct_function = false)]
  73                 public Button (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
  74                 public void add_image_size_group (Gtk.SizeGroup size_group);
  75                 public void add_size_groups (Gtk.SizeGroup title_size_group, Gtk.SizeGroup value_size_group, Gtk.SizeGroup image_size_group);
  76                 public void add_title_size_group (Gtk.SizeGroup size_group);
  77                 public void add_value_size_group (Gtk.SizeGroup size_group);
  78                 public unowned Gtk.Widget get_image ();
  79                 public Hildon.ButtonStyle get_style ();
  80                 public unowned string get_title ();
  81                 public unowned string get_value ();
  82                 public void set_alignment (float xalign, float yalign, float xscale, float yscale);
  83                 public void set_image (Gtk.Widget image);
  84                 public void set_image_alignment (float xalign, float yalign);
  85                 public void set_image_position (Gtk.PositionType position);
  86                 public void set_style (Hildon.ButtonStyle style);
  87                 public void set_text (string title, string value);
  88                 public void set_title (string title);
  89                 public void set_title_alignment (float xalign, float yalign);
  90                 public void set_value (string value);
  91                 public void set_value_alignment (float xalign, float yalign);
  92                 [CCode (type = "GtkWidget*", has_construct_function = false)]
  93                 public Button.with_text (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, string title, string value);
  94                 public Hildon.ButtonArrangement arrangement { construct; }
  95                 public Hildon.SizeType size { construct; }
  96                 public Hildon.ButtonStyle style { get; set; }
  97                 public string title { get; set; }
  98                 public string value { get; set; }
  99         }
 100         [CCode (cheader_filename = "hildon/hildon.h")]
 101         public class Calendar : Gtk.Widget, Atk.Implementor, Gtk.Buildable {
 102                 [CCode (array_length = false)]
 103                 public weak int[] day_month;
 104                 public Hildon.CalendarDisplayOptions display_flags;
 105                 public int focus_col;
 106                 public int focus_row;
 107                 public weak Gdk.GC gc;
 108                 [CCode (array_length = false)]
 109                 public weak char[] grow_space;
 110                 public weak Gtk.Style header_style;
 111                 public int highlight_col;
 112                 public int highlight_row;
 113                 public weak Gtk.Style label_style;
 114                 [CCode (array_length = false)]
 115                 public weak int[] marked_date;
 116                 [CCode (array_length = false)]
 117                 public weak Gdk.Color[] marked_date_color;
 118                 public int num_marked_dates;
 119                 public int selected_day;
 120                 public weak Gdk.GC xor_gc;
 121                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 122                 public Calendar ();
 123                 public void clear_marks ();
 124                 public void freeze ();
 125                 public void get_date (uint year, uint month, uint day);
 126                 public Hildon.CalendarDisplayOptions get_display_options ();
 127                 public bool mark_day (uint day);
 128                 public void select_day (uint day);
 129                 public bool select_month (uint month, uint year);
 130                 public void set_display_options (Hildon.CalendarDisplayOptions flags);
 131                 public void thaw ();
 132                 public bool unmark_day (uint day);
 133                 [NoAccessorMethod]
 134                 public int day { get; set; }
 135                 [NoAccessorMethod]
 136                 public int max_year { get; set; }
 137                 [NoAccessorMethod]
 138                 public int min_year { get; set; }
 139                 [NoAccessorMethod]
 140                 public int month { get; set; }
 141                 [NoAccessorMethod]
 142                 public bool no_month_change { get; set; }
 143                 [NoAccessorMethod]
 144                 public bool show_day_names { get; set; }
 145                 [NoAccessorMethod]
 146                 public bool show_heading { get; set; }
 147                 [NoAccessorMethod]
 148                 public bool show_week_numbers { get; set; }
 149                 [NoAccessorMethod]
 150                 public int week_start { get; set; }
 151                 [NoAccessorMethod]
 152                 public int year { get; set; }
 153                 public virtual signal void day_selected ();
 154                 public virtual signal void day_selected_double_click ();
 155                 public virtual signal void erroneous_date ();
 156                 public virtual signal void month_changed ();
 157                 public virtual signal void next_month ();
 158                 public virtual signal void next_year ();
 159                 public virtual signal void prev_month ();
 160                 public virtual signal void prev_year ();
 161                 public virtual signal void selected_date ();
 162         }
 163         [CCode (cheader_filename = "hildon/hildon.h")]
 164         public class CalendarPopup : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 165                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 166                 public CalendarPopup (Gtk.Window parent, uint year, uint month, uint day);
 167                 public void get_date (uint year, uint month, uint day);
 168                 public void set_date (uint year, uint month, uint day);
 169                 [NoAccessorMethod]
 170                 public int day { get; set; }
 171                 [NoAccessorMethod]
 172                 public uint max_year { set; }
 173                 [NoAccessorMethod]
 174                 public uint min_year { set; }
 175                 [NoAccessorMethod]
 176                 public int month { get; set; }
 177                 [NoAccessorMethod]
 178                 public int year { get; set; }
 179         }
 180         [CCode (cheader_filename = "hildon/hildon.h")]
 181         public class Caption : Gtk.EventBox, Atk.Implementor, Gtk.Buildable {
 182                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 183                 public Caption (Gtk.SizeGroup group, string value, Gtk.Widget control, Gtk.Widget icon, Hildon.CaptionStatus flag);
 184                 public bool get_child_expand ();
 185                 public unowned Gtk.Widget get_icon_image ();
 186                 public Hildon.CaptionIconPosition get_icon_position ();
 187                 public unowned string get_label ();
 188                 public float get_label_alignment ();
 189                 public unowned string get_separator ();
 190                 public unowned Gtk.SizeGroup get_size_group ();
 191                 public Hildon.CaptionStatus get_status ();
 192                 public bool is_mandatory ();
 193                 public void set_child_expand (bool expand);
 194                 public void set_icon_image (Gtk.Widget icon);
 195                 public void set_icon_position (Hildon.CaptionIconPosition pos);
 196                 public void set_label (string label);
 197                 public void set_label_alignment (float alignment);
 198                 public void set_label_markup (string markup);
 199                 public void set_separator (string separator);
 200                 public void set_size_group (Gtk.SizeGroup new_group);
 201                 public void set_status (Hildon.CaptionStatus flag);
 202                 [NoAccessorMethod]
 203                 public Gtk.Widget icon { owned get; set; }
 204                 public Hildon.CaptionIconPosition icon_position { get; set; }
 205                 public string label { get; set; }
 206                 [NoAccessorMethod]
 207                 public string markup { set; }
 208                 public string separator { get; set; }
 209                 public Gtk.SizeGroup size_group { get; set; }
 210                 public Hildon.CaptionStatus status { get; set; }
 211                 public virtual signal void activate ();
 212         }
 213         [CCode (cheader_filename = "hildon/hildon.h")]
 214         public class CheckButton : Gtk.Button, Atk.Implementor, Gtk.Buildable {
 215                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 216                 public CheckButton (Hildon.SizeType size);
 217                 public bool get_active ();
 218                 public void set_active (bool is_active);
 219                 [NoAccessorMethod]
 220                 public Hildon.SizeType size { set; }
 221                 public virtual signal void toggled ();
 222         }
 223         [CCode (cheader_filename = "hildon/hildon.h")]
 224         public class CodeDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 225                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 226                 public CodeDialog ();
 227                 public void clear_code ();
 228                 public unowned string get_code ();
 229                 public void set_help_text (string text);
 230                 public void set_input_sensitive (bool sensitive);
 231                 public virtual signal void input ();
 232         }
 233         [CCode (cheader_filename = "hildon/hildon.h")]
 234         public class ColorButton : Gtk.Button, Atk.Implementor, Gtk.Buildable {
 235                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 236                 public ColorButton ();
 237                 public void get_color (out Gdk.Color color);
 238                 public bool get_popup_shown ();
 239                 public void popdown ();
 240                 public void set_color (Gdk.Color color);
 241                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 242                 public ColorButton.with_color (Gdk.Color color);
 243                 public Gdk.Color color { get; set; }
 244                 public bool popup_shown { get; }
 245                 public virtual signal void setup_dialog (Hildon.ColorChooserDialog p0);
 246         }
 247         [CCode (cheader_filename = "hildon/hildon.h")]
 248         public class ColorChooser : Gtk.Widget, Atk.Implementor, Gtk.Buildable {
 249                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 250                 public ColorChooser ();
 251                 public void get_color (out Gdk.Color color);
 252                 public virtual void set_color (Gdk.Color color);
 253                 public Gdk.Color color { get; set; }
 254                 public virtual signal void color_changed ();
 255         }
 256         [CCode (cheader_filename = "hildon/hildon.h")]
 257         public class ColorChooserDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 258                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 259                 public ColorChooserDialog ();
 260                 public void get_color (out Gdk.Color color);
 261                 public void set_color (Gdk.Color color);
 262         }
 263         [CCode (cheader_filename = "hildon/hildon.h")]
 264         public class Controlbar : Gtk.Scale, Atk.Implementor, Gtk.Buildable {
 265                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 266                 public Controlbar ();
 267                 public int get_max ();
 268                 public int get_min ();
 269                 public int get_value ();
 270                 public void set_max (int max);
 271                 public void set_min (int min);
 272                 public void set_range (int min, int max);
 273                 public void set_value (int value);
 274                 public int max { get; set; }
 275                 public int min { get; set; }
 276                 public int value { get; set; }
 277                 public virtual signal void end_reached (bool end);
 278         }
 279         [CCode (cheader_filename = "hildon/hildon.h")]
 280         public class DateButton : Hildon.PickerButton, Atk.Implementor, Gtk.Buildable {
 281                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 282                 public DateButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
 283                 public void get_date (out uint year, out uint month, out uint day);
 284                 public void set_date (uint year, uint month, uint day);
 285                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 286                 public DateButton.with_year_range (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, int min_year, int max_year);
 287         }
 288         [CCode (cheader_filename = "hildon/hildon.h")]
 289         public class DateEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 290                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 291                 public DateEditor ();
 292                 public void get_date (uint year, uint month, uint day);
 293                 public uint get_day ();
 294                 public uint get_month ();
 295                 public uint get_year ();
 296                 public void set_date (uint year, uint month, uint day);
 297                 public bool set_day (uint day);
 298                 public bool set_month (uint month);
 299                 public bool set_year (uint year);
 300                 public uint day { get; set; }
 301                 [NoAccessorMethod]
 302                 public uint max_year { get; set; }
 303                 [NoAccessorMethod]
 304                 public uint min_year { get; set; }
 305                 public uint month { get; set; }
 306                 public uint year { get; set; }
 307                 public virtual signal bool date_error (Hildon.DateTimeError type);
 308         }
 309         [CCode (cheader_filename = "hildon/hildon.h")]
 310         public class DateSelector : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
 311                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 312                 public DateSelector ();
 313                 public void get_date (uint year, uint month, uint day);
 314                 public bool select_current_date (uint year, uint month, uint day);
 315                 public void select_day (uint day);
 316                 public bool select_month (uint month, uint year);
 317                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 318                 public DateSelector.with_year_range (int min_year, int max_year);
 319                 [NoAccessorMethod]
 320                 public int max_year { get; construct; }
 321                 [NoAccessorMethod]
 322                 public int min_year { get; construct; }
 323         }
 324         [CCode (cheader_filename = "hildon/hildon.h")]
 325         public class Dialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 326                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 327                 public Dialog ();
 328                 public unowned Gtk.Widget add_button (string button_text, int response_id);
 329                 public void add_buttons (...);
 330                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 331                 public Dialog.with_buttons (string title, Gtk.Window parent, Gtk.DialogFlags flags, ...);
 332         }
 333         [CCode (cheader_filename = "hildon/hildon.h")]
 334         public class EditToolbar : Gtk.HBox, Atk.Implementor, Gtk.Buildable {
 335                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 336                 public EditToolbar ();
 337                 public void set_button_label (string label);
 338                 public void set_label (string label);
 339                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 340                 public EditToolbar.with_text (string label, string button);
 341                 public virtual signal void arrow_clicked ();
 342                 public virtual signal void button_clicked ();
 343         }
 344         [CCode (cheader_filename = "hildon/hildon.h")]
 345         public class Entry : Gtk.Entry, Atk.Implementor, Gtk.Buildable, Gtk.Editable, Gtk.CellEditable {
 346                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 347                 public Entry (Hildon.SizeType size);
 348                 public unowned string get_text ();
 349                 public void set_placeholder (string text);
 350                 public void set_text (string text);
 351                 [NoAccessorMethod]
 352                 public Hildon.SizeType size { set construct; }
 353         }
 354         [CCode (cheader_filename = "hildon/hildon.h")]
 355         public class FindToolbar : Gtk.Toolbar, Atk.Implementor, Gtk.Buildable, Gtk.ToolShell {
 356                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 357                 public FindToolbar (string label);
 358                 public int get_active ();
 359                 public bool get_active_iter (out Gtk.TreeIter iter);
 360                 public int32 get_last_index ();
 361                 public void highlight_entry (bool get_focus);
 362                 public void set_active (int index);
 363                 public void set_active_iter (Gtk.TreeIter iter);
 364                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 365                 public FindToolbar.with_model (string label, Gtk.ListStore model, int column);
 366                 [NoAccessorMethod]
 367                 public int column { get; set; }
 368                 [NoAccessorMethod]
 369                 public int history_limit { get; set construct; }
 370                 [NoAccessorMethod]
 371                 public string label { owned get; set construct; }
 372                 [NoAccessorMethod]
 373                 public Gtk.ListStore list { owned get; set; }
 374                 [NoAccessorMethod]
 375                 public int max_characters { get; set construct; }
 376                 [NoAccessorMethod]
 377                 public string prefix { owned get; set; }
 378                 public virtual signal void close ();
 379                 public virtual signal bool history_append ();
 380                 public virtual signal void invalid_input ();
 381                 public virtual signal void search ();
 382         }
 383         [CCode (cheader_filename = "hildon/hildon.h")]
 384         public class FontSelectionDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 385                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 386                 public FontSelectionDialog (Gtk.Window parent, string title);
 387                 public unowned string get_preview_text ();
 388                 public void set_preview_text (string text);
 389                 [NoAccessorMethod]
 390                 public bool bold { get; set; }
 391                 [NoAccessorMethod]
 392                 public bool bold_set { get; set construct; }
 393                 [NoAccessorMethod]
 394                 public Gdk.Color color { get; set; }
 395                 [NoAccessorMethod]
 396                 public bool color_set { get; set construct; }
 397                 [NoAccessorMethod]
 398                 public string family { owned get; set; }
 399                 [NoAccessorMethod]
 400                 public bool family_set { get; set construct; }
 401                 [NoAccessorMethod]
 402                 public double font_scaling { get; set; }
 403                 [NoAccessorMethod]
 404                 public bool italic { get; set; }
 405                 [NoAccessorMethod]
 406                 public bool italic_set { get; set construct; }
 407                 [NoAccessorMethod]
 408                 public int position { get; set; }
 409                 [NoAccessorMethod]
 410                 public bool position_set { get; set construct; }
 411                 public string preview_text { get; set; }
 412                 [NoAccessorMethod]
 413                 public int size { get; set; }
 414                 [NoAccessorMethod]
 415                 public bool size_set { get; set construct; }
 416                 [NoAccessorMethod]
 417                 public bool strikethrough { get; set; }
 418                 [NoAccessorMethod]
 419                 public bool strikethrough_set { get; set construct; }
 420                 [NoAccessorMethod]
 421                 public bool underline { get; set; }
 422                 [NoAccessorMethod]
 423                 public bool underline_set { get; set construct; }
 424         }
 425         [CCode (cheader_filename = "hildon/hildon.h")]
 426         public class GetPasswordDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 427                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 428                 public GetPasswordDialog (Gtk.Window parent, bool get_old);
 429                 public unowned string get_password ();
 430                 public void set_caption (string new_caption);
 431                 public void set_max_characters (int max_characters);
 432                 public void set_message (string message);
 433                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 434                 public GetPasswordDialog.with_default (Gtk.Window parent, string password, bool get_old);
 435                 [NoAccessorMethod]
 436                 public string caption_label { owned get; set; }
 437                 [NoAccessorMethod]
 438                 public bool get_old { get; construct; }
 439                 [NoAccessorMethod]
 440                 public int max_characters { get; set; }
 441                 [NoAccessorMethod]
 442                 public string message { owned get; set; }
 443                 [NoAccessorMethod]
 444                 public bool numbers_only { get; set; }
 445                 [NoAccessorMethod]
 446                 public string password { owned get; set; }
 447         }
 448         [CCode (cheader_filename = "hildon/hildon.h")]
 449         public class HVolumebar : Hildon.Volumebar, Atk.Implementor, Gtk.Buildable {
 450                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 451                 public HVolumebar ();
 452         }
 453         [CCode (cheader_filename = "hildon/hildon.h")]
 454         public class LoginDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 455                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 456                 public LoginDialog (Gtk.Window parent);
 457                 public unowned string get_password ();
 458                 public unowned string get_username ();
 459                 public void set_message (string msg);
 460                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 461                 public LoginDialog.with_default (Gtk.Window parent, string name, string password);
 462                 [NoAccessorMethod]
 463                 public string message { owned get; set; }
 464                 [NoAccessorMethod]
 465                 public string password { owned get; set; }
 466                 [NoAccessorMethod]
 467                 public string username { owned get; set; }
 468         }
 469         [CCode (cheader_filename = "hildon/hildon.h")]
 470         public class Note : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 471                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 472                 public Note.cancel_with_progress_bar (Gtk.Window parent, string description, Gtk.ProgressBar progressbar);
 473                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 474                 public Note.confirmation (Gtk.Window parent, string description);
 475                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 476                 public Note.confirmation_add_buttons (Gtk.Window parent, string description);
 477                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 478                 public Note.confirmation_with_icon_name (Gtk.Window parent, string description, string icon_name);
 479                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 480                 public Note.information (Gtk.Window parent, string description);
 481                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 482                 public Note.information_with_icon_name (Gtk.Window parent, string description, string icon_name);
 483                 public void set_button_text (string text);
 484                 public void set_button_texts (string text_ok, string text_cancel);
 485                 [NoAccessorMethod]
 486                 public string description { owned get; set; }
 487                 [NoAccessorMethod]
 488                 public string icon { owned get; set; }
 489                 [NoAccessorMethod]
 490                 public Hildon.NoteType note_type { get; set construct; }
 491                 [NoAccessorMethod]
 492                 public Gtk.ProgressBar progressbar { owned get; set; }
 493                 [NoAccessorMethod]
 494                 public string stock_icon { owned get; set; }
 495         }
 496         [CCode (cheader_filename = "hildon/hildon.h")]
 497         public class NumberEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 498                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 499                 public NumberEditor (int min, int max);
 500                 public int get_value ();
 501                 public void set_range (int min, int max);
 502                 public void set_value (int value);
 503                 public int value { get; set; }
 504                 public virtual signal bool range_error (Hildon.NumberEditorErrorType type);
 505         }
 506         [CCode (cheader_filename = "hildon/hildon.h")]
 507         public class PannableArea : Gtk.Bin, Atk.Implementor, Gtk.Buildable {
 508                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 509                 public PannableArea ();
 510                 public void add_with_viewport (Gtk.Widget child);
 511                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 512                 public PannableArea.full (int mode, bool enabled, double vel_min, double vel_max, double decel, uint sps);
 513                 public unowned Gtk.Adjustment get_hadjustment ();
 514                 public Hildon.SizeRequestPolicy get_size_request_policy ();
 515                 public unowned Gtk.Adjustment get_vadjustment ();
 516                 public void jump_to (int x, int y);
 517                 public void jump_to_child (Gtk.Widget child);
 518                 public void scroll_to (int x, int y);
 519                 public void scroll_to_child (Gtk.Widget child);
 520                 public void set_size_request_policy (Hildon.SizeRequestPolicy size_request_policy);
 521                 [NoAccessorMethod]
 522                 public uint bounce_steps { get; set construct; }
 523                 [NoAccessorMethod]
 524                 public double deceleration { get; set construct; }
 525                 [NoAccessorMethod]
 526                 public uint direction_error_margin { get; set construct; }
 527                 [NoAccessorMethod]
 528                 public double drag_inertia { get; set construct; }
 529                 [NoAccessorMethod]
 530                 public bool enabled { get; set construct; }
 531                 [NoAccessorMethod]
 532                 public uint force { get; set construct; }
 533                 public Gtk.Adjustment hadjustment { get; }
 534                 [NoAccessorMethod]
 535                 public int hovershoot_max { get; set construct; }
 536                 [NoAccessorMethod]
 537                 public Gtk.PolicyType hscrollbar_policy { get; set construct; }
 538                 [NoAccessorMethod]
 539                 public bool initial_hint { get; set construct; }
 540                 [NoAccessorMethod]
 541                 public bool low_friction_mode { get; set construct; }
 542                 [NoAccessorMethod]
 543                 public Hildon.PannableAreaMode mode { get; set construct; }
 544                 [NoAccessorMethod]
 545                 public Hildon.MovementMode mov_mode { get; set construct; }
 546                 [NoAccessorMethod]
 547                 public uint panning_threshold { get; set construct; }
 548                 [NoAccessorMethod]
 549                 public double scroll_time { get; set construct; }
 550                 [NoAccessorMethod]
 551                 public uint scrollbar_fade_delay { get; set construct; }
 552                 public Hildon.SizeRequestPolicy size_request_policy { get; set construct; }
 553                 [NoAccessorMethod]
 554                 public uint sps { get; set construct; }
 555                 public Gtk.Adjustment vadjustment { get; }
 556                 [NoAccessorMethod]
 557                 public double velocity_fast_factor { get; set construct; }
 558                 [NoAccessorMethod]
 559                 public double velocity_max { get; set construct; }
 560                 [NoAccessorMethod]
 561                 public double velocity_min { get; set construct; }
 562                 [NoAccessorMethod]
 563                 public double velocity_overshooting_max { get; set construct; }
 564                 [NoAccessorMethod]
 565                 public int vovershoot_max { get; set construct; }
 566                 [NoAccessorMethod]
 567                 public Gtk.PolicyType vscrollbar_policy { get; set construct; }
 568                 public virtual signal void horizontal_movement (int direction, double x, double y);
 569                 public virtual signal void panning_finished ();
 570                 public virtual signal bool panning_started ();
 571                 public virtual signal void vertical_movement (int direction, double x, double y);
 572         }
 573         [CCode (cheader_filename = "hildon/hildon.h")]
 574         public class PickerButton : Hildon.Button, Atk.Implementor, Gtk.Buildable {
 575                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 576                 public PickerButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
 577                 public int get_active ();
 578                 public unowned string get_done_button_text ();
 579                 public unowned Hildon.TouchSelector get_selector ();
 580                 public void set_active (int index);
 581                 public void set_done_button_text (string done_button_text);
 582                 public void set_selector (Hildon.TouchSelector selector);
 583                 public string done_button_text { get; set; }
 584                 [NoAccessorMethod]
 585                 public Hildon.TouchSelector touch_selector { owned get; set; }
 586                 public virtual signal void value_changed ();
 587         }
 588         [CCode (cheader_filename = "hildon/hildon.h")]
 589         public class PickerDialog : Hildon.Dialog, Atk.Implementor, Gtk.Buildable {
 590                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 591                 public PickerDialog (Gtk.Window parent);
 592                 public unowned string get_done_label ();
 593                 public unowned Hildon.TouchSelector get_selector ();
 594                 public void set_done_label (string label);
 595                 public virtual bool set_selector (Hildon.TouchSelector selector);
 596                 [NoAccessorMethod]
 597                 public bool center_on_show { get; set construct; }
 598                 [NoAccessorMethod]
 599                 public string done_button_text { owned get; set construct; }
 600         }
 601         [CCode (cheader_filename = "hildon/hildon.h")]
 602         public class Program : GLib.Object {
 603                 public void add_window (Hildon.Window window);
 604                 public bool get_can_hibernate ();
 605                 public unowned Hildon.AppMenu get_common_app_menu ();
 606                 public unowned Gtk.Menu get_common_menu ();
 607                 public unowned Gtk.Toolbar get_common_toolbar ();
 608                 public static unowned Hildon.Program get_instance ();
 609                 public bool get_is_topmost ();
 610                 public void go_to_root_window ();
 611                 public unowned Hildon.StackableWindow peek_window_stack ();
 612                 public unowned Hildon.StackableWindow pop_window_stack ();
 613                 public void remove_window (Hildon.Window window);
 614                 public void set_can_hibernate (bool can_hibernate);
 615                 public void set_common_app_menu (Hildon.AppMenu menu);
 616                 public void set_common_menu (Gtk.Menu menu);
 617                 public void set_common_toolbar (Gtk.Toolbar toolbar);
 618                 public bool can_hibernate { get; set; }
 619                 public bool is_topmost { get; }
 620         }
 621         [CCode (cheader_filename = "hildon/hildon.h")]
 622         public class RangeEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 623                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 624                 public RangeEditor ();
 625                 public int get_higher ();
 626                 public int get_lower ();
 627                 public int get_max ();
 628                 public int get_min ();
 629                 public void get_range (int start, int end);
 630                 public unowned string get_separator ();
 631                 public void set_higher (int value);
 632                 public void set_limits (int start, int end);
 633                 public void set_lower (int value);
 634                 public void set_max (int value);
 635                 public void set_min (int value);
 636                 public void set_range (int start, int end);
 637                 public void set_separator (string separator);
 638                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 639                 public RangeEditor.with_separator (string separator);
 640                 public int higher { get; set construct; }
 641                 public int lower { get; set construct; }
 642                 public int max { get; set construct; }
 643                 public int min { get; set construct; }
 644                 public string separator { get; set construct; }
 645         }
 646         [CCode (cheader_filename = "hildon/hildon.h")]
 647         public class RemoteTexture : Gtk.Window, Atk.Implementor, Gtk.Buildable {
 648                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 649                 public RemoteTexture ();
 650                 public void send_message (uint32 message_type, uint32 l0, uint32 l1, uint32 l2, uint32 l3, uint32 l4);
 651                 public void set_image (uint32 key, uint width, uint height, uint bpp);
 652                 public void set_offset (double x, double y);
 653                 public void set_opacity (int opacity);
 654                 public void set_parent (Gtk.Window parent);
 655                 public void set_position (int x, int y, int width, int height);
 656                 public void set_scale (double x_scale, double y_scale);
 657                 public void set_show (int show);
 658                 public void set_show_full (int show, int opacity);
 659                 public void update_area (int x, int y, int width, int height);
 660         }
 661         [CCode (cheader_filename = "hildon/hildon.h")]
 662         public class Seekbar : Gtk.Scale, Atk.Implementor, Gtk.Buildable {
 663                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 664                 public Seekbar ();
 665                 public uint get_fraction ();
 666                 public int get_position ();
 667                 public int get_total_time ();
 668                 public void set_fraction (uint fraction);
 669                 public void set_position (int time);
 670                 public void set_total_time (int time);
 671                 public double fraction { get; set; }
 672                 public double position { get; set; }
 673                 public double total_time { get; set; }
 674         }
 675         [CCode (cheader_filename = "hildon/hildon.h")]
 676         public class SetPasswordDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 677                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 678                 public SetPasswordDialog (Gtk.Window parent, bool modify_protection);
 679                 public unowned string get_password ();
 680                 public bool get_protected ();
 681                 public void set_message (string message);
 682                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 683                 public SetPasswordDialog.with_default (Gtk.Window parent, string password, bool modify_protection);
 684                 [NoAccessorMethod]
 685                 public string message { owned get; set; }
 686                 [NoAccessorMethod]
 687                 public bool modify_protection { get; construct; }
 688                 [NoAccessorMethod]
 689                 public string password { owned get; set; }
 690         }
 691         [CCode (cheader_filename = "hildon/hildon.h")]
 692         public class SortDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 693                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 694                 public SortDialog (Gtk.Window parent);
 695                 public int add_sort_key (string sort_key);
 696                 public int add_sort_key_reversed (string sort_key);
 697                 public int get_sort_key ();
 698                 public Gtk.SortType get_sort_order ();
 699                 public void set_sort_key (int key);
 700                 public void set_sort_order (Gtk.SortType order);
 701                 public int sort_key { get; set; }
 702                 public Gtk.SortType sort_order { get; set; }
 703         }
 704         [CCode (cheader_filename = "hildon/hildon.h")]
 705         public class StackableWindow : Hildon.Window, Atk.Implementor, Gtk.Buildable {
 706                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 707                 public StackableWindow ();
 708                 public unowned Hildon.WindowStack get_stack ();
 709                 public void set_main_menu (Hildon.AppMenu menu);
 710         }
 711         [CCode (cheader_filename = "hildon/hildon.h")]
 712         public class TextView : Gtk.TextView, Atk.Implementor, Gtk.Buildable {
 713                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 714                 public TextView ();
 715                 public unowned Gtk.TextBuffer get_buffer ();
 716                 public void set_buffer (Gtk.TextBuffer buffer);
 717                 public void set_placeholder (string text);
 718         }
 719         [CCode (cheader_filename = "hildon/hildon.h")]
 720         public class TimeButton : Hildon.PickerButton, Atk.Implementor, Gtk.Buildable {
 721                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 722                 public TimeButton (Hildon.SizeType size, Hildon.ButtonArrangement arrangement);
 723                 public void get_time (uint hours, uint minutes);
 724                 public void set_time (uint hours, uint minutes);
 725                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 726                 public TimeButton.step (Hildon.SizeType size, Hildon.ButtonArrangement arrangement, uint minutes_step);
 727         }
 728         [CCode (cheader_filename = "hildon/hildon.h")]
 729         public class TimeEditor : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 730                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 731                 public TimeEditor ();
 732                 public uint get_duration_max ();
 733                 public uint get_duration_min ();
 734                 public bool get_duration_mode ();
 735                 public void get_duration_range (uint min_seconds, uint max_seconds);
 736                 public bool get_show_hours ();
 737                 public bool get_show_seconds ();
 738                 public uint get_ticks ();
 739                 public void get_time (uint hours, uint minutes, uint seconds);
 740                 public static void get_time_separators (Gtk.Label hm_sep_label, Gtk.Label ms_sep_label);
 741                 public void set_duration_max (uint duration_max);
 742                 public void set_duration_min (uint duration_min);
 743                 public void set_duration_mode (bool duration_mode);
 744                 public void set_duration_range (uint min_seconds, uint max_seconds);
 745                 public void set_show_hours (bool show_hours);
 746                 public void set_show_seconds (bool show_seconds);
 747                 public void set_ticks (uint ticks);
 748                 public void set_time (uint hours, uint minutes, uint seconds);
 749                 public uint duration_max { get; set; }
 750                 public uint duration_min { get; set; }
 751                 public bool duration_mode { get; set; }
 752                 public bool show_hours { get; set; }
 753                 public bool show_seconds { get; set; }
 754                 public uint ticks { get; set; }
 755                 public virtual signal bool time_error (Hildon.DateTimeError type);
 756         }
 757         [CCode (cheader_filename = "hildon/hildon.h")]
 758         public class TimePicker : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 759                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 760                 public TimePicker (Gtk.Window parent);
 761                 public void get_time (uint hours, uint minutes);
 762                 public void set_time (uint hours, uint minutes);
 763                 [NoAccessorMethod]
 764                 public uint minutes { get; set; }
 765         }
 766         [CCode (cheader_filename = "hildon/hildon.h")]
 767         public class TimeSelector : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
 768                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 769                 public TimeSelector ();
 770                 public void get_time (uint hours, uint minutes);
 771                 public bool set_time (uint hours, uint minutes);
 772                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 773                 public TimeSelector.step (uint minutes_step);
 774                 [NoAccessorMethod]
 775                 public uint minutes_step { get; construct; }
 776                 [NoAccessorMethod]
 777                 public Hildon.TimeSelectorFormatPolicy time_format_policy { get; set construct; }
 778         }
 779         [CCode (cheader_filename = "hildon/hildon.h")]
 780         public class TouchSelector : Gtk.VBox, Atk.Implementor, Gtk.Buildable {
 781                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 782                 public TouchSelector ();
 783                 public unowned Hildon.TouchSelectorColumn append_column (Gtk.TreeModel model, Gtk.CellRenderer cell_renderer);
 784                 public void append_text (string text);
 785                 public unowned Hildon.TouchSelectorColumn append_text_column (Gtk.TreeModel model, bool center);
 786                 public void center_on_selected ();
 787                 public int get_active (int column);
 788                 public unowned Hildon.TouchSelectorColumn get_column (int column);
 789                 public Hildon.TouchSelectorSelectionMode get_column_selection_mode ();
 790                 public unowned string get_current_text ();
 791                 public Hildon.UIMode get_hildon_ui_mode ();
 792                 public unowned Gtk.TreePath get_last_activated_row (int column);
 793                 public unowned Gtk.TreeModel get_model (int column);
 794                 public int get_num_columns ();
 795                 public unowned Hildon.TouchSelectorPrintFunc get_print_func ();
 796                 public bool get_selected (int column, Gtk.TreeIter iter);
 797                 public unowned GLib.List get_selected_rows (int column);
 798                 public void insert_text (int position, string text);
 799                 public void optimal_size_request (Gtk.Requisition requisition);
 800                 public void prepend_text (string text);
 801                 public bool remove_column (int column);
 802                 public void select_iter (int column, Gtk.TreeIter iter, bool scroll_to);
 803                 public void set_active (int column, int index);
 804                 public void set_column_attributes (int num_column, Gtk.CellRenderer cell_renderer);
 805                 public void set_column_selection_mode (Hildon.TouchSelectorSelectionMode mode);
 806                 public bool set_hildon_ui_mode (Hildon.UIMode mode);
 807                 public virtual void set_model (int column, Gtk.TreeModel model);
 808                 public void set_print_func (Hildon.TouchSelectorPrintFunc func);
 809                 public void set_print_func_full (Hildon.TouchSelectorPrintFunc func, GLib.DestroyNotify destroy_func);
 810                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 811                 public TouchSelector.text ();
 812                 public void unselect_all (int column);
 813                 public void unselect_iter (int column, Gtk.TreeIter iter);
 814                 [NoAccessorMethod]
 815                 public bool has_multiple_selection { get; }
 816                 public Hildon.UIMode hildon_ui_mode { get; set; }
 817                 [NoAccessorMethod]
 818                 public bool initial_scroll { get; set construct; }
 819                 public virtual signal void changed (int column);
 820                 public virtual signal void columns_changed ();
 821         }
 822         [CCode (cheader_filename = "hildon/hildon.h")]
 823         public class TouchSelectorColumn : GLib.Object, Gtk.CellLayout {
 824                 public int get_text_column ();
 825                 public void set_text_column (int text_column);
 826                 public int text_column { get; set; }
 827         }
 828         [CCode (cheader_filename = "hildon/hildon.h")]
 829         public class TouchSelectorEntry : Hildon.TouchSelector, Atk.Implementor, Gtk.Buildable {
 830                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 831                 public TouchSelectorEntry ();
 832                 public unowned Hildon.Entry get_entry ();
 833                 public Hildon.GtkInputMode get_input_mode ();
 834                 public int get_text_column ();
 835                 public void set_input_mode (Hildon.GtkInputMode input_mode);
 836                 public void set_text_column (int text_column);
 837                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 838                 public TouchSelectorEntry.text ();
 839                 public int text_column { get; set; }
 840         }
 841         [CCode (cheader_filename = "hildon/hildon.h")]
 842         public class VVolumebar : Hildon.Volumebar, Atk.Implementor, Gtk.Buildable {
 843                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 844                 public VVolumebar ();
 845         }
 846         [CCode (cheader_filename = "hildon/hildon.h")]
 847         public class Volumebar : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 848                 public unowned Gtk.Adjustment get_adjustment ();
 849                 public double get_level ();
 850                 public bool get_mute ();
 851                 public void set_level (double level);
 852                 public void set_mute (bool mute);
 853                 public void set_range_insensitive_message (string message);
 854                 public void set_range_insensitive_messagef (string format);
 855                 [NoAccessorMethod]
 856                 public bool has_mute { get; set construct; }
 857                 public double level { get; set; }
 858                 public bool mute { get; set; }
 859                 public virtual signal void level_changed ();
 860                 public virtual signal void mute_toggled ();
 861         }
 862         [CCode (cheader_filename = "hildon/hildon.h")]
 863         public class VolumebarRange : Gtk.Scale, Atk.Implementor, Gtk.Buildable {
 864                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 865                 public VolumebarRange (Gtk.Orientation orientation);
 866                 public double get_level ();
 867                 public void set_level (double level);
 868                 public double level { get; set; }
 869         }
 870         [CCode (cheader_filename = "hildon/hildon.h")]
 871         public class WeekdayPicker : Gtk.Container, Atk.Implementor, Gtk.Buildable {
 872                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 873                 public WeekdayPicker ();
 874                 public bool isset_day (GLib.DateWeekday day);
 875                 public void set_all ();
 876                 public void set_day (GLib.DateWeekday day);
 877                 public void toggle_day (GLib.DateWeekday day);
 878                 public void unset_all ();
 879                 public void unset_day (GLib.DateWeekday day);
 880                 public virtual signal void selection_changed (int p0);
 881         }
 882         [CCode (cheader_filename = "hildon/hildon.h")]
 883         public class Window : Gtk.Window, Atk.Implementor, Gtk.Buildable {
 884                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 885                 public Window ();
 886                 public void add_toolbar (Gtk.Toolbar toolbar);
 887                 public void add_with_scrollbar (Gtk.Widget child);
 888                 public unowned Hildon.AppMenu get_app_menu ();
 889                 public bool get_is_topmost ();
 890                 public unowned Gtk.Menu get_main_menu ();
 891                 public unowned string get_markup ();
 892                 public unowned Gtk.Menu get_menu ();
 893                 public void remove_toolbar (Gtk.Toolbar toolbar);
 894                 public void set_app_menu (Hildon.AppMenu menu);
 895                 public void set_edit_toolbar (Hildon.EditToolbar toolbar);
 896                 public void set_main_menu (Gtk.Menu menu);
 897                 public void set_markup (string markup);
 898                 public void set_menu (Gtk.Menu menu);
 899                 [NoWrapper]
 900                 public virtual bool toggle_menu (uint button, uint32 time);
 901                 public bool is_topmost { get; }
 902                 public string markup { get; set; }
 903                 public virtual signal void clipboard_operation (int operation);
 904         }
 905         [CCode (cheader_filename = "hildon/hildon.h")]
 906         public class WindowStack : GLib.Object {
 907                 [CCode (has_construct_function = false)]
 908                 public WindowStack ();
 909                 public static unowned Hildon.WindowStack get_default ();
 910                 public unowned GLib.List get_windows ();
 911                 public unowned Gtk.Widget peek ();
 912                 public void pop (int nwindows, GLib.List popped_windows);
 913                 public unowned Gtk.Widget pop_1 ();
 914                 public void pop_and_push (int nwindows, GLib.List popped_windows, Hildon.StackableWindow win1);
 915                 public void pop_and_push_list (int nwindows, GLib.List popped_windows, GLib.List list);
 916                 public void push (Hildon.StackableWindow win1);
 917                 public void push_1 (Hildon.StackableWindow win);
 918                 public void push_list (GLib.List list);
 919                 public int size ();
 920                 [NoAccessorMethod]
 921                 public Gtk.WindowGroup window_group { owned get; construct; }
 922         }
 923         [CCode (cheader_filename = "hildon/hildon.h")]
 924         public class WizardDialog : Gtk.Dialog, Atk.Implementor, Gtk.Buildable {
 925                 [CCode (type = "GtkWidget*", has_construct_function = false)]
 926                 public WizardDialog (Gtk.Window parent, string wizard_name, Gtk.Notebook notebook);
 927                 public void set_forward_page_func (Hildon.WizardDialogPageFunc page_func, void* data, GLib.DestroyNotify destroy);
 928                 [NoAccessorMethod]
 929                 public bool autotitle { get; set; }
 930                 [NoAccessorMethod]
 931                 public string wizard_name { owned get; set; }
 932                 [NoAccessorMethod]
 933                 public Gtk.Notebook wizard_notebook { owned get; set; }
 934         }
 935         [CCode (cheader_filename = "hildon/hildon.h")]
 936         public interface BreadCrumb : Gtk.Widget {
 937                 public void activated ();
 938                 public abstract void get_natural_size (int width, int height);
 939                 public signal void crumb_activated ();
 940         }
 941         [CCode (cprefix = "HILDON_BUTTON_ARRANGEMENT_", cheader_filename = "hildon/hildon.h")]
 942         public enum ButtonArrangement {
 943                 HORIZONTAL,
 944                 VERTICAL
 945         }
 946         [CCode (cprefix = "HILDON_BUTTON_STYLE_", cheader_filename = "hildon/hildon.h")]
 947         public enum ButtonStyle {
 948                 NORMAL,
 949                 PICKER
 950         }
 951         [CCode (cprefix = "HILDON_CALENDAR_", cheader_filename = "hildon/hildon.h")]
 952         [Flags]
 953         public enum CalendarDisplayOptions {
 954                 SHOW_HEADING,
 955                 SHOW_DAY_NAMES,
 956                 NO_MONTH_CHANGE,
 957                 SHOW_WEEK_NUMBERS,
 958                 WEEK_START_MONDAY
 959         }
 960         [CCode (cprefix = "HILDON_CAPTION_POSITION_", cheader_filename = "hildon/hildon.h")]
 961         public enum CaptionIconPosition {
 962                 LEFT,
 963                 RIGHT
 964         }
 965         [CCode (cprefix = "HILDON_CAPTION_", cheader_filename = "hildon/hildon.h")]
 966         public enum CaptionStatus {
 967                 OPTIONAL,
 968                 MANDATORY
 969         }
 970         [CCode (cprefix = "HILDON_DATE_TIME_ERROR_", cheader_filename = "hildon/hildon.h")]
 971         public enum DateTimeError {
 972                 NO_ERROR,
 973                 MAX_HOURS,
 974                 MAX_MINS,
 975                 MAX_SECS,
 976                 MAX_DAY,
 977                 MAX_MONTH,
 978                 MAX_YEAR,
 979                 MIN_HOURS,
 980                 MIN_MINS,
 981                 MIN_SECS,
 982                 MIN_DAY,
 983                 MIN_MONTH,
 984                 MIN_YEAR,
 985                 EMPTY_HOURS,
 986                 EMPTY_MINS,
 987                 EMPTY_SECS,
 988                 EMPTY_DAY,
 989                 EMPTY_MONTH,
 990                 EMPTY_YEAR,
 991                 MIN_DURATION,
 992                 MAX_DURATION,
 993                 INVALID_CHAR,
 994                 INVALID_DATE,
 995                 INVALID_TIME
 996         }
 997         [CCode (cprefix = "HILDON_GTK_INPUT_MODE_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
 998         public enum GtkInputMode {
 999                 ALPHA,
1000                 NUMERIC,
1001                 SPECIAL,
1002                 HEXA,
1003                 TELE,
1004                 FULL,
1005                 MULTILINE,
1006                 INVISIBLE,
1007                 AUTOCAP,
1008                 DICTIONARY
1009         }
1010         [CCode (cprefix = "HILDON_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
1011         public enum Mode {
1012                 DIABLO,
1013                 FREMANTLE
1014         }
1015         [CCode (cprefix = "HILDON_MOVEMENT_", cheader_filename = "hildon/hildon.h")]
1016         public enum MovementDirection {
1017                 UP,
1018                 DOWN,
1019                 LEFT,
1020                 RIGHT
1021         }
1022         [CCode (cprefix = "HILDON_MOVEMENT_MODE_", cheader_filename = "hildon/hildon.h")]
1023         [Flags]
1024         public enum MovementMode {
1025                 HORIZ,
1026                 VERT,
1027                 BOTH
1028         }
1029         [CCode (cprefix = "HILDON_NOTE_TYPE_", cheader_filename = "hildon/hildon.h")]
1030         public enum NoteType {
1031                 CONFIRMATION,
1032                 CONFIRMATION_BUTTON,
1033                 INFORMATION,
1034                 INFORMATION_THEME,
1035                 PROGRESSBAR
1036         }
1037         [CCode (cprefix = "HILDON_NUMBER_EDITOR_ERROR_", cheader_filename = "hildon/hildon.h")]
1038         public enum NumberEditorErrorType {
1039                 MAXIMUM_VALUE_EXCEED,
1040                 MINIMUM_VALUE_EXCEED,
1041                 ERRONEOUS_VALUE
1042         }
1043         [CCode (cprefix = "HILDON_PANNABLE_AREA_MODE_", cheader_filename = "hildon/hildon.h")]
1044         public enum PannableAreaMode {
1045                 PUSH,
1046                 ACCEL,
1047                 AUTO
1048         }
1049         [CCode (cprefix = "HILDON_PORTRAIT_MODE_", cheader_filename = "hildon/hildon.h")]
1050         [Flags]
1051         public enum PortraitFlags {
1052                 REQUEST,
1053                 SUPPORT
1054         }
1055         [CCode (cprefix = "HILDON_SIZE_REQUEST_", cheader_filename = "hildon/hildon.h")]
1056         public enum SizeRequestPolicy {
1057                 MINIMUM,
1058                 CHILDREN
1059         }
1060         [CCode (cprefix = "HILDON_SIZE_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
1061         public enum SizeType {
1062                 AUTO_WIDTH,
1063                 HALFSCREEN_WIDTH,
1064                 FULLSCREEN_WIDTH,
1065                 AUTO_HEIGHT,
1066                 FINGER_HEIGHT,
1067                 THUMB_HEIGHT,
1068                 AUTO
1069         }
1070         [CCode (cprefix = "HILDON_TIME_SELECTOR_FORMAT_POLICY_", cheader_filename = "hildon/hildon.h")]
1071         public enum TimeSelectorFormatPolicy {
1072                 AMPM,
1073                 @24H,
1074                 AUTOMATIC
1075         }
1076         [CCode (cprefix = "HILDON_TOUCH_SELECTOR_SELECTION_MODE_", cheader_filename = "hildon/hildon.h")]
1077         public enum TouchSelectorSelectionMode {
1078                 SINGLE,
1079                 MULTIPLE
1080         }
1081         [CCode (cprefix = "HILDON_UI_MODE_", has_type_id = "0", cheader_filename = "gtk/gtk.h")]
1082         public enum UIMode {
1083                 NORMAL,
1084                 EDIT
1085         }
1086         [CCode (cprefix = "HILDON_WINDOW_CO_", cheader_filename = "hildon/hildon.h")]
1087         public enum WindowClipboardOperation {
1088                 COPY,
1089                 CUT,
1090                 PASTE
1091         }
1092         [CCode (cprefix = "HILDON_WIZARD_DIALOG_", cheader_filename = "hildon/hildon.h")]
1093         public enum WizardDialogResponse {
1094                 CANCEL,
1095                 PREVIOUS,
1096                 NEXT,
1097                 FINISH
1098         }
1099         [CCode (cheader_filename = "hildon/hildon.h")]
1100         public delegate unowned string TouchSelectorPrintFunc (Hildon.TouchSelector selector);
1101         [CCode (cheader_filename = "hildon/hildon.h")]
1102         public delegate bool WizardDialogPageFunc (Gtk.Notebook notebook, int current_page);
1103         [CCode (cheader_filename = "hildon/hildon.h")]
1104         public const int AA_CENTER_GRAVITY;
1105         [CCode (cheader_filename = "hildon/hildon.h")]
1106         public const int AA_E_GRAVITY;
1107         [CCode (cheader_filename = "hildon/hildon.h")]
1108         public const int AA_NE_GRAVITY;
1109         [CCode (cheader_filename = "hildon/hildon.h")]
1110         public const int AA_NW_GRAVITY;
1111         [CCode (cheader_filename = "hildon/hildon.h")]
1112         public const int AA_N_GRAVITY;
1113         [CCode (cheader_filename = "hildon/hildon.h")]
1114         public const int AA_SE_GRAVITY;
1115         [CCode (cheader_filename = "hildon/hildon.h")]
1116         public const int AA_SW_GRAVITY;
1117         [CCode (cheader_filename = "hildon/hildon.h")]
1118         public const int AA_S_GRAVITY;
1119         [CCode (cheader_filename = "hildon/hildon.h")]
1120         public const int AA_W_GRAVITY;
1121         [CCode (cheader_filename = "hildon/hildon.h")]
1122         public const int AA_X_AXIS;
1123         [CCode (cheader_filename = "hildon/hildon.h")]
1124         public const int AA_Y_AXIS;
1125         [CCode (cheader_filename = "hildon/hildon.h")]
1126         public const int AA_Z_AXIS;
1127         [CCode (cheader_filename = "hildon/hildon.h")]
1128         public const int MAJOR_VERSION;
1129         [CCode (cheader_filename = "hildon/hildon.h")]
1130         public const int MARGIN_DEFAULT;
1131         [CCode (cheader_filename = "hildon/hildon.h")]
1132         public const int MARGIN_DOUBLE;
1133         [CCode (cheader_filename = "hildon/hildon.h")]
1134         public const int MARGIN_HALF;
1135         [CCode (cheader_filename = "hildon/hildon.h")]
1136         public const int MARGIN_TRIPLE;
1137         [CCode (cheader_filename = "hildon/hildon.h")]
1138         public const int MICRO_VERSION;
1139         [CCode (cheader_filename = "hildon/hildon.h")]
1140         public const int MINOR_VERSION;
1141         [CCode (cheader_filename = "hildon/hildon.h")]
1142         public const int WINDOW_LONG_PRESS_TIME;
1143         [CCode (cheader_filename = "hildon/hildon.h")]
1144         public const int WINDOW_TITLEBAR_HEIGHT;
1145         [CCode (cheader_filename = "hildon/hildon.h")]
1146         public static unowned string format_file_size_for_display (int64 size);
1147         [CCode (cheader_filename = "hildon/hildon.h")]
1148         public static int get_icon_pixel_size (Gtk.IconSize size);
1149         [CCode (cheader_filename = "hildon/hildon.h")]
1150         public static unowned Gtk.Widget gtk_button_new (Hildon.SizeType size);
1151         [CCode (cheader_filename = "hildon/hildon.h")]
1152         public static unowned Gtk.Widget gtk_hscale_new ();
1153         [CCode (cheader_filename = "hildon/hildon.h")]
1154         public static unowned Gtk.Widget gtk_icon_view_new (Hildon.UIMode mode);
1155         [CCode (cheader_filename = "hildon/hildon.h")]
1156         public static unowned Gtk.Widget gtk_icon_view_new_with_model (Hildon.UIMode mode, Gtk.TreeModel model);
1157         [CCode (cheader_filename = "hildon/hildon.h")]
1158         public static void gtk_icon_view_set_ui_mode (Gtk.IconView iconview, Hildon.UIMode mode);
1159         [CCode (cheader_filename = "hildon/hildon.h")]
1160         public static void gtk_init ([CCode (array_length_pos = 0.9)] ref unowned string[] argv);
1161         [CCode (cheader_filename = "hildon/hildon.h")]
1162         public static unowned Gtk.Widget gtk_menu_new ();
1163         [CCode (cheader_filename = "hildon/hildon.h")]
1164         public static unowned Gtk.Widget gtk_radio_button_new (Hildon.SizeType size, GLib.SList group);
1165         [CCode (cheader_filename = "hildon/hildon.h")]
1166         public static unowned Gtk.Widget gtk_radio_button_new_from_widget (Hildon.SizeType size, Gtk.RadioButton radio_group_member);
1167         [CCode (cheader_filename = "hildon/hildon.h")]
1168         public static unowned Gtk.Widget gtk_toggle_button_new (Hildon.SizeType size);
1169         [CCode (cheader_filename = "hildon/hildon.h")]
1170         public static unowned Gtk.Widget gtk_tree_view_new (Hildon.UIMode mode);
1171         [CCode (cheader_filename = "hildon/hildon.h")]
1172         public static unowned Gtk.Widget gtk_tree_view_new_with_model (Hildon.UIMode mode, Gtk.TreeModel model);
1173         [CCode (cheader_filename = "hildon/hildon.h")]
1174         public static void gtk_tree_view_set_ui_mode (Gtk.TreeView treeview, Hildon.UIMode mode);
1175         [CCode (cheader_filename = "hildon/hildon.h")]
1176         public static unowned Gtk.Widget gtk_vscale_new ();
1177         [CCode (cheader_filename = "gtk/gtk.h")]
1178         public static void gtk_widget_set_theme_size (Gtk.Widget widget, Hildon.SizeType size);
1179         [CCode (cheader_filename = "hildon/hildon.h")]
1180         public static void gtk_window_set_do_not_disturb (Gtk.Window window, bool dndflag);
1181         [CCode (cheader_filename = "hildon/hildon.h")]
1182         public static void gtk_window_set_portrait_flags (Gtk.Window window, Hildon.PortraitFlags portrait_flags);
1183         [CCode (cheader_filename = "hildon/hildon.h")]
1184         public static void gtk_window_set_progress_indicator (Gtk.Window window, uint state);
1185         [CCode (cheader_filename = "hildon/hildon.h")]
1186         public static void gtk_window_take_screenshot (Gtk.Window window, bool take);
1187         [CCode (cheader_filename = "hildon/hildon.h")]
1188         public static bool helper_event_button_is_finger (Gdk.EventButton event);
1189         [CCode (cheader_filename = "hildon/hildon.h")]
1190         public static void helper_set_insensitive_message (Gtk.Widget widget, string message);
1191         [CCode (cheader_filename = "hildon/hildon.h")]
1192         public static void helper_set_insensitive_messagef (Gtk.Widget widget, string format);
1193         [CCode (cheader_filename = "hildon/hildon.h")]
1194         public static ulong helper_set_logical_color (Gtk.Widget widget, Gtk.RcFlags rcflags, Gtk.StateType state, string logicalcolorname);
1195         [CCode (cheader_filename = "hildon/hildon.h")]
1196         public static ulong helper_set_logical_font (Gtk.Widget widget, string logicalfontname);
1197         [CCode (cheader_filename = "hildon/hildon.h")]
1198         public static void helper_set_thumb_scrollbar (Gtk.ScrolledWindow win, bool thumb);
1199         [CCode (cheader_filename = "hildon/hildon.h")]
1200         public static void init ();
1201         [CCode (cheader_filename = "hildon/hildon.h")]
1202         public static unowned Gtk.Widget pannable_get_child_widget_at (Hildon.PannableArea area, double x, double y);
1203         [CCode (cheader_filename = "hildon/hildon.h")]
1204         public static void play_system_sound (string sample);
1205 }