← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vala/maverick

« back to all changes in this revision

Viewing changes to vapi/gobject-2.0.vapi

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-04-02 10:10:55 UTC
  • mfrom: (1.4.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20100402101055-qbx3okzv0tnp3wpp
Tags: 0.8.0-0ubuntu1
* New upstream release:
  - Infer type arguments when calling generic methods.
  - Support `in' operator for arrays.
  - Add experimental support for regular expression literals.
  - Add experimental support for chained relational expressions.
  - Add va_list support.
  - Add clutter-gtk-0.10 bindings (Gordon Allott).
  - Add gdl-1.0 bindings (Nicolas Joseph).
  - Add gstreamer-app-0.10 bindings (Sebastian Dröge).
  - Add gstreamer-cdda-0.10 bindings (Sebastian Dröge).
  - Add gudev-1.0 bindings (Jim Nelson).
  - Add libgda-report-4.0 bindings (Shawn Ferris).
  - Add libgvc (graphviz) bindings (Martin Olsson).
  - Add purple bindings (Adrien Bustany).
  - Many bug fixes and binding updates.
* debian/patches/99_ltmain_as-needed.patch: refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
vapi/gobject-2.0.vapi
1
1
/* gobject-2.0.vala
2
2
 *
3
 
 * Copyright (C) 2006-2009  Jürg Billeter
 
3
 * Copyright (C) 2006-2010  Jürg Billeter
4
4
 * Copyright (C) 2006-2008  Raffaele Sandrini
5
5
 * Copyright (C) 2007  Mathias Hasselmann
6
6
 *
57
57
                public static Type from_name (string name);
58
58
                public Type[] interfaces ();
59
59
                public bool is_a (Type is_a_type);
60
 
                public weak string name ();
 
60
                public unowned string name ();
61
61
                public Quark qname ();
62
62
                public Type parent ();
63
63
 
64
64
                public void query (out TypeQuery query);
65
65
 
66
66
                public TypeClass class_ref ();
67
 
                public weak TypeClass class_peek ();
 
67
                public unowned TypeClass class_peek ();
68
68
 
69
69
                public const Type INVALID;
70
70
                public const Type INTERFACE;
75
75
 
76
76
        public struct TypeQuery {
77
77
                public Type type;
78
 
                public weak string type_name;
 
78
                public unowned string type_name;
79
79
                public uint class_size;
80
80
                public uint instance_size;
81
81
        }
109
109
                public virtual void unload ();
110
110
        }
111
111
 
112
 
        [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")]
 
112
        [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")]
113
113
        public class ParamSpec {
114
114
                public string name;
115
115
                public ParamFlags flags;
130
130
                public bool value_convert (Value src_value, Value dest_value, bool strict_validation);
131
131
                [CCode (cname = "g_param_values_cmp")]
132
132
                public int values_cmp (Value value1, Value value2);
133
 
                public weak string get_blurb ();
134
 
                public weak string get_name ();
135
 
                public weak string get_nick ();
 
133
                public unowned string get_blurb ();
 
134
                public unowned string get_name ();
 
135
                public unowned string get_nick ();
136
136
                public void* get_qdata (Quark quark);
137
137
                public void set_qdata (Quark quark, void* data);
138
138
                public void set_qdata_full (Quark quark, void* data, DestroyNotify destroy);
229
229
        public class ParamSpecEnum : ParamSpec {
230
230
                [CCode (cname = "g_param_spec_enum")]
231
231
                public ParamSpecEnum (string name, string nick, string blurb, Type enum_type, int default_value, ParamFlags flags);
232
 
                public weak EnumClass enum_class;
 
232
                public unowned EnumClass enum_class;
233
233
                public int default_value;
234
234
        }
235
235
 
236
236
        public class ParamSpecFlags : ParamSpec {
237
237
                [CCode (cname = "g_param_spec_flags")]
238
238
                public ParamSpecFlags (string name, string nick, string blurb, Type flags_type, uint default_value, ParamFlags flags);
239
 
                public weak FlagsClass flags_class;
 
239
                public unowned FlagsClass flags_class;
240
240
                public uint default_value;
241
241
        }
242
242
 
272
272
 
273
273
        [CCode (lower_case_csuffix = "object_class")]
274
274
        public class ObjectClass : TypeClass {
275
 
                public weak ParamSpec? find_property (string property_name);
 
275
                public unowned ParamSpec? find_property (string property_name);
276
276
                [CCode (array_length_type = "guint")]
277
 
                public weak ParamSpec[] list_properties ();
 
277
                public unowned ParamSpec[] list_properties ();
278
278
                public void install_property (uint property_id, ParamSpec pspec);
279
279
        }
280
280
        
285
285
        public delegate void ObjectGetPropertyFunc (Object object, uint property_id, Value value, ParamSpec pspec);
286
286
        [CCode (has_target = false)]
287
287
        public delegate void ObjectSetPropertyFunc (Object object, uint property_id, Value value, ParamSpec pspec);
288
 
        [CCode (has_target = false)]
289
 
        public delegate void WeakNotify (void *data, Object object);
 
288
        [CCode (instance_pos = 0)]
 
289
        public delegate void WeakNotify (Object object);
290
290
 
291
 
        [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", param_spec_function = "g_param_spec_object", cheader_filename = "glib-object.h")]
 
291
        [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")]
292
292
        public class Object {
293
293
                public uint ref_count;
294
294
 
295
295
                [CCode (has_new_function = false, construct_function = "g_object_new")]
296
296
                public Object (...);
297
297
 
298
 
#if VALA_0_7_6_NEW_METHODS
299
298
                public static Object @new (Type type, ...);
300
 
#endif
301
299
                public static Object newv (Type type, [CCode (array_length_pos = 1.9)] Parameter[] parameters);
302
300
 
303
301
                [CCode (cname = "G_TYPE_FROM_INSTANCE")]
304
302
                public Type get_type ();
305
303
                [CCode (cname = "G_OBJECT_GET_CLASS")]
306
304
                public unowned ObjectClass get_class ();
307
 
                public weak Object @ref ();
 
305
                public unowned Object @ref ();
308
306
                public void unref ();
309
307
                public Object ref_sink ();
310
 
                public void weak_ref (WeakNotify notify, void *data);
311
 
                public void weak_unref (WeakNotify notify, void *data);
 
308
                public void weak_ref (WeakNotify notify);
 
309
                public void weak_unref (WeakNotify notify);
312
310
                public void add_weak_pointer (void **data);
313
311
                public void remove_weak_pointer (void **data);
314
312
                public void get (string first_property_name, ...);
315
313
                public void set (string first_property_name, ...);
316
314
                public void get_property (string property_name, ref Value value);
317
315
                public void set_property (string property_name, Value value);
318
 
                public void* get_data (string key);
319
 
                public void set_data (string key, void* data);
 
316
                [CCode (simple_generics = true)]
 
317
                public unowned T get_data<T> (string key);
 
318
                [CCode (cname = "g_object_set_data_full", simple_generics = true)]
 
319
                public void set_data<T> (string key, owned T data);
320
320
                public void set_data_full (string key, void* data, DestroyNotify? destroy);
321
 
                public void* steal_data (string key);
322
 
                public void* get_qdata (Quark quark);
323
 
                public void set_qdata (Quark quark, void* data);
 
321
                [CCode (simple_generics = true)]
 
322
                public T steal_data<T> (string key);
 
323
                [CCode (simple_generics = true)]
 
324
                public unowned T get_qdata<T> (Quark quark);
 
325
                [CCode (cname = "g_object_set_qdata_full", simple_generics = true)]
 
326
                public void set_qdata<T> (Quark quark, owned T data);
324
327
                public void set_qdata_full (Quark quark, void* data, DestroyNotify? destroy);
325
 
                public void* steal_qdata (Quark quark);
 
328
                [CCode (simple_generics = true)]
 
329
                public T steal_qdata<T> (Quark quark);
326
330
                public void freeze_notify ();
327
331
                public void thaw_notify ();
328
332
                [CCode (cname = "g_object_run_dispose")]
329
333
                public virtual void dispose ();
330
 
                public virtual void finalize ();
331
334
                public virtual void constructed ();
332
335
 
333
336
                public signal void notify (ParamSpec pspec);
334
337
                [CCode (cname = "g_object_notify")]
335
338
                public void notify_property (string property_name);
336
339
 
337
 
                public weak Object connect (string signal_spec, ...);
 
340
                public unowned Object connect (string signal_spec, ...);
 
341
                [CCode (cname = "g_signal_handler_disconnect")]
 
342
                public void disconnect (ulong handler_id);
338
343
 
339
344
                public void add_toggle_ref (ToggleNotify notify);
340
345
                public void remove_toggle_ref (ToggleNotify notify);
360
365
 
361
366
        [CCode (lower_case_csuffix = "enum")]
362
367
        public class EnumClass : TypeClass {
363
 
                public weak EnumValue? get_value (int value);
364
 
                public weak EnumValue? get_value_by_name (string name);
365
 
                public weak EnumValue? get_value_by_nick (string name);
 
368
                public unowned EnumValue? get_value (int value);
 
369
                public unowned EnumValue? get_value_by_name (string name);
 
370
                public unowned EnumValue? get_value_by_nick (string name);
366
371
                public int minimum;
367
372
                public int maximum;
368
373
                public uint n_values;
369
 
                public weak EnumValue[] values;
 
374
                public unowned EnumValue[] values;
370
375
        }
371
376
 
372
377
        [Compact]
373
378
        public class EnumValue {
374
379
                public int value;
375
 
                public weak string value_name;
376
 
                public weak string value_nick;
 
380
                public unowned string value_name;
 
381
                public unowned string value_nick;
377
382
        }
378
383
 
379
384
        [CCode (lower_case_csuffix = "flags")]
380
385
        public class FlagsClass : TypeClass {
381
 
                public weak FlagsValue? get_first_value (uint value);
382
 
                public weak FlagsValue? get_value_by_name (string name);
383
 
                public weak FlagsValue? get_value_by_nick (string name);
 
386
                public unowned FlagsValue? get_first_value (uint value);
 
387
                public unowned FlagsValue? get_value_by_name (string name);
 
388
                public unowned FlagsValue? get_value_by_nick (string name);
384
389
                public uint mask;
385
390
                public uint n_values;
386
391
                public FlagsValue[] values;
389
394
        [Compact]
390
395
        public class FlagsValue {
391
396
                public int value;
392
 
                public weak string value_name;
393
 
                public weak string value_nick;
 
397
                public unowned string value_name;
 
398
                public unowned string value_nick;
394
399
        }
395
400
 
396
401
        [CCode (has_target = false)]
397
402
        public delegate void ValueTransform (Value src_value, out Value dest_value);
398
403
 
399
 
        [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", type_signature = "v")]
 
404
        [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")]
400
405
        public struct Value {
401
406
                [CCode (cname = "G_VALUE_HOLDS")]
402
407
                public bool holds (Type type);
403
408
                [CCode (cname = "G_VALUE_TYPE")]
404
409
                public Type type ();
405
410
                [CCode (cname = "G_VALUE_TYPE_NAME")]
406
 
                public weak string type_name ();
 
411
                public unowned string type_name ();
407
412
 
408
413
                public Value (Type g_type);
409
414
                public void copy (ref Value dest_value);
410
 
                public weak Value? reset ();
 
415
                public unowned Value? reset ();
411
416
                public void init (Type g_type);
412
417
                public void unset ();
413
418
                public void set_instance (void* instance);
448
453
                public void set_string (string v_string);
449
454
                public void set_static_string (string v_string);
450
455
                public void take_string (owned string v_string);
451
 
                public weak string get_string ();
 
456
                public unowned string get_string ();
452
457
                public string dup_string ();
453
458
                public void set_pointer (void* v_pointer);
454
459
                public void* get_pointer ();
457
462
                public void* dup_boxed ();
458
463
                public void set_object (Object v_object);
459
464
                public void take_object (owned Object v_object);
460
 
                public weak Object get_object ();
 
465
                public unowned Object get_object ();
461
466
                public Object dup_object ();
462
467
                public void set_gtype (Type v_gtype);
463
468
                public Type get_gtype ();
503
508
        public delegate void ClosureNotify (void* data, Closure closure);
504
509
 
505
510
        [Compact]
506
 
        [CCode (type_id = "G_TYPE_VALUE_ARRAY", copy_function = "g_value_array_copy")]
 
511
        [CCode (type_id = "G_TYPE_VALUE_ARRAY", copy_function = "g_value_array_copy", free_function = "g_value_array_free")]
507
512
        public class ValueArray {
508
513
                public uint n_values;
509
514
                [CCode (array_length_cname = "n_values", array_length_type = "guint")]
510
515
                public Value[] values;
511
516
                public ValueArray (uint n_prealloced);
512
517
                public ValueArray copy ();
513
 
                public weak Value? get_nth (uint index_);
 
518
                public unowned Value? get_nth (uint index_);
514
519
                public void append (Value value);
515
520
                public void prepend (Value value);
516
521
                public void insert (uint index_, Value value);
522
527
        namespace Signal {
523
528
                public static void query (uint signal_id, out SignalQuery query);
524
529
                public static uint lookup (string name, Type itype);
525
 
                public static weak string name (uint signal_id);
 
530
                public static unowned string name (uint signal_id);
526
531
                public static uint[] list_ids (Type itype);
527
532
                public static void emit (void* instance, uint signal_id, Quark detail, ...);
528
533
                public static void emit_by_name (void* instance, string detailed_signal, ...);
566
571
 
567
572
        public struct SignalQuery {
568
573
                public uint signal_id;
569
 
                public weak string signal_name;
 
574
                public unowned string signal_name;
570
575
                public Type itype;
571
576
                public SignalFlags signal_flags;
572
577
                public Type return_type;
573
578
                public uint n_params;
574
579
                [CCode (array_length = false)]
575
 
                public weak Type[] param_types;
 
580
                public unowned Type[] param_types;
576
581
        }
577
582
 
578
583
        [CCode (cprefix = "G_SIGNAL_MATCH_", has_type_id = false)]