git.roojs.org Git - app.Builder.js/blob - src/vapi/gobject-introspection-1.0.vapi

   1 /* gobject-introspection-1.0.vapi generated by vapigen, do not modify. */
   2
   3 [CCode (cprefix = "GI", gir_namespace = "GIRepository", gir_version = "2.0", lower_case_cprefix = "g_")]
   4 namespace GI {
   5         [CCode (cheader_filename = "girepository.h")]
   6         public class ArgInfo : GI.BaseInfo {
   7                 [CCode (has_construct_function = false)]
   8                 protected ArgInfo ();
   9                 public static int get_closure (GI.ArgInfo info);
  10                 public static int get_destroy (GI.ArgInfo info);
  11                 public static GI.Direction get_direction (GI.ArgInfo info);
  12                 public static GI.Transfer get_ownership_transfer (GI.ArgInfo info);
  13                 public static GI.ScopeType get_scope (GI.ArgInfo info);
  14                 public static GI.TypeInfo get_type (GI.ArgInfo info);
  15                 public static bool is_caller_allocates (GI.ArgInfo info);
  16                 public static bool is_optional (GI.ArgInfo info);
  17                 public static bool is_return_value (GI.ArgInfo info);
  18                 public static bool is_skip (GI.ArgInfo info);
  19                 public static void load_type (GI.ArgInfo info, out unowned GI.TypeInfo type);
  20                 public static bool may_be_null (GI.ArgInfo info);
  21         }
  22         [CCode (cheader_filename = "girepository.h", copy_function = "g_boxed_copy", free_function = "g_boxed_free", lower_case_csuffix = "base_info_gtype", type_id = "g_base_info_gtype_get_type ()")]
  23         [Compact]
  24         public class BaseInfo {
  25                 [CCode (cname = "g_base_info_equal")]
  26                 public bool equal (GI.BaseInfo info2);
  27                 [CCode (cname = "g_base_info_get_attribute")]
  28                 public unowned string get_attribute (string name);
  29                 [CCode (cname = "g_base_info_get_container")]
  30                 public unowned GI.BaseInfo get_container ();
  31                 [CCode (cname = "g_base_info_get_name")]
  32                 public unowned string get_name ();
  33                 [CCode (cname = "g_base_info_get_namespace")]
  34                 public unowned string get_namespace ();
  35                 [CCode (cname = "g_base_info_get_type")]
  36                 public GI.InfoType get_type ();
  37                 [CCode (cname = "g_base_info_get_typelib")]
  38                 public unowned GI.Typelib get_typelib ();
  39                 [CCode (cname = "g_base_info_is_deprecated")]
  40                 public bool is_deprecated ();
  41                 [CCode (cname = "g_base_info_iterate_attributes")]
  42                 public bool iterate_attributes (GI.AttributeIter iterator, out unowned string name, out unowned string value);
  43         }
  44         [CCode (cheader_filename = "girepository.h")]
  45         public class CallableInfo : GI.BaseInfo {
  46                 [CCode (has_construct_function = false)]
  47                 protected CallableInfo ();
  48                 public static bool can_throw_gerror (GI.CallableInfo info);
  49                 public static GI.ArgInfo get_arg (GI.CallableInfo info, int n);
  50                 public static GI.Transfer get_caller_owns (GI.CallableInfo info);
  51                 public static int get_n_args (GI.CallableInfo info);
  52                 public static unowned string get_return_attribute (GI.CallableInfo info, string name);
  53                 public static GI.TypeInfo get_return_type (GI.CallableInfo info);
  54                 public static bool invoke (GI.CallableInfo info, void* function, GI.Argument in_args, int n_in_args, GI.Argument out_args, int n_out_args, GI.Argument return_value, bool is_method, bool @throws) throws GLib.Error;
  55                 public static bool is_method (GI.CallableInfo info);
  56                 public static bool iterate_return_attributes (GI.CallableInfo info, GI.AttributeIter iterator, out unowned string name, out unowned string value);
  57                 public static void load_arg (GI.CallableInfo info, int n, out unowned GI.ArgInfo arg);
  58                 public static void load_return_type (GI.CallableInfo info, out unowned GI.TypeInfo type);
  59                 public static bool may_return_null (GI.CallableInfo info);
  60                 public static bool skip_return (GI.CallableInfo info);
  61         }
  62         [CCode (cheader_filename = "girepository.h")]
  63         public class CallbackInfo : GI.BaseInfo {
  64                 [CCode (has_construct_function = false)]
  65                 protected CallbackInfo ();
  66         }
  67         [CCode (cheader_filename = "girepository.h")]
  68         public class ConstantInfo : GI.BaseInfo {
  69                 [CCode (has_construct_function = false)]
  70                 protected ConstantInfo ();
  71                 public static GI.TypeInfo get_type (GI.ConstantInfo info);
  72         }
  73         [CCode (cheader_filename = "girepository.h")]
  74         public class EnumInfo : GI.BaseInfo {
  75                 [CCode (has_construct_function = false)]
  76                 protected EnumInfo ();
  77                 public static unowned string get_error_domain (GI.EnumInfo info);
  78                 public static GI.FunctionInfo get_method (GI.EnumInfo info, int n);
  79                 public static int get_n_methods (GI.EnumInfo info);
  80                 public static int get_n_values (GI.EnumInfo info);
  81                 public static GI.TypeTag get_storage_type (GI.EnumInfo info);
  82                 public static GI.ValueInfo get_value (GI.EnumInfo info, int n);
  83         }
  84         [CCode (cheader_filename = "girepository.h")]
  85         public class FieldInfo : GI.BaseInfo {
  86                 [CCode (has_construct_function = false)]
  87                 protected FieldInfo ();
  88                 public static GI.FieldInfoFlags get_flags (GI.FieldInfo info);
  89                 public static int get_offset (GI.FieldInfo info);
  90                 public static int get_size (GI.FieldInfo info);
  91                 public static GI.TypeInfo get_type (GI.FieldInfo info);
  92         }
  93         [CCode (cheader_filename = "girepository.h")]
  94         public class FunctionInfo : GI.BaseInfo {
  95                 [CCode (has_construct_function = false)]
  96                 protected FunctionInfo ();
  97                 public static GI.FunctionInfoFlags get_flags (GI.FunctionInfo info);
  98                 public static GI.PropertyInfo get_property (GI.FunctionInfo info);
  99                 public static unowned string get_symbol (GI.FunctionInfo info);
 100                 public static GI.VFuncInfo get_vfunc (GI.FunctionInfo info);
 101         }
 102         [CCode (cheader_filename = "girepository.h")]
 103         public class InterfaceInfo : GI.BaseInfo {
 104                 [CCode (has_construct_function = false)]
 105                 protected InterfaceInfo ();
 106                 public static GI.FunctionInfo find_method (GI.InterfaceInfo info, string name);
 107                 public static GI.SignalInfo find_signal (GI.InterfaceInfo info, string name);
 108                 public static GI.VFuncInfo find_vfunc (GI.InterfaceInfo info, string name);
 109                 public static GI.ConstantInfo get_constant (GI.InterfaceInfo info, int n);
 110                 public static GI.StructInfo get_iface_struct (GI.InterfaceInfo info);
 111                 public static GI.FunctionInfo get_method (GI.InterfaceInfo info, int n);
 112                 public static int get_n_constants (GI.InterfaceInfo info);
 113                 public static int get_n_methods (GI.InterfaceInfo info);
 114                 public static int get_n_prerequisites (GI.InterfaceInfo info);
 115                 public static int get_n_properties (GI.InterfaceInfo info);
 116                 public static int get_n_signals (GI.InterfaceInfo info);
 117                 public static int get_n_vfuncs (GI.InterfaceInfo info);
 118                 public static GI.BaseInfo get_prerequisite (GI.InterfaceInfo info, int n);
 119                 public static GI.PropertyInfo get_property (GI.InterfaceInfo info, int n);
 120                 public static GI.SignalInfo get_signal (GI.InterfaceInfo info, int n);
 121                 public static GI.VFuncInfo get_vfunc (GI.InterfaceInfo info, int n);
 122         }
 123         [CCode (cheader_filename = "girepository.h")]
 124         public class ObjectInfo : GI.BaseInfo {
 125                 [CCode (has_construct_function = false)]
 126                 protected ObjectInfo ();
 127                 public static GI.FunctionInfo find_method (GI.ObjectInfo info, string name);
 128                 public static GI.FunctionInfo find_method_using_interfaces (GI.ObjectInfo info, string name, out GI.ObjectInfo implementor);
 129                 public static GI.SignalInfo find_signal (GI.ObjectInfo info, string name);
 130                 public static GI.VFuncInfo find_vfunc (GI.ObjectInfo info, string name);
 131                 public static GI.VFuncInfo find_vfunc_using_interfaces (GI.ObjectInfo info, string name, out GI.ObjectInfo implementor);
 132                 public static bool get_abstract (GI.ObjectInfo info);
 133                 public static GI.StructInfo get_class_struct (GI.ObjectInfo info);
 134                 public static GI.ConstantInfo get_constant (GI.ObjectInfo info, int n);
 135                 public static GI.FieldInfo get_field (GI.ObjectInfo info, int n);
 136                 public static bool get_fundamental (GI.ObjectInfo info);
 137                 public static unowned string get_get_value_function (GI.ObjectInfo info);
 138                 public static GI.InterfaceInfo get_interface (GI.ObjectInfo info, int n);
 139                 public static GI.FunctionInfo get_method (GI.ObjectInfo info, int n);
 140                 public static int get_n_constants (GI.ObjectInfo info);
 141                 public static int get_n_fields (GI.ObjectInfo info);
 142                 public static int get_n_interfaces (GI.ObjectInfo info);
 143                 public static int get_n_methods (GI.ObjectInfo info);
 144                 public static int get_n_properties (GI.ObjectInfo info);
 145                 public static int get_n_signals (GI.ObjectInfo info);
 146                 public static int get_n_vfuncs (GI.ObjectInfo info);
 147                 public static GI.ObjectInfo get_parent (GI.ObjectInfo info);
 148                 public static GI.PropertyInfo get_property (GI.ObjectInfo info, int n);
 149                 public static unowned string get_ref_function (GI.ObjectInfo info);
 150                 public static unowned string get_set_value_function (GI.ObjectInfo info);
 151                 public static GI.SignalInfo get_signal (GI.ObjectInfo info, int n);
 152                 public static unowned string get_type_init (GI.ObjectInfo info);
 153                 public static unowned string get_type_name (GI.ObjectInfo info);
 154                 public static unowned string get_unref_function (GI.ObjectInfo info);
 155                 public static GI.VFuncInfo get_vfunc (GI.ObjectInfo info, int n);
 156         }
 157         [CCode (cheader_filename = "girepository.h")]
 158         public class PropertyInfo : GI.BaseInfo {
 159                 [CCode (has_construct_function = false)]
 160                 protected PropertyInfo ();
 161                 public static GLib.ParamFlags get_flags (GI.PropertyInfo info);
 162                 public static GI.Transfer get_ownership_transfer (GI.PropertyInfo info);
 163                 public static GI.TypeInfo get_type (GI.PropertyInfo info);
 164         }
 165         [CCode (cheader_filename = "girepository.h")]
 166         public class RegisteredTypeInfo : GI.BaseInfo {
 167                 [CCode (has_construct_function = false)]
 168                 protected RegisteredTypeInfo ();
 169                 public static GLib.Type get_g_type (GI.RegisteredTypeInfo info);
 170                 public static unowned string get_type_init (GI.RegisteredTypeInfo info);
 171                 public static unowned string get_type_name (GI.RegisteredTypeInfo info);
 172         }
 173         [CCode (cheader_filename = "girepository.h", lower_case_csuffix = "irepository", type_id = "g_irepository_get_type ()")]
 174         public class Repository : GLib.Object {
 175                 [CCode (has_construct_function = false)]
 176                 protected Repository ();
 177                 public static bool dump (string arg) throws GLib.Error;
 178                 public GLib.List<string> enumerate_versions (string namespace_);
 179                 public static GLib.Quark error_quark ();
 180                 public GI.EnumInfo find_by_error_domain (GLib.Quark domain);
 181                 public GI.BaseInfo find_by_gtype (GLib.Type gtype);
 182                 public GI.BaseInfo find_by_name (string namespace_, string name);
 183                 public unowned string get_c_prefix (string namespace_);
 184                 public static unowned GI.Repository get_default ();
 185                 [CCode (array_length = false, array_null_terminated = true)]
 186                 public string[] get_dependencies (string namespace_);
 187                 public GI.BaseInfo get_info (string namespace_, int index);
 188                 [CCode (array_length = false, array_null_terminated = true)]
 189                 public string[] get_loaded_namespaces ();
 190                 public int get_n_infos (string namespace_);
 191                 public static unowned GLib.SList<string> get_search_path ();
 192                 public unowned string get_shared_library (string namespace_);
 193                 public unowned string get_typelib_path (string namespace_);
 194                 public unowned string get_version (string namespace_);
 195                 public bool is_registered (string namespace_, string? version);
 196                 public unowned string load_typelib (GI.Typelib typelib, GI.RepositoryLoadFlags flags) throws GLib.Error;
 197                 public static void prepend_library_path (string directory);
 198                 public static void prepend_search_path (string directory);
 199                 public unowned GI.Typelib require (string namespace_, string? version, GI.RepositoryLoadFlags flags) throws GLib.Error;
 200                 public unowned GI.Typelib require_private (string typelib_dir, string namespace_, string? version, GI.RepositoryLoadFlags flags) throws GLib.Error;
 201         }
 202         [CCode (cheader_filename = "girepository.h")]
 203         public class SignalInfo : GI.BaseInfo {
 204                 [CCode (has_construct_function = false)]
 205                 protected SignalInfo ();
 206                 public static GI.VFuncInfo get_class_closure (GI.SignalInfo info);
 207                 public static GLib.SignalFlags get_flags (GI.SignalInfo info);
 208                 public static bool true_stops_emit (GI.SignalInfo info);
 209         }
 210         [CCode (cheader_filename = "girepository.h")]
 211         public class StructInfo : GI.BaseInfo {
 212                 [CCode (has_construct_function = false)]
 213                 protected StructInfo ();
 214                 public static GI.FunctionInfo find_method (GI.StructInfo info, string name);
 215                 public static size_t get_alignment (GI.StructInfo info);
 216                 public static GI.FieldInfo get_field (GI.StructInfo info, int n);
 217                 public static GI.FunctionInfo get_method (GI.StructInfo info, int n);
 218                 public static int get_n_fields (GI.StructInfo info);
 219                 public static int get_n_methods (GI.StructInfo info);
 220                 public static size_t get_size (GI.StructInfo info);
 221                 public static bool is_foreign (GI.StructInfo info);
 222                 public static bool is_gtype_struct (GI.StructInfo info);
 223         }
 224         [CCode (cheader_filename = "girepository.h")]
 225         public class TypeInfo : GI.BaseInfo {
 226                 [CCode (has_construct_function = false)]
 227                 protected TypeInfo ();
 228                 public static int get_array_fixed_size (GI.TypeInfo info);
 229                 public static int get_array_length (GI.TypeInfo info);
 230                 public static GI.ArrayType get_array_type (GI.TypeInfo info);
 231                 public static GI.BaseInfo get_interface (GI.TypeInfo info);
 232                 public static GI.TypeInfo get_param_type (GI.TypeInfo info, int n);
 233                 public static GI.TypeTag get_tag (GI.TypeInfo info);
 234                 public static bool is_pointer (GI.TypeInfo info);
 235                 public static bool is_zero_terminated (GI.TypeInfo info);
 236         }
 237         [CCode (cheader_filename = "girepository.h")]
 238         [Compact]
 239         public class Typelib {
 240                 public void free ();
 241                 public unowned string get_namespace ();
 242                 public bool symbol (string symbol_name, void* symbol);
 243         }
 244         [CCode (cheader_filename = "girepository.h")]
 245         public class UnionInfo : GI.BaseInfo {
 246                 [CCode (has_construct_function = false)]
 247                 protected UnionInfo ();
 248                 public static GI.FunctionInfo find_method (GI.UnionInfo info, string name);
 249                 public static size_t get_alignment (GI.UnionInfo info);
 250                 public static GI.ConstantInfo get_discriminator (GI.UnionInfo info, int n);
 251                 public static int get_discriminator_offset (GI.UnionInfo info);
 252                 public static GI.TypeInfo get_discriminator_type (GI.UnionInfo info);
 253                 public static GI.FieldInfo get_field (GI.UnionInfo info, int n);
 254                 public static GI.FunctionInfo get_method (GI.UnionInfo info, int n);
 255                 public static int get_n_fields (GI.UnionInfo info);
 256                 public static int get_n_methods (GI.UnionInfo info);
 257                 public static size_t get_size (GI.UnionInfo info);
 258                 public static bool is_discriminated (GI.UnionInfo info);
 259         }
 260         [CCode (cheader_filename = "girepository.h")]
 261         [Compact]
 262         public class UnresolvedInfo {
 263         }
 264         [CCode (cheader_filename = "girepository.h")]
 265         public class VFuncInfo : GI.BaseInfo {
 266                 [CCode (has_construct_function = false)]
 267                 protected VFuncInfo ();
 268                 public static GI.VFuncInfoFlags get_flags (GI.VFuncInfo info);
 269                 public static GI.FunctionInfo get_invoker (GI.VFuncInfo info);
 270                 public static int get_offset (GI.VFuncInfo info);
 271                 public static GI.SignalInfo get_signal (GI.VFuncInfo info);
 272         }
 273         [CCode (cheader_filename = "girepository.h")]
 274         public class ValueInfo : GI.BaseInfo {
 275                 [CCode (has_construct_function = false)]
 276                 protected ValueInfo ();
 277                 public static int64 get_value (GI.ValueInfo info);
 278         }
 279         [CCode (cheader_filename = "girepository.h")]
 280         public struct Argument {
 281                 public bool v_boolean;
 282                 public int8 v_int8;
 283                 public uint8 v_uint8;
 284                 public int16 v_int16;
 285                 public uint16 v_uint16;
 286                 public int32 v_int32;
 287                 public uint32 v_uint32;
 288                 public int64 v_int64;
 289                 public uint64 v_uint64;
 290                 public float v_float;
 291                 public double v_double;
 292                 public short v_short;
 293                 public ushort v_ushort;
 294                 public int v_int;
 295                 public uint v_uint;
 296                 public long v_long;
 297                 public ulong v_ulong;
 298                 public ssize_t v_ssize;
 299                 public size_t v_size;
 300                 public weak string v_string;
 301                 public void* v_pointer;
 302         }
 303         [CCode (cheader_filename = "girepository.h", has_type_id = false)]
 304         public struct AttributeIter {
 305         }
 306         [CCode (cheader_filename = "girepository.h", cprefix = "GI_ARRAY_TYPE_", has_type_id = false)]
 307         public enum ArrayType {
 308                 C,
 309                 ARRAY,
 310                 PTR_ARRAY,
 311                 BYTE_ARRAY
 312         }
 313         [CCode (cheader_filename = "girepository.h", cprefix = "GI_DIRECTION_", has_type_id = false)]
 314         public enum Direction {
 315                 IN,
 316                 OUT,
 317                 INOUT
 318         }
 319         [CCode (cheader_filename = "girepository.h", cprefix = "GI_FIELD_IS_", has_type_id = false)]
 320         [Flags]
 321         public enum FieldInfoFlags {
 322                 READABLE,
 323                 WRITABLE
 324         }
 325         [CCode (cheader_filename = "girepository.h", cprefix = "GI_FUNCTION_", has_type_id = false)]
 326         [Flags]
 327         public enum FunctionInfoFlags {
 328                 IS_METHOD,
 329                 IS_CONSTRUCTOR,
 330                 IS_GETTER,
 331                 IS_SETTER,
 332                 WRAPS_VFUNC,
 333                 THROWS
 334         }
 335         [CCode (cheader_filename = "girepository.h", cprefix = "GI_INFO_TYPE_", has_type_id = false)]
 336         public enum InfoType {
 337                 INVALID,
 338                 FUNCTION,
 339                 CALLBACK,
 340                 STRUCT,
 341                 BOXED,
 342                 ENUM,
 343                 FLAGS,
 344                 OBJECT,
 345                 INTERFACE,
 346                 CONSTANT,
 347                 INVALID_0,
 348                 UNION,
 349                 VALUE,
 350                 SIGNAL,
 351                 VFUNC,
 352                 PROPERTY,
 353                 FIELD,
 354                 ARG,
 355                 TYPE,
 356                 UNRESOLVED;
 357                 public static unowned string to_string (GI.InfoType type);
 358         }
 359         [CCode (cheader_filename = "girepository.h", cprefix = "G_IREPOSITORY_ERROR_", has_type_id = false)]
 360         public enum RepositoryError {
 361                 TYPELIB_NOT_FOUND,
 362                 NAMESPACE_MISMATCH,
 363                 NAMESPACE_VERSION_CONFLICT,
 364                 LIBRARY_NOT_FOUND
 365         }
 366         [CCode (cheader_filename = "girepository.h", cprefix = "G_IREPOSITORY_LOAD_FLAG_", has_type_id = false)]
 367         [Flags]
 368         public enum RepositoryLoadFlags {
 369                 [CCode (cname = "G_IREPOSITORY_LOAD_FLAG_LAZY")]
 370                 IREPOSITORY_LOAD_FLAG_LAZY
 371         }
 372         [CCode (cheader_filename = "girepository.h", cprefix = "GI_SCOPE_TYPE_", has_type_id = false)]
 373         public enum ScopeType {
 374                 INVALID,
 375                 CALL,
 376                 ASYNC,
 377                 NOTIFIED
 378         }
 379         [CCode (cheader_filename = "girepository.h", cprefix = "GI_TRANSFER_", has_type_id = false)]
 380         public enum Transfer {
 381                 NOTHING,
 382                 CONTAINER,
 383                 EVERYTHING
 384         }
 385         [CCode (cheader_filename = "girepository.h", cprefix = "GI_TYPE_TAG_", has_type_id = false)]
 386         public enum TypeTag {
 387                 VOID,
 388                 BOOLEAN,
 389                 INT8,
 390                 UINT8,
 391                 INT16,
 392                 UINT16,
 393                 INT32,
 394                 UINT32,
 395                 INT64,
 396                 UINT64,
 397                 FLOAT,
 398                 DOUBLE,
 399                 GTYPE,
 400                 UTF8,
 401                 FILENAME,
 402                 ARRAY,
 403                 INTERFACE,
 404                 GLIST,
 405                 GSLIST,
 406                 GHASH,
 407                 ERROR,
 408                 UNICHAR;
 409                 public static unowned string to_string (GI.TypeTag type);
 410         }
 411         [CCode (cheader_filename = "girepository.h", cprefix = "GI_VFUNC_", has_type_id = false)]
 412         [Flags]
 413         public enum VFuncInfoFlags {
 414                 MUST_CHAIN_UP,
 415                 MUST_OVERRIDE,
 416                 MUST_NOT_OVERRIDE,
 417                 THROWS
 418         }
 419         [CCode (cheader_filename = "girepository.h", cprefix = "G_INVOKE_ERROR_", has_type_id = false)]
 420         public enum nvokeError {
 421                 FAILED,
 422                 SYMBOL_NOT_FOUND,
 423                 ARGUMENT_MISMATCH
 424         }
 425         [CCode (cheader_filename = "girepository.h")]
 426         public static GI.BaseInfo info_new (GI.InfoType type, GI.BaseInfo container, GI.Typelib typelib, uint32 offset);
 427         [CCode (cheader_filename = "girepository.h")]
 428         public static GLib.Quark invoke_error_quark ();
 429 }