vapi/gobject-2.0.vapi

   1 /* gobject-2.0.vala
   2  *
   3  * Copyright (C) 2006-2010  Jürg Billeter
   4  * Copyright (C) 2006-2008  Raffaele Sandrini
   5  * Copyright (C) 2007  Mathias Hasselmann
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  20  *
  21  * Author:
  22  *      Jürg Billeter <j@bitron.ch>
  23  *      Raffaele Sandrini <rasa@gmx.ch>
  24  *      Mathias Hasselmann <mathias.hasselmann@gmx.de>
  25  */
  26
  27 [CCode (cprefix = "G", lower_case_cprefix = "g_", cheader_filename = "glib.h", gir_namespace = "GObject", gir_version = "2.0")]
  28 namespace GLib {
  29         [CCode (type_id = "G_TYPE_GTYPE", marshaller_type_name = "GTYPE", get_value_function = "g_value_get_gtype", set_value_function = "g_value_set_gtype")]
  30         public struct Type : ulong {
  31                 [CCode (cname = "G_TYPE_IS_OBJECT")]
  32                 public bool is_object ();
  33                 [CCode (cname = "G_TYPE_IS_ABSTRACT")]
  34                 public bool is_abstract ();
  35                 [CCode (cname = "G_TYPE_IS_CLASSED")]
  36                 public bool is_classed ();
  37                 [CCode (cname = "G_TYPE_IS_DERIVABLE")]
  38                 public bool is_derivable ();
  39                 [CCode (cname = "G_TYPE_IS_DEEP_DERIVABLE")]
  40                 public bool is_deep_derivable ();
  41                 [CCode (cname = "G_TYPE_IS_DERIVED")]
  42                 public bool is_derived ();
  43                 [CCode (cname = "G_TYPE_IS_FUNDAMENTAL")]
  44                 public bool is_fundamental ();
  45                 [CCode (cname = "G_TYPE_IS_INSTANTIATABLE")]
  46                 public bool is_instantiatable ();
  47                 [CCode (cname = "G_TYPE_IS_INTERFACE")]
  48                 public bool is_interface ();
  49                 [CCode (cname = "G_TYPE_IS_VALUE_TYPE")]
  50                 public bool is_value_type ();
  51                 [CCode (cname = "G_TYPE_IS_ENUM")]
  52                 public bool is_enum ();
  53                 [CCode (cname = "G_TYPE_IS_FLAGS")]
  54                 public bool is_flags ();
  55
  56                 [CCode (cname = "G_TYPE_FROM_INSTANCE")]
  57                 public static Type from_instance (void* instance);
  58
  59                 public Type[] children ();
  60                 public uint depth ();
  61                 public static Type from_name (string name);
  62                 [CCode (array_length_type = "guint")]
  63                 public Type[] interfaces ();
  64                 public bool is_a (Type is_a_type);
  65                 public unowned string name ();
  66                 public Quark qname ();
  67                 public Type parent ();
  68
  69                 public void* get_qdata (Quark quark);
  70                 public void set_qdata (Quark quark, void* data);
  71
  72                 public void query (out TypeQuery query);
  73
  74                 public TypeClass class_ref ();
  75                 public unowned TypeClass class_peek ();
  76
  77                 public const Type INVALID;
  78                 public const Type INTERFACE;
  79                 public const Type ENUM;
  80                 public const Type FLAGS;
  81                 public const Type BOXED;
  82         }
  83
  84         public struct TypeQuery {
  85                 public Type type;
  86                 public unowned string type_name;
  87                 public uint class_size;
  88                 public uint instance_size;
  89         }
  90
  91         [Compact]
  92         [CCode (ref_function = "g_type_class_ref", unref_function = "g_type_class_unref")]
  93         public class TypeClass {
  94                 [CCode (cname = "G_TYPE_FROM_CLASS")]
  95                 public Type get_type ();
  96         }
  97
  98         [CCode (cprefix = "G_TYPE_DEBUG_", has_type_id = false)]
  99         [Flags]
 100         public enum TypeDebugFlags {
 101                 NONE,
 102                 OBJECTS,
 103                 SIGNALS,
 104                 MASK
 105         }
 106
 107         public interface TypePlugin {
 108         }
 109
 110         [CCode (lower_case_csuffix = "type_module")]
 111         public class TypeModule : Object, TypePlugin {
 112                 [CCode (has_construct_function = false)]
 113                 protected TypeModule ();
 114                 public bool use ();
 115                 public void unuse ();
 116                 public void set_name (string name);
 117                 [NoWrapper]
 118                 public virtual bool load ();
 119                 [NoWrapper]
 120                 public virtual void unload ();
 121         }
 122
 123         [CCode (type_id = "G_TYPE_PARAM", ref_function = "g_param_spec_ref", unref_function = "g_param_spec_unref", param_spec_function = "g_param_spec_param", get_value_function = "g_value_get_param", set_value_function = "g_value_set_param", take_value_function = "g_value_take_param")]
 124         public class ParamSpec {
 125                 public string name;
 126                 public ParamFlags flags;
 127                 public Type value_type;
 128                 public Type owner_type;
 129                 [CCode (cname = "g_param_spec_internal")]
 130                 public ParamSpec.internal (GLib.Type param_type, string name, string nick, string blurb, GLib.ParamFlags flags);
 131                 public ParamSpec ref ();
 132                 public void unref ();
 133                 public void sink ();
 134                 public ParamSpec ref_sink ();
 135                 [CCode (cname = "g_param_value_set_default")]
 136                 public void set_value_default (Value value);
 137                 [CCode (cname = "g_param_value_defaults")]
 138                 public bool value_defaults (Value value);
 139                 [CCode (cname = "g_param_value_validate")]
 140                 public bool value_validate (Value value);
 141                 [CCode (cname = "g_param_value_convert")]
 142                 public bool value_convert (Value src_value, Value dest_value, bool strict_validation);
 143                 [CCode (cname = "g_param_values_cmp")]
 144                 public int values_cmp (Value value1, Value value2);
 145                 public unowned string get_blurb ();
 146                 public unowned string get_name ();
 147                 public unowned string get_nick ();
 148                 public void* get_qdata (Quark quark);
 149                 public void set_qdata (Quark quark, void* data);
 150                 public void set_qdata_full (Quark quark, void* data, DestroyNotify destroy);
 151                 public void* steal_qdata (Quark quark);
 152                 public ParamSpec get_redirect_target ();
 153         }
 154
 155         public class ParamSpecBoolean : ParamSpec {
 156                 [CCode (cname = "g_param_spec_boolean")]
 157                 public ParamSpecBoolean (string name, string nick, string blurb, bool defaultvalue, ParamFlags flags);
 158                 public bool default_value;
 159         }
 160
 161         public class ParamSpecChar : ParamSpec {
 162                 [CCode (cname = "g_param_spec_char")]
 163                 public ParamSpecChar (string name, string nick, string blurb, int8 minimum, int8 maximum, int8 default_value, ParamFlags flags);
 164                 public int8 minimum;
 165                 public int8 maximum;
 166                 public int8 default_value;
 167         }
 168
 169         public class ParamSpecUChar : ParamSpec {
 170                 [CCode (cname = "g_param_spec_uchar")]
 171                 public ParamSpecUChar (string name, string nick, string blurb, uint8 minimum, uint8 maximum, uint8 default_value, ParamFlags flags);
 172                 public uint8 minimum;
 173                 public uint8 maximum;
 174                 public uint8 default_value;
 175         }
 176
 177         public class ParamSpecInt : ParamSpec {
 178                 [CCode (cname = "g_param_spec_int")]
 179                 public ParamSpecInt (string name, string nick, string blurb, int minimum, int maximum, int default_value, ParamFlags flags);
 180                 public int minimum;
 181                 public int maximum;
 182                 public int default_value;
 183         }
 184
 185         public class ParamSpecUInt : ParamSpec {
 186                 [CCode (cname = "g_param_spec_uint")]
 187                 public ParamSpecUInt (string name, string nick, string blurb, uint minimum, uint maximum, uint default_value, ParamFlags flags);
 188                 public uint minimum;
 189                 public uint maximum;
 190                 public uint default_value;
 191         }
 192
 193         public class ParamSpecLong : ParamSpec {
 194                 [CCode (cname = "g_param_spec_long")]
 195                 public ParamSpecLong (string name, string nick, string blurb, long minimum, long maximum, long default_value, ParamFlags flags);
 196                 public long minimum;
 197                 public long maximum;
 198                 public long default_value;
 199         }
 200
 201         public class ParamSpecULong : ParamSpec {
 202                 [CCode (cname = "g_param_spec_ulong")]
 203                 public ParamSpecULong (string name, string nick, string blurb, ulong minimum, ulong maximum, ulong default_value, ParamFlags flags);
 204                 public ulong minimum;
 205                 public ulong maximum;
 206                 public ulong default_value;
 207         }
 208
 209         public class ParamSpecInt64 : ParamSpec {
 210                 [CCode (cname = "g_param_spec_int64")]
 211                 public ParamSpecInt64 (string name, string nick, string blurb, int64 minimum, int64 maximum, int64 default_value, ParamFlags flags);
 212                 public int64 minimum;
 213                 public int64 maximum;
 214                 public int64 default_value;
 215         }
 216
 217         public class ParamSpecUInt64 : ParamSpec {
 218                 [CCode (cname = "g_param_spec_uint64")]
 219                 public ParamSpecUInt64 (string name, string nick, string blurb, uint64 minimum, uint64 maximum, uint64 default_value, ParamFlags flags);
 220                 public uint64 minimum;
 221                 public uint64 maximum;
 222                 public uint64 default_value;
 223         }
 224
 225         public class ParamSpecFloat : ParamSpec {
 226                 [CCode (cname = "g_param_spec_float")]
 227                 public ParamSpecFloat (string name, string nick, string blurb, float minimum, float maximum, float default_value, ParamFlags flags);
 228                 public float minimum;
 229                 public float maximum;
 230                 public float default_value;
 231         }
 232
 233         public class ParamSpecDouble : ParamSpec {
 234                 [CCode (cname = "g_param_spec_double")]
 235                 public ParamSpecDouble (string name, string nick, string blurb, double minimum, double maximum, double default_value, ParamFlags flags);
 236                 public double minimum;
 237                 public double maximum;
 238                 public double default_value;
 239         }
 240
 241         public class ParamSpecEnum : ParamSpec {
 242                 [CCode (cname = "g_param_spec_enum")]
 243                 public ParamSpecEnum (string name, string nick, string blurb, Type enum_type, int default_value, ParamFlags flags);
 244                 public unowned EnumClass enum_class;
 245                 public int default_value;
 246         }
 247
 248         public class ParamSpecFlags : ParamSpec {
 249                 [CCode (cname = "g_param_spec_flags")]
 250                 public ParamSpecFlags (string name, string nick, string blurb, Type flags_type, uint default_value, ParamFlags flags);
 251                 public unowned FlagsClass flags_class;
 252                 public uint default_value;
 253         }
 254
 255         public class ParamSpecString : ParamSpec {
 256                 [CCode (cname = "g_param_spec_string")]
 257                 public ParamSpecString (string name, string nick, string blurb, string default_value, ParamFlags flags);
 258                 public string default_value;
 259                 public string cset_first;
 260                 public string cset_nth;
 261                 public char substitutor;
 262                 public uint null_fold_if_empty;
 263                 public uint ensure_non_null;
 264         }
 265
 266         public class ParamSpecParam : ParamSpec {
 267                 [CCode (cname = "g_param_spec_param")]
 268                 public ParamSpecParam (string name, string nick, string blurb, Type param_type, ParamFlags flags);
 269         }
 270
 271         [CCode (cprefix = "G_PARAM_", has_type_id = false)]
 272         [Flags]
 273         public enum ParamFlags {
 274                 READABLE,
 275                 WRITABLE,
 276                 CONSTRUCT,
 277                 CONSTRUCT_ONLY,
 278                 LAX_VALIDATION,
 279                 STATIC_NAME,
 280                 STATIC_NICK,
 281                 STATIC_BLURB,
 282                 READWRITE,
 283                 STATIC_STRINGS,
 284                 USER_SHIFT,
 285                 DEPRECATED,
 286                 MASK
 287         }
 288
 289         [CCode (lower_case_csuffix = "object_class")]
 290         public class ObjectClass : TypeClass {
 291                 public unowned ParamSpec? find_property (string property_name);
 292                 [CCode (array_length_type = "guint")]
 293                 public unowned ParamSpec[] list_properties ();
 294                 public void install_property (uint property_id, ParamSpec pspec);
 295         }
 296
 297         public struct ObjectConstructParam {
 298         }
 299
 300         [CCode (cprefix = "G_BINDING_")]
 301         [Flags]
 302         public enum BindingFlags {
 303                 DEFAULT,
 304                 BIDIRECTIONAL,
 305                 SYNC_CREATE,
 306                 INVERT_BOOLEAN
 307         }
 308
 309         public delegate bool BindingTransformFunc (GLib.Binding binding, GLib.Value source_value, ref GLib.Value target_value);
 310
 311         public class Binding : GLib.Object {
 312                 public weak GLib.Object source { get; }
 313                 public string source_property { get; }
 314                 public weak GLib.Object target { get; }
 315                 public string target_property { get; }
 316                 public GLib.BindingFlags flags { get; }
 317         }
 318
 319         [CCode (has_target = false)]
 320         public delegate void ObjectGetPropertyFunc (Object object, uint property_id, Value value, ParamSpec pspec);
 321         [CCode (has_target = false)]
 322         public delegate void ObjectSetPropertyFunc (Object object, uint property_id, Value value, ParamSpec pspec);
 323         [CCode (instance_pos = 0)]
 324         public delegate void WeakNotify (Object object);
 325
 326         [CCode (ref_function = "g_object_ref", unref_function = "g_object_unref", marshaller_type_name = "OBJECT", get_value_function = "g_value_get_object", set_value_function = "g_value_set_object", take_value_function = "g_value_take_object", param_spec_function = "g_param_spec_object", cheader_filename = "glib-object.h")]
 327         public class Object {
 328                 public uint ref_count;
 329
 330                 [CCode (has_new_function = false, construct_function = "g_object_new")]
 331                 public Object (...);
 332
 333                 public static Object @new (Type type, ...);
 334                 public static Object newv (Type type, [CCode (array_length_pos = 1.9)] Parameter[] parameters);
 335                 public static Object new_valist (Type type, string? firstprop, va_list var_args);
 336
 337                 [CCode (cname = "G_TYPE_FROM_INSTANCE")]
 338                 public Type get_type ();
 339                 [CCode (cname = "G_OBJECT_GET_CLASS")]
 340                 public unowned ObjectClass get_class ();
 341                 public unowned Object @ref ();
 342                 public void unref ();
 343                 public Object ref_sink ();
 344                 public void weak_ref (WeakNotify notify);
 345                 public void weak_unref (WeakNotify notify);
 346                 public void add_weak_pointer (void **data);
 347                 public void remove_weak_pointer (void **data);
 348                 public void get (string first_property_name, ...);
 349                 public void set (string first_property_name, ...);
 350                 public void get_property (string property_name, ref Value value);
 351                 public void set_property (string property_name, Value value);
 352                 [CCode (simple_generics = true)]
 353                 public unowned T get_data<T> (string key);
 354                 [CCode (cname = "g_object_set_data_full", simple_generics = true)]
 355                 public void set_data<T> (string key, owned T data);
 356                 public void set_data_full (string key, void* data, DestroyNotify? destroy);
 357                 [CCode (simple_generics = true)]
 358                 public T steal_data<T> (string key);
 359                 [CCode (simple_generics = true)]
 360                 public unowned T get_qdata<T> (Quark quark);
 361                 [CCode (cname = "g_object_set_qdata_full", simple_generics = true)]
 362                 public void set_qdata<T> (Quark quark, owned T data);
 363                 public void set_qdata_full (Quark quark, void* data, DestroyNotify? destroy);
 364                 [CCode (simple_generics = true)]
 365                 public T steal_qdata<T> (Quark quark);
 366                 public void freeze_notify ();
 367                 public void thaw_notify ();
 368                 [CCode (cname = "g_object_run_dispose")]
 369                 public virtual void dispose ();
 370                 public virtual void constructed ();
 371
 372                 public signal void notify (ParamSpec pspec);
 373                 [CCode (cname = "g_object_notify")]
 374                 public void notify_property (string property_name);
 375
 376                 public unowned Object connect (string signal_spec, ...);
 377                 [CCode (cname = "g_signal_handler_disconnect")]
 378                 public void disconnect (ulong handler_id);
 379
 380                 public void add_toggle_ref (ToggleNotify notify);
 381                 public void remove_toggle_ref (ToggleNotify notify);
 382
 383                 [CCode (cname = "g_object_bind_property_with_closures")]
 384                 public unowned GLib.Binding bind_property (string source_property, GLib.Object target, string target_property, GLib.BindingFlags flags = GLib.BindingFlags.DEFAULT, [CCode (type = "GClosure*")] owned GLib.BindingTransformFunc? transform_to = null, [CCode (type = "GClosure*")] owned GLib.BindingTransformFunc? transform_from = null);
 385         }
 386
 387         [CCode (destroy_function = "g_weak_ref_clear")]
 388         public struct WeakRef {
 389                 public WeakRef (GLib.Object? object);
 390                 public GLib.Object? get ();
 391                 public void set (GLib.Object? object);
 392         }
 393
 394         [CCode (instance_pos = 0)]
 395         public delegate void ToggleNotify (GLib.Object object, bool is_last_ref);
 396
 397         [CCode (has_copy_function = false, has_destroy_function = false)]
 398         public struct Parameter {
 399                 public unowned string name;
 400                 public Value value;
 401         }
 402
 403         [CCode (ref_sink_function = "g_object_ref_sink")]
 404         public class InitiallyUnowned : Object {
 405                 [CCode (has_construct_function = false)]
 406                 protected InitiallyUnowned ();
 407         }
 408
 409         [CCode (lower_case_csuffix = "enum")]
 410         public class EnumClass : TypeClass {
 411                 public unowned EnumValue? get_value (int value);
 412                 public unowned EnumValue? get_value_by_name (string name);
 413                 public unowned EnumValue? get_value_by_nick (string name);
 414                 public int minimum;
 415                 public int maximum;
 416                 public uint n_values;
 417                 [CCode (array_length_cname = "n_values")]
 418                 public unowned EnumValue[] values;
 419         }
 420
 421         [CCode (has_type_id = false)]
 422         public struct EnumValue {
 423                 public int value;
 424                 public unowned string value_name;
 425                 public unowned string value_nick;
 426         }
 427
 428         [CCode (lower_case_csuffix = "flags")]
 429         public class FlagsClass : TypeClass {
 430                 public unowned FlagsValue? get_first_value (uint value);
 431                 public unowned FlagsValue? get_value_by_name (string name);
 432                 public unowned FlagsValue? get_value_by_nick (string name);
 433                 public uint mask;
 434                 public uint n_values;
 435                 [CCode (array_length_cname = "n_values")]
 436                 public FlagsValue[] values;
 437         }
 438
 439         [Compact]
 440         public class FlagsValue {
 441                 public int value;
 442                 public unowned string value_name;
 443                 public unowned string value_nick;
 444         }
 445
 446         [CCode (has_target = false)]
 447         public delegate void ValueTransform (Value src_value, ref Value dest_value);
 448
 449         [CCode (copy_function = "g_value_copy", destroy_function = "g_value_unset", type_id = "G_TYPE_VALUE", marshaller_type_name = "BOXED", get_value_function = "g_value_get_boxed", set_value_function = "g_value_set_boxed", take_value_function = "g_value_take_boxed", type_signature = "v")]
 450         public struct Value {
 451                 [CCode (cname = "G_VALUE_HOLDS")]
 452                 public bool holds (Type type);
 453                 [CCode (cname = "G_VALUE_TYPE")]
 454                 public Type type ();
 455                 [CCode (cname = "G_VALUE_TYPE_NAME")]
 456                 public unowned string type_name ();
 457
 458                 public Value (Type g_type);
 459                 public void copy (ref Value dest_value);
 460                 public unowned Value? reset ();
 461                 public void init (Type g_type);
 462                 public void unset ();
 463                 public void set_instance (void* instance);
 464                 public bool fits_pointer ();
 465                 public void* peek_pointer ();
 466                 public static bool type_compatible (Type src_type, Type dest_type);
 467                 public static bool type_transformable (Type src_type, Type dest_type);
 468                 public bool transform (ref Value dest_value);
 469                 [CCode (cname = "g_strdup_value_contents")]
 470                 public string strdup_contents ();
 471                 public static void register_transform_func (Type src_type, Type dest_type, ValueTransform transform);
 472                 public void set_boolean (bool v_boolean);
 473                 public bool get_boolean ();
 474                 public void set_char (char v_char);
 475                 public char get_char ();
 476                 public void set_schar (int8 v_char);
 477                 public int8 get_schar ();
 478                 public void set_uchar (uchar v_uchar);
 479                 public uchar get_uchar ();
 480                 public void set_int (int v_int);
 481                 public int get_int ();
 482                 public void set_uint (uint v_uint);
 483                 public uint get_uint ();
 484                 public void set_long (long v_long);
 485                 public long get_long ();
 486                 public void set_ulong (ulong v_ulong);
 487                 public ulong get_ulong ();
 488                 public void set_int64 (int64 v_int64);
 489                 public int64 get_int64 ();
 490                 public void set_uint64 (uint64 v_uint64);
 491                 public uint64 get_uint64 ();
 492                 public void set_float (float v_float);
 493                 public float get_float ();
 494                 public void set_double (double v_double);
 495                 public double get_double ();
 496                 public void set_enum (int v_enum);
 497                 public int get_enum ();
 498                 public void set_flags (uint v_flags);
 499                 public uint get_flags ();
 500                 public void set_string (string v_string);
 501                 public void set_static_string (string v_string);
 502                 public void take_string (owned string v_string);
 503                 public unowned string get_string ();
 504                 public string dup_string ();
 505                 public void set_pointer (void* v_pointer);
 506                 public void* get_pointer ();
 507                 public void set_boxed (void* v_boxed);
 508                 public void* get_boxed ();
 509                 public void* dup_boxed ();
 510                 public void set_object (Object v_object);
 511                 public void take_object (owned Object v_object);
 512                 public unowned Object get_object ();
 513                 public Object dup_object ();
 514                 public void set_gtype (Type v_gtype);
 515                 public Type get_gtype ();
 516                 public void set_param(ParamSpec param);
 517                 public ParamSpec get_param();
 518                 public void take_param(out ParamSpec param);
 519                 public void param_take_ownership(out ParamSpec param);
 520         }
 521
 522         public struct SignalInvocationHint {
 523                 public uint signal_id;
 524                 public Quark detail;
 525                 public SignalFlags run_type;
 526         }
 527
 528         public delegate bool SignalEmissionHook (SignalInvocationHint ihint, [CCode (array_length_pos = 1.9)] Value[] param_values);
 529
 530         [CCode (cprefix = "G_SIGNAL_", has_type_id = false)]
 531         [Flags]
 532         public enum SignalFlags {
 533                 RUN_FIRST,
 534                 RUN_LAST,
 535                 RUN_CLEANUP,
 536                 NO_RECURSE,
 537                 DETAILED,
 538                 ACTION,
 539                 NO_HOOKS,
 540                 MUST_COLLECT,
 541                 DEPRECATED
 542         }
 543
 544         [CCode (cprefix = "G_CONNECT_", has_type_id = false)]
 545         [Flags]
 546         public enum ConnectFlags {
 547                 AFTER,
 548                 SWAPPED
 549         }
 550
 551         [CCode (has_target = false)]
 552         public delegate void Callback ();
 553
 554         [Compact]
 555         [CCode (ref_function = "g_closure_ref", unref_function = "g_closure_unref", type_id = "G_TYPE_CLOSURE")]
 556         public class Closure {
 557                 public void sink ();
 558                 public void invoke (out Value? return_value, [CCode (array_length_pos = 1.9)] Value[] param_values, void *invocation_hint);
 559                 public void invalidate ();
 560                 public void add_finalize_notifier (void *notify_data, ClosureNotify notify_func);
 561                 public void add_invalidate_notifier (void *notify_data, ClosureNotify notify_func);
 562                 public void remove_finalize_notifier (void *notify_data, ClosureNotify notify_func);
 563                 public void remove_invalidate_notifier (void *notify_data, ClosureNotify notify_func);
 564                 [CCode (cname = "g_closure_new_object")]
 565                 public Closure (ulong sizeof_closure, Object object);
 566                 public void set_marshal (ClosureMarshal marshal);
 567                 public void add_marshal_guards (void *pre_marshal_data, ClosureNotify pre_marshal_notify, void *post_marshal_data, ClosureNotify post_marshal_notify);
 568                 public void set_meta_marshal (void *marshal_data, ClosureMarshal meta_marshal);
 569                 [CCode (cname = "sizeof(GClosure)")]
 570                 public static size_t SIZE;
 571         }
 572
 573         [CCode (has_target = false)]
 574         public delegate void ClosureNotify (void* data, Closure closure);
 575
 576         [CCode (instance_pos = 0, has_target = false)]
 577         public delegate void ClosureMarshal (Closure closure, out Value return_value, [CCode (array_length_pos = 2.9)] Value[] param_values, void *invocation_hint, void *marshal_data);
 578
 579         [Compact]
 580         [CCode (type_id = "G_TYPE_VALUE_ARRAY", copy_function = "g_value_array_copy", free_function = "g_value_array_free")]
 581         public class ValueArray {
 582                 public uint n_values;
 583                 [CCode (array_length_cname = "n_values", array_length_type = "guint")]
 584                 public Value[] values;
 585                 public ValueArray (uint n_prealloced);
 586                 public ValueArray copy ();
 587                 public unowned Value? get_nth (uint index_);
 588                 public void append (Value value);
 589                 public void prepend (Value value);
 590                 public void insert (uint index_, Value value);
 591                 public void remove (uint index_);
 592                 public void sort (CompareFunc compare_func);
 593                 public void sort_with_data (CompareDataFunc compare_func);
 594         }
 595
 596         namespace Signal {
 597                 public static void query (uint signal_id, out SignalQuery query);
 598                 public static uint lookup (string name, Type itype);
 599                 public static unowned string name (uint signal_id);
 600                 public static uint[] list_ids (Type itype);
 601                 public static void emit (void* instance, uint signal_id, Quark detail, ...);
 602                 public static void emit_by_name (void* instance, string detailed_signal, ...);
 603                 public static ulong connect (void* instance, string detailed_signal, Callback handler, void* data);
 604                 public static ulong connect_after (void* instance, string detailed_signal, Callback handler, void* data);
 605                 public static ulong connect_swapped (void* instance, string detailed_signal, Callback handler, void* data);
 606                 public static ulong connect_object (void* instance, string detailed_signal, Callback handler, Object gobject, ConnectFlags flags);
 607                 public static ulong connect_data (void* instance, string detailed_signal, Callback handler, void* data, ClosureNotify destroy_data, ConnectFlags flags);
 608                 public static ulong connect_closure (void* instance, string detailed_signal, Closure closure, bool after);
 609                 public static ulong connect_closure_by_id (void* instance, uint signal_id, Quark detail, Closure closure, bool after);
 610                 public static bool has_handler_pending (void* instance, uint signal_id, Quark detail, bool may_be_blocked);
 611                 public static void stop_emission (void* instance, uint signal_id, Quark detail);
 612                 public static void stop_emission_by_name (void* instance, string detailed_signal);
 613                 public static void override_class_closure (uint signal_id, Type instance_type, Closure class_closure);
 614                 public static void chain_from_overridden ([CCode (array_length = false)] Value[] instance_and_params, out Value return_value);
 615                 public static ulong add_emission_hook (uint signal_id, Quark detail, SignalEmissionHook hook_func, DestroyNotify? data_destroy);
 616                 public static void remove_emission_hook (uint signal_id, ulong hook_id);
 617                 public static bool parse_name (string detailed_signal, Type itype, out uint signal_id, out Quark detail, bool force_detail_quark);
 618                 public static unowned SignalInvocationHint? get_invocation_hint (void* instance);
 619         }
 620
 621         namespace SignalHandler {
 622                 public static void block (void* instance, ulong handler_id);
 623                 public static void unblock (void* instance, ulong handler_id);
 624                 public static void disconnect (void* instance, ulong handler_id);
 625                 public static ulong find (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data);
 626                 public static bool is_connected (void* instance, ulong handler_id);
 627
 628                 [CCode (cname = "g_signal_handlers_block_matched")]
 629                 public static uint block_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data);
 630                 [CCode (cname = "g_signal_handlers_unblock_matched")]
 631                 public static uint unblock_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data);
 632                 [CCode (cname = "g_signal_handlers_disconnect_matched")]
 633                 public static uint disconnect_matched (void* instance, SignalMatchType mask, uint signal_id, Quark detail, Closure? closure, void* func, void* data);
 634                 [CCode (cname = "g_signal_handlers_block_by_func")]
 635                 public static uint block_by_func (void* instance, void* func, void* data);
 636                 [CCode (cname = "g_signal_handlers_unblock_by_func")]
 637                 public static uint unblock_by_func (void* instance, void* func, void* data);
 638                 [CCode (cname = "g_signal_handlers_disconnect_by_func")]
 639                 public static uint disconnect_by_func (void* instance, void* func, void* data);
 640         }
 641
 642         public struct SignalQuery {
 643                 public uint signal_id;
 644                 public unowned string signal_name;
 645                 public Type itype;
 646                 public SignalFlags signal_flags;
 647                 public Type return_type;
 648                 public uint n_params;
 649                 [CCode (array_length = false)]
 650                 public unowned Type[] param_types;
 651         }
 652
 653         [CCode (cprefix = "G_SIGNAL_MATCH_", has_type_id = false)]
 654         public enum SignalMatchType {
 655                 ID,
 656                 DETAIL,
 657                 CLOSURE,
 658                 FUNC,
 659                 DATA,
 660                 UNBLOCKED
 661         }
 662 }