← Back to branch summary

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

« back to all changes in this revision

Viewing changes to vapi/purple.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/purple.vapi
 
1
/* purple.vapi generated by vapigen, do not modify. */
 
2
 
 
3
[CCode (cprefix = "Purple", lower_case_cprefix = "purple_")]
 
4
namespace Purple {
 
5
        [Compact]
 
6
        [CCode (free_function = "purple_account_destroy", cheader_filename = "purple.h")]
 
7
        public class Account {
 
8
                public weak string alias;
 
9
                public weak string buddy_icon_path;
 
10
                public weak GLib.SList deny;
 
11
                public bool disconnecting;
 
12
                public weak Purple.Connection gc;
 
13
                public weak string password;
 
14
                public Purple.PrivacyType perm_deny;
 
15
                public weak GLib.SList permit;
 
16
                public weak Purple.Presence presence;
 
17
                public void* priv;
 
18
                public weak string protocol_id;
 
19
                public weak Purple.ProxyInfo proxy_info;
 
20
                public weak Purple.AccountRegistrationCb registration_cb;
 
21
                public void* registration_cb_user_data;
 
22
                public bool remember_pass;
 
23
                public weak GLib.HashTable settings;
 
24
                public weak GLib.List status_types;
 
25
                public weak Purple.Log system_log;
 
26
                public void* ui_data;
 
27
                public weak GLib.HashTable ui_settings;
 
28
                public weak string user_info;
 
29
                public weak string username;
 
30
                [CCode (has_construct_function = false)]
 
31
                public Account (string username, string protocol_id);
 
32
                public void add_buddies (GLib.List buddies);
 
33
                public void add_buddy (Purple.Buddy buddy);
 
34
                public void change_password (string orig_pw, string new_pw);
 
35
                public void clear_current_error ();
 
36
                public void clear_settings ();
 
37
                public void connect ();
 
38
                public void destroy_log ();
 
39
                public void disconnect ();
 
40
                public unowned Purple.Status get_active_status ();
 
41
                public unowned string get_alias ();
 
42
                public bool get_bool (string name, bool default_value);
 
43
                public unowned string get_buddy_icon_path ();
 
44
                public bool get_check_mail ();
 
45
                public unowned Purple.Connection get_connection ();
 
46
                public unowned Purple.ConnectionErrorInfo get_current_error ();
 
47
                public bool get_enabled (string ui);
 
48
                public int get_int (string name, int default_value);
 
49
                public unowned Purple.Log get_log (bool create);
 
50
                public unowned string get_password ();
 
51
                public unowned Purple.Presence get_presence ();
 
52
                public unowned string get_protocol_id ();
 
53
                public unowned string get_protocol_name ();
 
54
                public unowned Purple.ProxyInfo get_proxy_info ();
 
55
                public bool get_remember_password ();
 
56
                public unowned Purple.Status get_status (string status_id);
 
57
                public unowned Purple.StatusType get_status_type (string id);
 
58
                public unowned Purple.StatusType get_status_type_with_primitive (Purple.StatusPrimitive primitive);
 
59
                public unowned GLib.List get_status_types ();
 
60
                public unowned string get_string (string name, string default_value);
 
61
                public bool get_ui_bool (string ui, string name, bool default_value);
 
62
                public int get_ui_int (string ui, string name, int default_value);
 
63
                public unowned string get_ui_string (string ui, string name, string default_value);
 
64
                public unowned string get_user_info ();
 
65
                public unowned string get_username ();
 
66
                public bool is_connected ();
 
67
                public bool is_connecting ();
 
68
                public bool is_disconnected ();
 
69
                public bool is_status_active (string status_id);
 
70
                public void notify_added (string remote_user, string id, string alias, string message);
 
71
                public void register ();
 
72
                public void remove_buddies (GLib.List buddies, GLib.List groups);
 
73
                public void remove_buddy (Purple.Buddy buddy, Purple.Group group);
 
74
                public void remove_group (Purple.Group group);
 
75
                public void remove_setting (string setting);
 
76
                public void request_add (string remote_user, string id, string alias, string message);
 
77
                public void* request_authorization (string remote_user, string id, string alias, string message, bool on_list, Purple.AccountRequestAuthorizationCb auth_cb, Purple.AccountRequestAuthorizationCb deny_cb);
 
78
                public void request_change_password ();
 
79
                public void request_change_user_info ();
 
80
                public static void request_close (void* ui_handle);
 
81
                public void request_close_with_account ();
 
82
                public void request_password (GLib.Callback ok_cb, GLib.Callback cancel_cb);
 
83
                public void set_alias (string alias);
 
84
                public void set_bool (string name, bool value);
 
85
                public void set_buddy_icon_path (string path);
 
86
                public void set_check_mail (bool value);
 
87
                public void set_connection (Purple.Connection gc);
 
88
                public void set_enabled (string ui, bool value);
 
89
                public void set_int (string name, int value);
 
90
                public void set_password (string password);
 
91
                public void set_protocol_id (string protocol_id);
 
92
                public void set_proxy_info (Purple.ProxyInfo info);
 
93
                public void set_register_callback (Purple.AccountRegistrationCb cb);
 
94
                public void set_remember_password (bool value);
 
95
                public void set_status (string status_id, bool active);
 
96
                public void set_status_list (string status_id, bool active, GLib.List attrs);
 
97
                public void set_status_types (GLib.List status_types);
 
98
                public void set_string (string name, string value);
 
99
                public void set_ui_bool (string ui, string name, bool value);
 
100
                public void set_ui_int (string ui, string name, int value);
 
101
                public void set_ui_string (string ui, string name, string value);
 
102
                public void set_user_info (string user_info);
 
103
                public void set_username (string username);
 
104
                public bool supports_offline_message (Purple.Buddy buddy);
 
105
                public void unregister (Purple.AccountUnregistrationCb cb);
 
106
        }
 
107
        [Compact]
 
108
        [CCode (free_function = "purple_account_option_destroy", cheader_filename = "purple.h")]
 
109
        public class AccountOption {
 
110
                public void* default_value;
 
111
                public bool masked;
 
112
                public weak string pref_name;
 
113
                public weak string text;
 
114
                public Purple.PrefType type;
 
115
                [CCode (has_construct_function = false)]
 
116
                public AccountOption (Purple.PrefType type, string text, string pref_name);
 
117
                public void add_list_item (string key, string value);
 
118
                public static unowned Purple.AccountOption bool_new (string text, string pref_name, bool default_value);
 
119
                public bool get_default_bool ();
 
120
                public int get_default_int ();
 
121
                public unowned string get_default_list_value ();
 
122
                public unowned string get_default_string ();
 
123
                public unowned GLib.List get_list ();
 
124
                public bool get_masked ();
 
125
                public unowned string get_setting ();
 
126
                public unowned string get_text ();
 
127
                public static unowned Purple.AccountOption int_new (string text, string pref_name, int default_value);
 
128
                public static unowned Purple.AccountOption list_new (string text, string pref_name, GLib.List list);
 
129
                public void set_default_bool (bool value);
 
130
                public void set_default_int (int value);
 
131
                public void set_default_string (string value);
 
132
                public void set_list (GLib.List values);
 
133
                public void set_masked (bool masked);
 
134
                public static unowned Purple.AccountOption string_new (string text, string pref_name, string default_value);
 
135
        }
 
136
        [Compact]
 
137
        [CCode (cheader_filename = "purple.h")]
 
138
        public class AccountUiOps {
 
139
                public weak GLib.Callback close_account_request;
 
140
                public weak GLib.Callback notify_added;
 
141
                public weak GLib.Callback request_add;
 
142
                public weak GLib.Callback request_authorize;
 
143
                public weak GLib.Callback status_changed;
 
144
        }
 
145
        [Compact]
 
146
        [CCode (free_function = "purple_account_user_split_destroy", cheader_filename = "purple.h")]
 
147
        public class AccountUserSplit {
 
148
                public weak string default_value;
 
149
                public weak DBus.ObjectPath field_sep;
 
150
                public bool reverse;
 
151
                public weak string text;
 
152
                [CCode (has_construct_function = false)]
 
153
                public AccountUserSplit (string text, string default_value, DBus.ObjectPath sep);
 
154
                public unowned string get_default_value ();
 
155
                public bool get_reverse ();
 
156
                public unowned DBus.ObjectPath get_separator ();
 
157
                public unowned string get_text ();
 
158
                public void set_reverse (bool reverse);
 
159
        }
 
160
        [Compact]
 
161
        [CCode (cheader_filename = "purple.h")]
 
162
        public class AttentionType {
 
163
                public weak string icon_name;
 
164
                public weak string incoming_description;
 
165
                public weak string name;
 
166
                public weak string outgoing_description;
 
167
                public weak string unlocalized_name;
 
168
                [CCode (has_construct_function = false)]
 
169
                public AttentionType (string ulname, string name, string inc_desc, string out_desc);
 
170
                public unowned string get_icon_name ();
 
171
                public unowned string get_incoming_desc ();
 
172
                public unowned string get_name ();
 
173
                public unowned string get_outgoing_desc ();
 
174
                public unowned string get_unlocalized_name ();
 
175
                public void set_icon_name (string name);
 
176
                public void set_incoming_desc (string desc);
 
177
                public void set_name (string name);
 
178
                public void set_outgoing_desc (string desc);
 
179
                public void set_unlocalized_name (string ulname);
 
180
        }
 
181
        [Compact]
 
182
        [CCode (cheader_filename = "purple.h")]
 
183
        public class BlistNode {
 
184
                public weak Purple.BlistNode child;
 
185
                public Purple.BlistNodeFlags flags;
 
186
                public weak Purple.BlistNode parent;
 
187
                public weak Purple.BlistNode prev;
 
188
                public weak GLib.HashTable settings;
 
189
                public Purple.BlistNodeType type;
 
190
                public void* ui_data;
 
191
                public bool get_bool (string key);
 
192
                public unowned GLib.List get_extended_menu ();
 
193
                public unowned Purple.BlistNode get_first_child ();
 
194
                public Purple.BlistNodeFlags get_flags ();
 
195
                public int get_int (string key);
 
196
                public unowned Purple.BlistNode get_parent ();
 
197
                public unowned Purple.BlistNode get_sibling_next ();
 
198
                public unowned Purple.BlistNode get_sibling_prev ();
 
199
                public unowned string get_string (string key);
 
200
                public void* get_ui_data ();
 
201
                public unowned Purple.BlistNode next (bool offline);
 
202
                public void remove_setting (string key);
 
203
                public void set_bool (string key, bool value);
 
204
                public void set_flags (Purple.BlistNodeFlags flags);
 
205
                public void set_int (string key, int value);
 
206
                public void set_string (string key, string value);
 
207
                public void set_ui_data (void* ui_data);
 
208
        }
 
209
        [Compact]
 
210
        [CCode (cheader_filename = "purple.h")]
 
211
        public class BlistUiOps {
 
212
                public weak GLib.Callback destroy;
 
213
                public weak GLib.Callback new_list;
 
214
                public weak GLib.Callback new_node;
 
215
                public weak GLib.Callback remove;
 
216
                public weak GLib.Callback remove_node;
 
217
                public weak GLib.Callback request_add_buddy;
 
218
                public weak GLib.Callback request_add_chat;
 
219
                public weak GLib.Callback request_add_group;
 
220
                public weak GLib.Callback save_account;
 
221
                public weak GLib.Callback save_node;
 
222
                public weak GLib.Callback set_visible;
 
223
                public weak GLib.Callback show;
 
224
                public weak GLib.Callback update;
 
225
        }
 
226
        [Compact]
 
227
        [CCode (free_function = "purple_buddy_destroy", cheader_filename = "purple.h")]
 
228
        public class Buddy {
 
229
                public weak Purple.Account account;
 
230
                public weak string alias;
 
231
                public weak Purple.BuddyIcon icon;
 
232
                public weak string name;
 
233
                public weak Purple.BlistNode node;
 
234
                public weak Purple.Presence presence;
 
235
                public void* proto_data;
 
236
                public weak string server_alias;
 
237
                [CCode (has_construct_function = false)]
 
238
                public Buddy (Purple.Account account, string name, string alias);
 
239
                public unowned Purple.Account get_account ();
 
240
                public unowned string get_alias ();
 
241
                public unowned string get_alias_only ();
 
242
                public unowned Purple.Contact get_contact ();
 
243
                public unowned string get_contact_alias ();
 
244
                public unowned Purple.Group get_group ();
 
245
                public unowned Purple.BuddyIcon get_icon ();
 
246
                public unowned string get_local_alias ();
 
247
                public unowned string get_local_buddy_alias ();
 
248
                public unowned string get_name ();
 
249
                public unowned Purple.Presence get_presence ();
 
250
                public void* get_protocol_data ();
 
251
                public unowned string get_server_alias ();
 
252
                public static unowned Purple.BuddyIcon icons_find (Purple.Account account, string username);
 
253
                public static unowned Purple.StoredImage icons_find_account_icon (Purple.Account account);
 
254
                public static unowned Purple.StoredImage icons_find_custom_icon (Purple.Contact contact);
 
255
                public static ulong icons_get_account_icon_timestamp (Purple.Account account);
 
256
                public static unowned string icons_get_cache_dir ();
 
257
                public unowned string icons_get_checksum_for_user ();
 
258
                public static void* icons_get_handle ();
 
259
                public static bool icons_has_custom_icon (Purple.Contact contact);
 
260
                public static void icons_init ();
 
261
                public static bool icons_is_caching ();
 
262
                public static unowned Purple.StoredImage icons_node_find_custom_icon (Purple.BlistNode node);
 
263
                public static bool icons_node_has_custom_icon (Purple.BlistNode node);
 
264
                public static unowned Purple.StoredImage icons_node_set_custom_icon (Purple.BlistNode node, uchar[] icon_data, size_t icon_len);
 
265
                public static unowned Purple.StoredImage icons_node_set_custom_icon_from_file (Purple.BlistNode node, string filename);
 
266
                public static unowned Purple.StoredImage icons_set_account_icon (Purple.Account account, uchar[] icon_data, size_t icon_len);
 
267
                public static void icons_set_cache_dir (string cache_dir);
 
268
                public static void icons_set_caching (bool caching);
 
269
                public static unowned Purple.StoredImage icons_set_custom_icon (Purple.Contact contact, uchar[] icon_data, size_t icon_len);
 
270
                public static void icons_set_for_user (Purple.Account account, string username, void* icon_data, size_t icon_len, string checksum);
 
271
                public static void icons_uninit ();
 
272
                public void set_icon (Purple.BuddyIcon icon);
 
273
                public void set_protocol_data (void* data);
 
274
        }
 
275
        [Compact]
 
276
        [CCode (ref_function = "purple_buddy_icon_ref", unref_function = "purple_buddy_icon_unref", cheader_filename = "purple.h")]
 
277
        public class BuddyIcon {
 
278
                [CCode (has_construct_function = false)]
 
279
                public BuddyIcon (Purple.Account account, string username, void* icon_data, size_t icon_len, string checksum);
 
280
                public unowned Purple.Account get_account ();
 
281
                public unowned string get_checksum ();
 
282
                public void* get_data (size_t len);
 
283
                public unowned string get_extension ();
 
284
                public unowned string get_full_path ();
 
285
                public static void get_scale_size (Purple.BuddyIconSpec spec, int width, int height);
 
286
                public unowned string get_username ();
 
287
                public void set_data (uchar[] data, size_t len, string checksum);
 
288
                public void update ();
 
289
        }
 
290
        [Compact]
 
291
        [CCode (cheader_filename = "purple.h")]
 
292
        public class BuddyIconSpec {
 
293
                public weak string format;
 
294
                public size_t max_filesize;
 
295
                public int max_height;
 
296
                public int max_width;
 
297
                public int min_height;
 
298
                public int min_width;
 
299
                public Purple.IconScaleRules scale_rules;
 
300
        }
 
301
        [Compact]
 
302
        [CCode (cheader_filename = "purple.h")]
 
303
        public class BuddyList {
 
304
                public weak GLib.HashTable buddies;
 
305
                public weak Purple.BlistNode root;
 
306
                public void* ui_data;
 
307
        }
 
308
        [Compact]
 
309
        [CCode (copy_function = "purple_certificate_copy", free_function = "purple_certificate_destroy", cheader_filename = "purple.h")]
 
310
        public class Certificate {
 
311
                public void* data;
 
312
                public weak Purple.CertificateScheme scheme;
 
313
                public static void add_ca_search_path (string path);
 
314
                public static bool check_signature_chain (GLib.List chain);
 
315
                public static bool check_signature_chain_with_failing (GLib.List chain, out unowned Purple.Certificate failing);
 
316
                public bool check_subject_name (string name);
 
317
                public unowned Purple.Certificate copy ();
 
318
                public static unowned GLib.List copy_list (GLib.List crt_list);
 
319
                public static void destroy_list (GLib.List crt_list);
 
320
                public void display_x509 ();
 
321
                public static bool export (string filename, Purple.Certificate crt);
 
322
                public static unowned Purple.CertificatePool find_pool (string scheme_name, string pool_name);
 
323
                public static unowned Purple.CertificateScheme find_scheme (string name);
 
324
                public static unowned Purple.CertificateVerifier find_verifier (string scheme_name, string ver_name);
 
325
                public unowned GLib.ByteArray get_fingerprint_sha1 ();
 
326
                public static void* get_handle ();
 
327
                public unowned string get_issuer_unique_id ();
 
328
                public static unowned GLib.List get_pools ();
 
329
                public static unowned GLib.List get_schemes ();
 
330
                public unowned string get_subject_name ();
 
331
                public bool get_times (ulong activation, ulong expiration);
 
332
                public unowned string get_unique_id ();
 
333
                public static unowned GLib.List get_verifiers ();
 
334
                public static unowned Purple.Certificate import (Purple.CertificateScheme scheme, string filename);
 
335
                public static void init ();
 
336
                public static bool register_pool (Purple.CertificatePool pool);
 
337
                public static bool register_scheme (Purple.CertificateScheme scheme);
 
338
                public static bool register_verifier (Purple.CertificateVerifier vr);
 
339
                public bool signed_by (Purple.Certificate issuer);
 
340
                public static void uninit ();
 
341
                public static bool unregister_pool (Purple.CertificatePool pool);
 
342
                public static bool unregister_scheme (Purple.CertificateScheme scheme);
 
343
                public static bool unregister_verifier (Purple.CertificateVerifier vr);
 
344
                public static void verify (Purple.CertificateVerifier verifier, string subject_name, GLib.List cert_chain, Purple.CertificateVerifiedCallback cb, void* cb_data);
 
345
                public static void verify_complete (Purple.CertificateVerificationRequest vrq, Purple.CertificateVerificationStatus st);
 
346
        }
 
347
        [Compact]
 
348
        [CCode (cheader_filename = "purple.h")]
 
349
        public class CertificatePool {
 
350
                public weak GLib.Callback cert_in_pool;
 
351
                public void* data;
 
352
                public weak GLib.Callback delete_cert;
 
353
                public weak string fullname;
 
354
                public weak GLib.Callback get_cert;
 
355
                public weak GLib.Callback init;
 
356
                public weak string name;
 
357
                public weak GLib.Callback put_cert;
 
358
                public weak string scheme_name;
 
359
                public weak GLib.Callback uninit;
 
360
                public bool contains (string id);
 
361
                public bool @delete (string id);
 
362
                public static void destroy_idlist (GLib.List idlist);
 
363
                public unowned GLib.List get_idlist ();
 
364
                public unowned Purple.CertificateScheme get_scheme ();
 
365
                public unowned string mkpath (string id);
 
366
                public unowned Purple.Certificate retrieve (string id);
 
367
                public bool store (string id, Purple.Certificate crt);
 
368
                public bool usable ();
 
369
        }
 
370
        [Compact]
 
371
        [CCode (cheader_filename = "purple.h")]
 
372
        public class CertificateScheme {
 
373
                public weak GLib.Callback check_subject_name;
 
374
                public weak GLib.Callback copy_certificate;
 
375
                public weak GLib.Callback destroy_certificate;
 
376
                public weak GLib.Callback export_certificate;
 
377
                public weak string fullname;
 
378
                public weak GLib.Callback get_fingerprint_sha1;
 
379
                public weak GLib.Callback get_issuer_unique_id;
 
380
                public weak GLib.Callback get_subject_name;
 
381
                public weak GLib.Callback get_times;
 
382
                public weak GLib.Callback get_unique_id;
 
383
                public weak GLib.Callback import_certificate;
 
384
                public weak string name;
 
385
                public weak GLib.Callback signed_by;
 
386
        }
 
387
        [Compact]
 
388
        [CCode (cheader_filename = "purple.h")]
 
389
        public class CertificateVerificationRequest {
 
390
                public weak Purple.CertificateVerifiedCallback cb;
 
391
                public void* cb_data;
 
392
                public weak GLib.List cert_chain;
 
393
                public void* data;
 
394
                public weak Purple.CertificateScheme scheme;
 
395
                public weak string subject_name;
 
396
                public weak Purple.CertificateVerifier verifier;
 
397
        }
 
398
        [Compact]
 
399
        [CCode (cheader_filename = "purple.h")]
 
400
        public class CertificateVerifier {
 
401
                public weak GLib.Callback destroy_request;
 
402
                public weak string name;
 
403
                public weak string scheme_name;
 
404
                public weak GLib.Callback start_verification;
 
405
        }
 
406
        [Compact]
 
407
        [CCode (free_function = "purple_chat_destroy", cheader_filename = "purple.h")]
 
408
        public class Chat {
 
409
                public weak Purple.Account account;
 
410
                public weak string alias;
 
411
                public weak GLib.HashTable components;
 
412
                public weak Purple.BlistNode node;
 
413
                [CCode (has_construct_function = false)]
 
414
                public Chat (Purple.Account account, string alias, GLib.HashTable components);
 
415
                public unowned Purple.Account get_account ();
 
416
                public unowned GLib.HashTable get_components ();
 
417
                public unowned Purple.Group get_group ();
 
418
                public unowned string get_name ();
 
419
        }
 
420
        [Compact]
 
421
        [CCode (cheader_filename = "purple.h")]
 
422
        public class Cipher {
 
423
                public static bool digest_region (string name, uchar[] data, size_t data_len, size_t in_len, uchar[] digest, size_t out_len);
 
424
                public uint get_capabilities ();
 
425
                public unowned string get_name ();
 
426
                public static unowned string http_digest_calculate_response (string algorithm, string method, string digest_uri, string qop, string entity, string nonce, string nonce_count, string client_nonce, string session_key);
 
427
                public static unowned string http_digest_calculate_session_key (string algorithm, string username, string realm, string password, string nonce, string client_nonce);
 
428
        }
 
429
        [Compact]
 
430
        [CCode (free_function = "purple_cipher_context_destroy", cheader_filename = "purple.h")]
 
431
        public class CipherContext {
 
432
                [CCode (has_construct_function = false)]
 
433
                public CipherContext (Purple.Cipher cipher, void* extra);
 
434
                public void append (uchar[] data, size_t len);
 
435
                [CCode (has_construct_function = false)]
 
436
                public CipherContext.by_name (string name, void* extra);
 
437
                public int decrypt (uchar[] data, size_t len, uchar[] output, size_t outlen);
 
438
                public bool digest (size_t in_len, uchar[] digest, size_t out_len);
 
439
                public bool digest_to_str (size_t in_len, char[] digest_s, size_t out_len);
 
440
                public int encrypt (uchar[] data, size_t len, uchar[] output, size_t outlen);
 
441
                public Purple.CipherBatchMode get_batch_mode ();
 
442
                public size_t get_block_size ();
 
443
                public void* get_data ();
 
444
                public size_t get_key_size ();
 
445
                public void* get_option (string name);
 
446
                public size_t get_salt_size ();
 
447
                public void reset (void* extra);
 
448
                public void set_batch_mode (Purple.CipherBatchMode mode);
 
449
                public void set_data (void* data);
 
450
                public void set_iv (uchar[] iv, size_t len);
 
451
                public void set_key (uchar[] key);
 
452
                public void set_key_with_len (uchar[] key, size_t len);
 
453
                public void set_option (string name, void* value);
 
454
                public void set_salt (uchar[] salt);
 
455
        }
 
456
        [Compact]
 
457
        [CCode (cheader_filename = "purple.h")]
 
458
        public class CipherOps {
 
459
                public weak GLib.Callback append;
 
460
                public weak GLib.Callback decrypt;
 
461
                public weak GLib.Callback digest;
 
462
                public weak GLib.Callback encrypt;
 
463
                public weak GLib.Callback get_batch_mode;
 
464
                public weak GLib.Callback get_block_size;
 
465
                public weak GLib.Callback get_key_size;
 
466
                public weak GLib.Callback get_option;
 
467
                public weak GLib.Callback get_salt_size;
 
468
                public weak GLib.Callback init;
 
469
                public weak GLib.Callback reset;
 
470
                public weak GLib.Callback set_batch_mode;
 
471
                public weak GLib.Callback set_iv;
 
472
                public weak GLib.Callback set_key;
 
473
                public weak GLib.Callback set_key_with_len;
 
474
                public weak GLib.Callback set_option;
 
475
                public weak GLib.Callback set_salt;
 
476
                public weak GLib.Callback uninit;
 
477
        }
 
478
        [Compact]
 
479
        [CCode (free_function = "purple_circ_buffer_destroy", cheader_filename = "purple.h")]
 
480
        public class CircBuffer {
 
481
                public weak string buffer;
 
482
                public size_t buflen;
 
483
                public size_t bufused;
 
484
                public size_t growsize;
 
485
                public weak string inptr;
 
486
                public weak string outptr;
 
487
                [CCode (has_construct_function = false)]
 
488
                public CircBuffer (size_t growsize);
 
489
                public void append (void* src, size_t len);
 
490
                public size_t get_max_read ();
 
491
                public bool mark_read (size_t len);
 
492
        }
 
493
        [Compact]
 
494
        [CCode (cheader_filename = "purple.h")]
 
495
        public class CmdId {
 
496
        }
 
497
        [Compact]
 
498
        [CCode (free_function = "purple_connection_destroy", cheader_filename = "purple.h")]
 
499
        public class Connection {
 
500
                public weak Purple.Account account;
 
501
                public weak GLib.SList buddy_chats;
 
502
                public uint disconnect_timeout;
 
503
                public weak string display_name;
 
504
                public Purple.ConnectionFlags flags;
 
505
                public int inpa;
 
506
                public uint keepalive;
 
507
                public ulong last_received;
 
508
                public weak string password;
 
509
                public void* proto_data;
 
510
                public weak Purple.Plugin prpl;
 
511
                public Purple.ConnectionState state;
 
512
                public bool wants_to_die;
 
513
                [CCode (type = "void", has_construct_function = false)]
 
514
                public Connection (Purple.Account account, bool regist, string password);
 
515
                public void error (string reason);
 
516
                public static bool error_is_fatal (Purple.ConnectionError reason);
 
517
                public void error_reason (Purple.ConnectionError reason, string description);
 
518
                public unowned Purple.Account get_account ();
 
519
                public unowned string get_display_name ();
 
520
                public unowned string get_password ();
 
521
                public void* get_protocol_data ();
 
522
                public unowned Purple.Plugin get_prpl ();
 
523
                public Purple.ConnectionState get_state ();
 
524
                public void notice (string text);
 
525
                public void set_account (Purple.Account account);
 
526
                public void set_display_name (string name);
 
527
                public void set_protocol_data (void* proto_data);
 
528
                public void set_state (Purple.ConnectionState state);
 
529
                public void ssl_error (Purple.SslErrorType ssl_error);
 
530
                [CCode (type = "void", has_construct_function = false)]
 
531
                public Connection.unregister (Purple.Account account, string password, Purple.AccountUnregistrationCb cb);
 
532
                public void update_progress (string text, size_t step, size_t count);
 
533
        }
 
534
        [Compact]
 
535
        [CCode (cheader_filename = "purple.h")]
 
536
        public class ConnectionErrorInfo {
 
537
                public weak string description;
 
538
                public Purple.ConnectionError type;
 
539
        }
 
540
        [Compact]
 
541
        [CCode (cheader_filename = "purple.h")]
 
542
        public class ConnectionUiOps {
 
543
                public weak GLib.Callback connect_progress;
 
544
                public weak GLib.Callback connected;
 
545
                public weak GLib.Callback disconnected;
 
546
                public weak GLib.Callback network_connected;
 
547
                public weak GLib.Callback network_disconnected;
 
548
                public weak GLib.Callback notice;
 
549
                public weak GLib.Callback report_disconnect;
 
550
                public weak GLib.Callback report_disconnect_reason;
 
551
        }
 
552
        [Compact]
 
553
        [CCode (free_function = "purple_contact_destroy", cheader_filename = "purple.h")]
 
554
        public class Contact {
 
555
                public weak string alias;
 
556
                public int currentsize;
 
557
                public weak Purple.BlistNode node;
 
558
                public int online;
 
559
                public weak Purple.Buddy priority;
 
560
                public bool priority_valid;
 
561
                public int totalsize;
 
562
                [CCode (has_construct_function = false)]
 
563
                public Contact ();
 
564
                public unowned string get_alias ();
 
565
                public unowned Purple.Buddy get_priority_buddy ();
 
566
                public void invalidate_priority_buddy ();
 
567
                public bool on_account (Purple.Account account);
 
568
                public void set_alias (string alias);
 
569
        }
 
570
        [Compact]
 
571
        [CCode (cheader_filename = "purple.h")]
 
572
        public class ConvChat {
 
573
                public weak Purple.Conversation conv;
 
574
                public int id;
 
575
                public weak GLib.List ignored;
 
576
                public weak GLib.List in_room;
 
577
                public weak string nick;
 
578
                public weak string topic;
 
579
                public weak string who;
 
580
                public void add_user (string user, string extra_msg, Purple.ConvChatBuddyFlags flags, bool new_arrival);
 
581
                public void add_users (GLib.List users, GLib.List extra_msgs, GLib.List flags, bool new_arrivals);
 
582
                public static void cb_destroy (Purple.ConvChatBuddy cb);
 
583
                public unowned Purple.ConvChatBuddy cb_find (string name);
 
584
                public static unowned string cb_get_name (Purple.ConvChatBuddy cb);
 
585
                public static unowned Purple.ConvChatBuddy cb_new (string name, string alias, Purple.ConvChatBuddyFlags flags);
 
586
                public void clear_users ();
 
587
                public bool find_user (string user);
 
588
                public unowned Purple.Conversation get_conversation ();
 
589
                public int get_id ();
 
590
                public unowned GLib.List get_ignored ();
 
591
                public unowned string get_ignored_user (string user);
 
592
                public unowned string get_nick ();
 
593
                public unowned string get_topic ();
 
594
                public unowned GLib.List get_users ();
 
595
                public bool has_left ();
 
596
                public void ignore (string name);
 
597
                public void invite_user (string user, string message, bool confirm);
 
598
                public bool is_user_ignored (string user);
 
599
                public void left ();
 
600
                public void remove_user (string user, string reason);
 
601
                public void remove_users (GLib.List users, string reason);
 
602
                public void rename_user (string old_user, string new_user);
 
603
                public void send (string message);
 
604
                public void send_with_flags (string message, Purple.MessageFlags flags);
 
605
                public void set_id (int id);
 
606
                public unowned GLib.List set_ignored (GLib.List ignored);
 
607
                public void set_nick (string nick);
 
608
                public void set_topic (string who, string topic);
 
609
                public unowned GLib.List set_users (GLib.List users);
 
610
                public void unignore (string name);
 
611
                public Purple.ConvChatBuddyFlags user_get_flags (string user);
 
612
                public void user_set_flags (string user, Purple.ConvChatBuddyFlags flags);
 
613
                public void write (string who, string message, Purple.MessageFlags flags, ulong mtime);
 
614
        }
 
615
        [Compact]
 
616
        [CCode (cheader_filename = "purple.h")]
 
617
        public class ConvChatBuddy {
 
618
                public weak string alias;
 
619
                public weak string alias_key;
 
620
                public bool buddy;
 
621
                public Purple.ConvChatBuddyFlags flags;
 
622
                public weak string name;
 
623
        }
 
624
        [Compact]
 
625
        [CCode (cheader_filename = "purple.h")]
 
626
        public class ConvIm {
 
627
                public weak Purple.Conversation conv;
 
628
                public weak Purple.BuddyIcon icon;
 
629
                public uint send_typed_timeout;
 
630
                public ulong type_again;
 
631
                public Purple.TypingState typing_state;
 
632
                public uint typing_timeout;
 
633
                public unowned Purple.Conversation get_conversation ();
 
634
                public unowned Purple.BuddyIcon get_icon ();
 
635
                public uint get_send_typed_timeout ();
 
636
                public ulong get_type_again ();
 
637
                public Purple.TypingState get_typing_state ();
 
638
                public uint get_typing_timeout ();
 
639
                public void send (string message);
 
640
                public void send_with_flags (string message, Purple.MessageFlags flags);
 
641
                public void set_icon (Purple.BuddyIcon icon);
 
642
                public void set_type_again (uint val);
 
643
                public void set_typing_state (Purple.TypingState state);
 
644
                public void start_send_typed_timeout ();
 
645
                public void start_typing_timeout (int timeout);
 
646
                public void stop_send_typed_timeout ();
 
647
                public void stop_typing_timeout ();
 
648
                public void update_typing ();
 
649
                public void write (string who, string message, Purple.MessageFlags flags, ulong mtime);
 
650
        }
 
651
        [Compact]
 
652
        [CCode (cheader_filename = "purple.h")]
 
653
        public class ConvMessage {
 
654
                public weak string alias;
 
655
                public weak Purple.Conversation conv;
 
656
                public Purple.MessageFlags flags;
 
657
                public weak string what;
 
658
                public ulong when;
 
659
                public weak string who;
 
660
        }
 
661
        [Compact]
 
662
        [CCode (free_function = "purple_conversation_destroy", cheader_filename = "purple.h")]
 
663
        public class Conversation {
 
664
                public weak Purple.Account account;
 
665
                public weak GLib.HashTable data;
 
666
                public Purple.ConnectionFlags features;
 
667
                public bool logging;
 
668
                public weak GLib.List logs;
 
669
                public weak GLib.List message_history;
 
670
                public weak string name;
 
671
                public weak string title;
 
672
                public Purple.ConversationType type;
 
673
                public void* u;
 
674
                public void* ui_data;
 
675
                public weak Purple.ConversationUiOps ui_ops;
 
676
                [CCode (has_construct_function = false)]
 
677
                public Conversation (Purple.ConversationType type, Purple.Account account, string name);
 
678
                public void autoset_title ();
 
679
                public void clear_message_history ();
 
680
                public void close_logs ();
 
681
                public bool do_command (string cmdline, string markup, string error);
 
682
                public static void @foreach (GLib.Callback func);
 
683
                public unowned Purple.Account get_account ();
 
684
                public unowned Purple.ConvChat get_chat_data ();
 
685
                public void* get_data (string key);
 
686
                public unowned GLib.List get_extended_menu ();
 
687
                public Purple.ConnectionFlags get_features ();
 
688
                public unowned Purple.Connection get_gc ();
 
689
                public unowned Purple.ConvIm get_im_data ();
 
690
                public unowned GLib.List get_message_history ();
 
691
                public unowned string get_name ();
 
692
                public unowned string get_title ();
 
693
                public unowned Purple.ConversationUiOps get_ui_ops ();
 
694
                public bool has_focus ();
 
695
                public bool is_logging ();
 
696
                public static Purple.MessageFlags message_get_flags (Purple.ConvMessage msg);
 
697
                public static unowned string message_get_message (Purple.ConvMessage msg);
 
698
                public static unowned string message_get_sender (Purple.ConvMessage msg);
 
699
                public static ulong message_get_timestamp (Purple.ConvMessage msg);
 
700
                public void present ();
 
701
                public void set_account (Purple.Account account);
 
702
                public void set_data (string key, void* data);
 
703
                public void set_features (Purple.ConnectionFlags features);
 
704
                public void set_logging (bool log);
 
705
                public void set_name (string name);
 
706
                public void set_title (string title);
 
707
                public void set_ui_ops (Purple.ConversationUiOps ops);
 
708
                public void update (Purple.ConvUpdateType type);
 
709
                public void write (string who, string message, Purple.MessageFlags flags, ulong mtime);
 
710
        }
 
711
        [Compact]
 
712
        [CCode (cheader_filename = "purple.h")]
 
713
        public class ConversationUiOps {
 
714
                public weak GLib.Callback chat_add_users;
 
715
                public weak GLib.Callback chat_remove_users;
 
716
                public weak GLib.Callback chat_rename_user;
 
717
                public weak GLib.Callback chat_update_user;
 
718
                public weak GLib.Callback create_conversation;
 
719
                public weak GLib.Callback custom_smiley_add;
 
720
                public weak GLib.Callback custom_smiley_close;
 
721
                public weak GLib.Callback custom_smiley_write;
 
722
                public weak GLib.Callback destroy_conversation;
 
723
                public weak GLib.Callback has_focus;
 
724
                public weak GLib.Callback present;
 
725
                public weak GLib.Callback send_confirm;
 
726
                public weak GLib.Callback write_chat;
 
727
                public weak GLib.Callback write_conv;
 
728
                public weak GLib.Callback write_im;
 
729
        }
 
730
        [Compact]
 
731
        [CCode (cheader_filename = "purple.h")]
 
732
        public class Core {
 
733
                public static bool ensure_single_instance ();
 
734
                public static unowned string get_ui ();
 
735
                public static unowned GLib.HashTable get_ui_info ();
 
736
                public static unowned Purple.CoreUiOps get_ui_ops ();
 
737
                public static unowned string get_version ();
 
738
                public static bool init (string ui);
 
739
                public static bool migrate ();
 
740
                public static void quit ();
 
741
                public static bool quit_cb (void* unused);
 
742
                public static void set_ui_ops (Purple.CoreUiOps ops);
 
743
        }
 
744
        [Compact]
 
745
        [CCode (cheader_filename = "purple.h")]
 
746
        public class CoreUiOps {
 
747
                public weak GLib.Callback debug_ui_init;
 
748
                public weak GLib.Callback get_ui_info;
 
749
                public weak GLib.Callback quit;
 
750
                public weak GLib.Callback ui_init;
 
751
                public weak GLib.Callback ui_prefs_init;
 
752
        }
 
753
        [Compact]
 
754
        [CCode (cheader_filename = "purple.h")]
 
755
        public class DBusType {
 
756
                public weak Purple.DBusType parent;
 
757
        }
 
758
        [Compact]
 
759
        [CCode (cheader_filename = "purple.h")]
 
760
        public class DebugUiOps {
 
761
                public weak GLib.Callback is_enabled;
 
762
                public weak GLib.Callback print;
 
763
        }
 
764
        [Compact]
 
765
        [CCode (copy_function = "purple_desktop_item_copy", cheader_filename = "purple.h")]
 
766
        public class DesktopItem {
 
767
                public unowned Purple.DesktopItem copy ();
 
768
                [CCode (has_construct_function = false)]
 
769
                public DesktopItem.from_file (string filename);
 
770
                public Purple.DesktopItemType get_entry_type ();
 
771
                public unowned string get_string (string attr);
 
772
        }
 
773
        [Compact]
 
774
        [CCode (cheader_filename = "purple.h")]
 
775
        public class DnsQueryData {
 
776
        }
 
777
        [Compact]
 
778
        [CCode (cheader_filename = "purple.h")]
 
779
        public class DnsQueryUiOps {
 
780
                public weak GLib.Callback destroy;
 
781
                public weak GLib.Callback resolve_host;
 
782
        }
 
783
        [Compact]
 
784
        [CCode (cheader_filename = "purple.h")]
 
785
        public class EventLoopUiOps {
 
786
                public weak GLib.Callback input_add;
 
787
                public weak GLib.Callback input_get_error;
 
788
                public weak GLib.Callback input_remove;
 
789
                public weak GLib.Callback timeout_add;
 
790
                public weak GLib.Callback timeout_add_seconds;
 
791
                public weak GLib.Callback timeout_remove;
 
792
        }
 
793
        [Compact]
 
794
        [CCode (free_function = "purple_group_destroy", cheader_filename = "purple.h")]
 
795
        public class Group {
 
796
                public int currentsize;
 
797
                public weak string name;
 
798
                public weak Purple.BlistNode node;
 
799
                public int online;
 
800
                public int totalsize;
 
801
                [CCode (has_construct_function = false)]
 
802
                public Group (string name);
 
803
                public unowned GLib.SList get_accounts ();
 
804
                public unowned string get_name ();
 
805
                public bool on_account (Purple.Account account);
 
806
        }
 
807
        [Compact]
 
808
        [CCode (cheader_filename = "purple.h")]
 
809
        public class IdleUiOps {
 
810
                public weak GLib.Callback get_time_idle;
 
811
        }
 
812
        [Compact]
 
813
        [CCode (cheader_filename = "purple.h")]
 
814
        public class KeyValuePair {
 
815
                public weak string key;
 
816
                public void* value;
 
817
        }
 
818
        [Compact]
 
819
        [CCode (cheader_filename = "purple.h")]
 
820
        public class Log {
 
821
                public weak Purple.Account account;
 
822
                public weak Purple.Conversation conv;
 
823
                public weak Purple.LogLogger logger;
 
824
                public void* logger_data;
 
825
                public weak string name;
 
826
                public ulong time;
 
827
                public void* tm;
 
828
                public Purple.LogType type;
 
829
                [CCode (has_construct_function = false)]
 
830
                public Log (Purple.LogType type, string name, Purple.Account account, Purple.Conversation conv, ulong time, void* tm);
 
831
                public bool common_deleter ();
 
832
                public bool common_is_deletable ();
 
833
                public static unowned GLib.List common_lister (Purple.LogType type, string name, Purple.Account account, string ext, Purple.LogLogger logger);
 
834
                public int common_sizer ();
 
835
                public static int common_total_sizer (Purple.LogType type, string name, Purple.Account account, string ext);
 
836
                public void common_writer (string ext);
 
837
                public static int compare (void* y, void* z);
 
838
                public bool @delete ();
 
839
                public static int get_activity_score (Purple.LogType type, string name, Purple.Account account);
 
840
                public static void* get_handle ();
 
841
                public static unowned string get_log_dir (Purple.LogType type, string name, Purple.Account account);
 
842
                public static unowned GLib.HashTable get_log_sets ();
 
843
                public static unowned GLib.List get_logs (Purple.LogType type, string name, Purple.Account account);
 
844
                public int get_size ();
 
845
                public static unowned GLib.List get_system_logs (Purple.Account account);
 
846
                public static int get_total_size (Purple.LogType type, string name, Purple.Account account);
 
847
                public static void init ();
 
848
                public bool is_deletable ();
 
849
                public unowned string read (Purple.LogReadFlags flags);
 
850
                public static void uninit ();
 
851
                public void write (Purple.MessageFlags type, string from, ulong time, string message);
 
852
        }
 
853
        [Compact]
 
854
        [CCode (cheader_filename = "purple.h")]
 
855
        public class LogCommonLoggerData {
 
856
                public void* extra_data;
 
857
                public weak GLib.FileStream file;
 
858
                public weak string path;
 
859
        }
 
860
        [Compact]
 
861
        [CCode (cheader_filename = "purple.h")]
 
862
        public class LogLogger {
 
863
                public weak GLib.Callback create;
 
864
                public weak GLib.Callback finalize;
 
865
                public weak GLib.Callback get_log_sets;
 
866
                public weak string id;
 
867
                public weak GLib.Callback is_deletable;
 
868
                public weak GLib.Callback list;
 
869
                public weak GLib.Callback list_syslog;
 
870
                public weak string name;
 
871
                public weak GLib.Callback read;
 
872
                public weak GLib.Callback size;
 
873
                public weak GLib.Callback total_size;
 
874
                public weak GLib.Callback write;
 
875
                [CCode (has_construct_function = false)]
 
876
                public LogLogger (string id, string name, int functions);
 
877
                public void add ();
 
878
                public static unowned Purple.LogLogger @get ();
 
879
                public static unowned GLib.List get_options ();
 
880
                public void remove ();
 
881
                public void @set ();
 
882
        }
 
883
        [Compact]
 
884
        [CCode (cheader_filename = "purple.h")]
 
885
        public class LogSet {
 
886
                public weak Purple.Account account;
 
887
                public bool buddy;
 
888
                public weak string name;
 
889
                public weak string normalized_name;
 
890
                public Purple.LogType type;
 
891
                public static int compare (void* y, void* z);
 
892
        }
 
893
        [Compact]
 
894
        [CCode (cheader_filename = "purple.h")]
 
895
        public class Media {
 
896
                public bool accepted (string sess_id, string participant);
 
897
                public void add_remote_candidates (string sess_id, string participant, GLib.List remote_candidates);
 
898
                public bool add_stream (string sess_id, string who, Purple.MediaSessionType type, bool initiator, string transmitter, uint num_params, GLib.Parameter @params);
 
899
                public bool candidates_prepared (string session_id, string participant);
 
900
                public bool codecs_ready (string sess_id);
 
901
                public static GLib.Type element_type_get_type ();
 
902
                public void end (string session_id, string participant);
 
903
                public void error (string error);
 
904
                public unowned Purple.Account get_account ();
 
905
                public unowned GLib.List get_codecs (string sess_id);
 
906
                public unowned GLib.List get_local_candidates (string sess_id, string participant);
 
907
                public void* get_manager ();
 
908
                public void* get_prpl_data ();
 
909
                public unowned GLib.List get_session_ids ();
 
910
                public Purple.MediaSessionType get_session_type (string sess_id);
 
911
                public unowned Gst.Element get_src (string sess_id);
 
912
                public unowned Gst.Element get_tee (string session_id, string participant);
 
913
                public static GLib.Type info_type_get_type ();
 
914
                public bool is_initiator (string sess_id, string participant);
 
915
                public static GLib.Type network_protocol_get_type ();
 
916
                public void remove_output_windows ();
 
917
                public static GLib.Type session_type_get_type ();
 
918
                public void set_input_volume (string session_id, double level);
 
919
                public void set_output_volume (string session_id, string participant, double level);
 
920
                public ulong set_output_window (string session_id, string participant, ulong window_id);
 
921
                public void set_prpl_data (void* prpl_data);
 
922
                public bool set_remote_codecs (string sess_id, string participant, GLib.List codecs);
 
923
                public bool set_send_codec (string sess_id, Purple.MediaCodec codec);
 
924
                public static GLib.Type state_changed_get_type ();
 
925
                public void stream_info (Purple.MediaInfoType type, string session_id, string participant, bool local);
 
926
        }
 
927
        [Compact]
 
928
        [CCode (cheader_filename = "purple.h")]
 
929
        public class MediaCandidate {
 
930
                [CCode (has_construct_function = false)]
 
931
                public MediaCandidate (string foundation, uint component_id, Purple.MediaCandidateType type, Purple.MediaNetworkProtocol proto, string ip, uint port);
 
932
                public unowned string get_base_ip ();
 
933
                public uint16 get_base_port ();
 
934
                public Purple.MediaCandidateType get_candidate_type ();
 
935
                public uint get_component_id ();
 
936
                public unowned string get_foundation ();
 
937
                public unowned string get_ip ();
 
938
                public unowned string get_password ();
 
939
                public uint16 get_port ();
 
940
                public uint32 get_priority ();
 
941
                public Purple.MediaNetworkProtocol get_protocol ();
 
942
                public uint get_ttl ();
 
943
                public unowned string get_username ();
 
944
                public static unowned GLib.List list_copy (GLib.List candidates);
 
945
                public static void list_free (GLib.List candidates);
 
946
                public static GLib.Type type_get_type ();
 
947
        }
 
948
        [Compact]
 
949
        [CCode (cheader_filename = "purple.h")]
 
950
        public class MediaCodec {
 
951
                [CCode (has_construct_function = false)]
 
952
                public MediaCodec (int id, string encoding_name, Purple.MediaSessionType media_type, uint clock_rate);
 
953
                public void add_optional_parameter (string name, string value);
 
954
                public uint get_channels ();
 
955
                public uint get_clock_rate ();
 
956
                public unowned string get_encoding_name ();
 
957
                public uint get_id ();
 
958
                public unowned Purple.KeyValuePair get_optional_parameter (string name, string value);
 
959
                public unowned GLib.List get_optional_parameters ();
 
960
                public static unowned GLib.List list_copy (GLib.List codecs);
 
961
                public static void list_free (GLib.List codecs);
 
962
                public void remove_optional_parameter (Purple.KeyValuePair param);
 
963
                public unowned string to_string ();
 
964
        }
 
965
        [Compact]
 
966
        [CCode (cheader_filename = "purple.h")]
 
967
        public class MediaElementInfo {
 
968
                public unowned Gst.Element call_create (Purple.Media media, string session_id, string participant);
 
969
                public Purple.MediaElementType get_element_type ();
 
970
                public unowned string get_id ();
 
971
                public unowned string get_name ();
 
972
        }
 
973
        [Compact]
 
974
        [CCode (cheader_filename = "purple.h")]
 
975
        public class MediaElementInfoClass {
 
976
        }
 
977
        [Compact]
 
978
        [CCode (cheader_filename = "purple.h")]
 
979
        public class MediaManager {
 
980
                public unowned Purple.Media create_media (Purple.Account account, string conference_type, string remote_user, bool initiator);
 
981
                public bool create_output_window (Purple.Media media, string session_id, string participant);
 
982
                public static unowned Purple.MediaManager @get ();
 
983
                public unowned Purple.MediaElementInfo get_active_element (Purple.MediaElementType type);
 
984
                public unowned Gst.Element get_element (Purple.MediaSessionType type, Purple.Media media, string session_id, string participant);
 
985
                public unowned Purple.MediaElementInfo get_element_info (string name);
 
986
                public unowned GLib.List get_media ();
 
987
                public unowned GLib.List get_media_by_account (Purple.Account account);
 
988
                public unowned Gst.Element get_pipeline ();
 
989
                public Purple.MediaCaps get_ui_caps ();
 
990
                public bool register_element (Purple.MediaElementInfo info);
 
991
                public void remove_media (Purple.Media media);
 
992
                public bool remove_output_window (ulong output_window_id);
 
993
                public void remove_output_windows (Purple.Media media, string session_id, string participant);
 
994
                public bool set_active_element (Purple.MediaElementInfo info);
 
995
                public ulong set_output_window (Purple.Media media, string session_id, string participant, ulong window_id);
 
996
                public void set_ui_caps (Purple.MediaCaps caps);
 
997
                public bool unregister_element (string name);
 
998
        }
 
999
        [Compact]
 
1000
        [CCode (cheader_filename = "purple.h")]
 
1001
        public class MediaManagerClass {
 
1002
        }
 
1003
        [Compact]
 
1004
        [CCode (cheader_filename = "purple.h")]
 
1005
        public class MenuAction {
 
1006
                public weak Purple.Callback callback;
 
1007
                public weak GLib.List children;
 
1008
                public void* data;
 
1009
                public weak string label;
 
1010
                [CCode (has_construct_function = false)]
 
1011
                public MenuAction (string label, Purple.Callback callback, void* data, GLib.List children);
 
1012
        }
 
1013
        [Compact]
 
1014
        [CCode (cheader_filename = "purple.h")]
 
1015
        public class MimeDocument {
 
1016
                [CCode (has_construct_function = false)]
 
1017
                public MimeDocument ();
 
1018
                public unowned string get_field (string field);
 
1019
                public unowned GLib.List get_fields ();
 
1020
                public unowned GLib.List get_parts ();
 
1021
                public static unowned Purple.MimeDocument parse (string buf);
 
1022
                public static unowned Purple.MimeDocument parsen (string buf, size_t len);
 
1023
                public void set_field (string field, string value);
 
1024
                public void write (GLib.StringBuilder str);
 
1025
        }
 
1026
        [Compact]
 
1027
        [CCode (cheader_filename = "purple.h")]
 
1028
        public class MimePart {
 
1029
                [CCode (has_construct_function = false)]
 
1030
                public MimePart (Purple.MimeDocument doc);
 
1031
                public unowned string get_data ();
 
1032
                public void get_data_decoded (uchar[] data, size_t len);
 
1033
                public unowned string get_field (string field);
 
1034
                public unowned string get_field_decoded (string field);
 
1035
                public unowned GLib.List get_fields ();
 
1036
                public size_t get_length ();
 
1037
                public void set_data (string data);
 
1038
                public void set_field (string field, string value);
 
1039
        }
 
1040
        [Compact]
 
1041
        [CCode (cheader_filename = "purple.h")]
 
1042
        public class NetworkListenData {
 
1043
        }
 
1044
        [Compact]
 
1045
        [CCode (cheader_filename = "purple.h")]
 
1046
        public class NotifySearchButton {
 
1047
                public weak Purple.NotifySearchResultsCallback callback;
 
1048
                public weak string label;
 
1049
                public Purple.NotifySearchButtonType type;
 
1050
        }
 
1051
        [Compact]
 
1052
        [CCode (cheader_filename = "purple.h")]
 
1053
        public class NotifySearchColumn {
 
1054
                public weak string title;
 
1055
        }
 
1056
        [Compact]
 
1057
        [CCode (free_function = "purple_notify_searchresults_free", cheader_filename = "purple.h")]
 
1058
        public class NotifySearchResults {
 
1059
                public weak GLib.List buttons;
 
1060
                public weak GLib.List columns;
 
1061
                [CCode (cname = "purple_notify_searchresults_new", has_construct_function = false)]
 
1062
                public NotifySearchResults ();
 
1063
                [CCode (cname = "purple_notify_searchresults_button_add")]
 
1064
                public void button_add (Purple.NotifySearchButtonType type, Purple.NotifySearchResultsCallback cb);
 
1065
                [CCode (cname = "purple_notify_searchresults_button_add_labeled")]
 
1066
                public void button_add_labeled (string label, Purple.NotifySearchResultsCallback cb);
 
1067
                [CCode (cname = "purple_notify_searchresults_column_add")]
 
1068
                public void column_add (Purple.NotifySearchColumn column);
 
1069
                [CCode (cname = "purple_notify_searchresults_column_get_title")]
 
1070
                public unowned string column_get_title (uint column_id);
 
1071
                [CCode (cname = "purple_notify_searchresults_column_new")]
 
1072
                public static unowned Purple.NotifySearchColumn column_new (string title);
 
1073
                [CCode (cname = "purple_notify_searchresults_get_columns_count")]
 
1074
                public uint get_columns_count ();
 
1075
                [CCode (cname = "purple_notify_searchresults_get_rows_count")]
 
1076
                public uint get_rows_count ();
 
1077
                [CCode (cname = "purple_notify_searchresults_row_add")]
 
1078
                public void row_add (GLib.List row);
 
1079
                [CCode (cname = "purple_notify_searchresults_row_get")]
 
1080
                public unowned GLib.List row_get (uint row_id);
 
1081
                [CCode (cname = "purple_notify_searchresults_new_rows", type = "void", has_construct_function = false)]
 
1082
                public NotifySearchResults.rows (Purple.Connection gc, Purple.NotifySearchResults results, void* data);
 
1083
        }
 
1084
        [Compact]
 
1085
        [CCode (cheader_filename = "purple.h")]
 
1086
        public class NotifyUiOps {
 
1087
                public weak GLib.Callback close_notify;
 
1088
                public weak GLib.Callback notify_email;
 
1089
                public weak GLib.Callback notify_emails;
 
1090
                public weak GLib.Callback notify_formatted;
 
1091
                public weak GLib.Callback notify_message;
 
1092
                public weak GLib.Callback notify_searchresults;
 
1093
                public weak GLib.Callback notify_searchresults_new_rows;
 
1094
                public weak GLib.Callback notify_uri;
 
1095
                public weak GLib.Callback notify_userinfo;
 
1096
        }
 
1097
        [Compact]
 
1098
        [CCode (free_function = "purple_notify_user_info_destroy", cheader_filename = "purple.h")]
 
1099
        public class NotifyUserInfo {
 
1100
                [CCode (has_construct_function = false)]
 
1101
                public NotifyUserInfo ();
 
1102
                public void add_pair (string label, string value);
 
1103
                public void add_section_break ();
 
1104
                public void add_section_header (string label);
 
1105
                public unowned GLib.List get_entries ();
 
1106
                public unowned string get_text_with_newline (string newline);
 
1107
                public void prepend_pair (string label, string value);
 
1108
                public void prepend_section_break ();
 
1109
                public void prepend_section_header (string label);
 
1110
                public void remove_entry (Purple.NotifyUserInfoEntry user_info_entry);
 
1111
                public void remove_last_item ();
 
1112
        }
 
1113
        [Compact]
 
1114
        [CCode (cheader_filename = "purple.h")]
 
1115
        public class NotifyUserInfoEntry {
 
1116
                [CCode (has_construct_function = false)]
 
1117
                public NotifyUserInfoEntry (string label, string value);
 
1118
                public unowned string get_label ();
 
1119
                public unowned string get_value ();
 
1120
                public void set_label (string label);
 
1121
                public void set_type (Purple.NotifyUserInfoEntryType type);
 
1122
                public void set_value (string value);
 
1123
        }
 
1124
        [Compact]
 
1125
        [CCode (free_function = "purple_plugin_destroy", cheader_filename = "purple.h")]
 
1126
        public class Plugin {
 
1127
                public weak GLib.List dependent_plugins;
 
1128
                public weak string error;
 
1129
                public void* extra;
 
1130
                public void* handle;
 
1131
                public weak Purple.PluginInfo info;
 
1132
                public void* ipc_data;
 
1133
                public bool loaded;
 
1134
                public bool native_plugin;
 
1135
                public weak string path;
 
1136
                public bool unloadable;
 
1137
                [CCode (has_construct_function = false)]
 
1138
                public Plugin (bool native, string path);
 
1139
                public void disable ();
 
1140
                public unowned string get_author ();
 
1141
                public unowned string get_description ();
 
1142
                public unowned string get_homepage ();
 
1143
                public unowned string get_id ();
 
1144
                public unowned string get_name ();
 
1145
                public unowned string get_summary ();
 
1146
                public unowned string get_version ();
 
1147
                public void* ipc_call (string command, bool ok);
 
1148
                public bool ipc_get_params (string command, out unowned Purple.Value ret_value, int num_params, out unowned Purple.Value @params);
 
1149
                public bool ipc_register (string command, Purple.Callback func, Purple.SignalMarshalFunc marshal, Purple.Value ret_value, int num_params);
 
1150
                public void ipc_unregister (string command);
 
1151
                public void ipc_unregister_all ();
 
1152
                public bool is_loaded ();
 
1153
                public bool is_unloadable ();
 
1154
                public bool load ();
 
1155
                public static unowned Purple.Plugin probe (string filename);
 
1156
                public bool register ();
 
1157
                public bool reload ();
 
1158
                public bool unload ();
 
1159
        }
 
1160
        [Compact]
 
1161
        [CCode (cheader_filename = "purple.h")]
 
1162
        public class PluginAction {
 
1163
                public weak GLib.Callback callback;
 
1164
                public void* context;
 
1165
                public weak string label;
 
1166
                public weak Purple.Plugin plugin;
 
1167
                public void* user_data;
 
1168
                [CCode (has_construct_function = false)]
 
1169
                public PluginAction (string label, GLib.Callback callback);
 
1170
        }
 
1171
        [Compact]
 
1172
        [CCode (cheader_filename = "purple.h")]
 
1173
        public class PluginInfo {
 
1174
                public weak GLib.Callback actions;
 
1175
                public weak string author;
 
1176
                public weak GLib.List dependencies;
 
1177
                public weak string description;
 
1178
                public weak GLib.Callback destroy;
 
1179
                public void* extra_info;
 
1180
                public uint flags;
 
1181
                public weak string homepage;
 
1182
                public weak string id;
 
1183
                public weak GLib.Callback load;
 
1184
                public uint magic;
 
1185
                public uint major_version;
 
1186
                public uint minor_version;
 
1187
                public weak string name;
 
1188
                public weak Purple.PluginUiInfo prefs_info;
 
1189
                public weak Purple.PluginPriority priority;
 
1190
                public weak string summary;
 
1191
                public Purple.PluginType type;
 
1192
                public void* ui_info;
 
1193
                public weak string ui_requirement;
 
1194
                public weak GLib.Callback unload;
 
1195
                public weak string version;
 
1196
        }
 
1197
        [Compact]
 
1198
        [CCode (cheader_filename = "purple.h")]
 
1199
        public class PluginLoaderInfo {
 
1200
                public weak GLib.Callback destroy;
 
1201
                public weak GLib.List exts;
 
1202
                public weak GLib.Callback load;
 
1203
                public weak GLib.Callback probe;
 
1204
                public weak GLib.Callback unload;
 
1205
        }
 
1206
        [Compact]
 
1207
        [CCode (free_function = "purple_plugin_pref_destroy", cheader_filename = "purple.h")]
 
1208
        public class PluginPref {
 
1209
                [CCode (has_construct_function = false)]
 
1210
                public PluginPref ();
 
1211
                public void add_choice (string label, void* choice);
 
1212
                public void get_bounds (int min, int max);
 
1213
                public unowned GLib.List get_choices ();
 
1214
                public Purple.StringFormatType get_format_type ();
 
1215
                public unowned string get_label ();
 
1216
                public bool get_masked ();
 
1217
                public uint get_max_length ();
 
1218
                public unowned string get_name ();
 
1219
                public void set_bounds (int min, int max);
 
1220
                public void set_format_type (Purple.StringFormatType format);
 
1221
                public void set_label (string label);
 
1222
                public void set_masked (bool mask);
 
1223
                public void set_max_length (uint max_length);
 
1224
                public void set_name (string name);
 
1225
                public void set_type (Purple.PluginPrefType type);
 
1226
                [CCode (has_construct_function = false)]
 
1227
                public PluginPref.with_label (string label);
 
1228
                [CCode (has_construct_function = false)]
 
1229
                public PluginPref.with_name (string name);
 
1230
                [CCode (has_construct_function = false)]
 
1231
                public PluginPref.with_name_and_label (string name, string label);
 
1232
        }
 
1233
        [Compact]
 
1234
        [CCode (free_function = "purple_plugin_pref_frame_destroy", cheader_filename = "purple.h")]
 
1235
        public class PluginPrefFrame {
 
1236
                [CCode (has_construct_function = false)]
 
1237
                public PluginPrefFrame ();
 
1238
                public void add (Purple.PluginPref pref);
 
1239
                public unowned GLib.List get_prefs ();
 
1240
        }
 
1241
        [Compact]
 
1242
        [CCode (cheader_filename = "purple.h")]
 
1243
        public class PluginPriority {
 
1244
        }
 
1245
        [Compact]
 
1246
        [CCode (cheader_filename = "purple.h")]
 
1247
        public class PluginProtocolInfo {
 
1248
                public weak GLib.Callback add_buddies;
 
1249
                public weak GLib.Callback add_buddy;
 
1250
                public weak GLib.Callback add_deny;
 
1251
                public weak GLib.Callback add_permit;
 
1252
                public weak GLib.Callback alias_buddy;
 
1253
                public weak GLib.Callback blist_node_menu;
 
1254
                public weak GLib.Callback buddy_free;
 
1255
                public weak GLib.Callback can_receive_file;
 
1256
                public weak GLib.Callback change_passwd;
 
1257
                public weak GLib.Callback chat_info;
 
1258
                public weak GLib.Callback chat_info_defaults;
 
1259
                public weak GLib.Callback chat_invite;
 
1260
                public weak GLib.Callback chat_leave;
 
1261
                public weak GLib.Callback chat_send;
 
1262
                public weak GLib.Callback chat_whisper;
 
1263
                public weak GLib.Callback close;
 
1264
                public weak GLib.Callback convo_closed;
 
1265
                public weak GLib.Callback find_blist_chat;
 
1266
                public weak GLib.Callback get_account_text_table;
 
1267
                public weak GLib.Callback get_attention_types;
 
1268
                public weak GLib.Callback get_cb_away;
 
1269
                public weak GLib.Callback get_cb_info;
 
1270
                public weak GLib.Callback get_cb_real_name;
 
1271
                public weak GLib.Callback get_chat_name;
 
1272
                public weak GLib.Callback get_info;
 
1273
                public weak GLib.Callback get_media_caps;
 
1274
                public weak GLib.Callback group_buddy;
 
1275
                public weak Purple.BuddyIconSpec icon_spec;
 
1276
                public weak GLib.Callback initiate_media;
 
1277
                public weak GLib.Callback join_chat;
 
1278
                public weak GLib.Callback keepalive;
 
1279
                public weak GLib.Callback list_emblem;
 
1280
                public weak GLib.Callback list_icon;
 
1281
                public weak GLib.Callback login;
 
1282
                public weak GLib.Callback new_xfer;
 
1283
                public weak GLib.Callback normalize;
 
1284
                public weak GLib.Callback offline_message;
 
1285
                public Purple.ProtocolOptions options;
 
1286
                public weak GLib.List protocol_options;
 
1287
                public weak GLib.Callback register_user;
 
1288
                public weak GLib.Callback reject_chat;
 
1289
                public weak GLib.Callback rem_deny;
 
1290
                public weak GLib.Callback rem_permit;
 
1291
                public weak GLib.Callback remove_buddies;
 
1292
                public weak GLib.Callback remove_buddy;
 
1293
                public weak GLib.Callback remove_group;
 
1294
                public weak GLib.Callback rename_group;
 
1295
                public weak GLib.Callback roomlist_cancel;
 
1296
                public weak GLib.Callback roomlist_expand_category;
 
1297
                public weak GLib.Callback roomlist_get_list;
 
1298
                public weak GLib.Callback roomlist_room_serialize;
 
1299
                public weak GLib.Callback send_attention;
 
1300
                public weak GLib.Callback send_file;
 
1301
                public weak GLib.Callback send_im;
 
1302
                public weak GLib.Callback send_raw;
 
1303
                public weak GLib.Callback send_typing;
 
1304
                public weak GLib.Callback set_buddy_icon;
 
1305
                public weak GLib.Callback set_chat_topic;
 
1306
                public weak GLib.Callback set_idle;
 
1307
                public weak GLib.Callback set_info;
 
1308
                public weak GLib.Callback set_permit_deny;
 
1309
                public weak GLib.Callback set_status;
 
1310
                public weak GLib.Callback status_text;
 
1311
                public weak GLib.Callback status_types;
 
1312
                public uint struct_size;
 
1313
                public weak GLib.Callback tooltip_text;
 
1314
                public weak GLib.Callback unregister_user;
 
1315
                public weak GLib.List user_splits;
 
1316
                public weak Purple.WhiteboardPrplOps whiteboard_prpl_ops;
 
1317
        }
 
1318
        [Compact]
 
1319
        [CCode (cheader_filename = "purple.h")]
 
1320
        public class PluginUiInfo {
 
1321
                public weak Purple.PluginPrefFrame frame;
 
1322
                public weak GLib.Callback get_plugin_pref_frame;
 
1323
                public int page_num;
 
1324
        }
 
1325
        [Compact]
 
1326
        [CCode (free_function = "purple_pounce_destroy", cheader_filename = "purple.h")]
 
1327
        public class Pounce {
 
1328
                public weak GLib.HashTable actions;
 
1329
                public void* data;
 
1330
                public Purple.PounceEvent events;
 
1331
                public Purple.PounceOption options;
 
1332
                public weak string pouncee;
 
1333
                public weak Purple.Account pouncer;
 
1334
                public bool save;
 
1335
                public weak string ui_type;
 
1336
                [CCode (has_construct_function = false)]
 
1337
                public Pounce (string ui_type, Purple.Account pouncer, string pouncee, Purple.PounceEvent event, Purple.PounceOption option);
 
1338
                public unowned string action_get_attribute (string action, string attr);
 
1339
                public bool action_is_enabled (string action);
 
1340
                public void action_register (string name);
 
1341
                public void action_set_attribute (string action, string attr, string value);
 
1342
                public void action_set_enabled (string action, bool enabled);
 
1343
                public static void destroy_all_by_account (Purple.Account account);
 
1344
                public static void execute (Purple.Account pouncer, string pouncee, Purple.PounceEvent events);
 
1345
                public void* get_data ();
 
1346
                public Purple.PounceEvent get_events ();
 
1347
                public Purple.PounceOption get_options ();
 
1348
                public unowned string get_pouncee ();
 
1349
                public unowned Purple.Account get_pouncer ();
 
1350
                public bool get_save ();
 
1351
                public void set_data (void* data);
 
1352
                public void set_events (Purple.PounceEvent events);
 
1353
                public void set_options (Purple.PounceOption options);
 
1354
                public void set_pouncee (string pouncee);
 
1355
                public void set_pouncer (Purple.Account pouncer);
 
1356
                public void set_save (bool save);
 
1357
        }
 
1358
        [Compact]
 
1359
        [CCode (free_function = "purple_presence_destroy", cheader_filename = "purple.h")]
 
1360
        public class Presence {
 
1361
                [CCode (has_construct_function = false)]
 
1362
                public Presence (Purple.PresenceContext context);
 
1363
                public void add_list (GLib.List source_list);
 
1364
                public void add_status (Purple.Status status);
 
1365
                public int compare (Purple.Presence presence2);
 
1366
                [CCode (has_construct_function = false)]
 
1367
                public Presence.for_account (Purple.Account account);
 
1368
                [CCode (has_construct_function = false)]
 
1369
                public Presence.for_buddy (Purple.Buddy buddy);
 
1370
                [CCode (has_construct_function = false)]
 
1371
                public Presence.for_conv (Purple.Conversation conv);
 
1372
                public unowned Purple.Account get_account ();
 
1373
                public unowned Purple.Status get_active_status ();
 
1374
                public unowned Purple.Buddy get_buddy ();
 
1375
                public unowned string get_chat_user ();
 
1376
                public Purple.PresenceContext get_context ();
 
1377
                public unowned Purple.Conversation get_conversation ();
 
1378
                public ulong get_idle_time ();
 
1379
                public ulong get_login_time ();
 
1380
                public unowned Purple.Status get_status (string status_id);
 
1381
                public unowned GLib.List get_statuses ();
 
1382
                public bool is_available ();
 
1383
                public bool is_idle ();
 
1384
                public bool is_online ();
 
1385
                public bool is_status_active (string status_id);
 
1386
                public bool is_status_primitive_active (Purple.StatusPrimitive primitive);
 
1387
                public void set_idle (bool idle, ulong idle_time);
 
1388
                public void set_login_time (ulong login_time);
 
1389
                public void set_status_active (string status_id, bool active);
 
1390
                public void switch_status (string status_id);
 
1391
        }
 
1392
        [Compact]
 
1393
        [CCode (cheader_filename = "purple.h")]
 
1394
        public class PrivacyUiOps {
 
1395
                public weak GLib.Callback deny_added;
 
1396
                public weak GLib.Callback deny_removed;
 
1397
                public weak GLib.Callback permit_added;
 
1398
                public weak GLib.Callback permit_removed;
 
1399
        }
 
1400
        [Compact]
 
1401
        [CCode (cheader_filename = "purple.h")]
 
1402
        public class ProxyConnectData {
 
1403
        }
 
1404
        [Compact]
 
1405
        [CCode (free_function = "purple_proxy_info_destroy", cheader_filename = "purple.h")]
 
1406
        public class ProxyInfo {
 
1407
                public weak string host;
 
1408
                public weak string password;
 
1409
                public int port;
 
1410
                public Purple.ProxyType type;
 
1411
                public weak string username;
 
1412
                [CCode (has_construct_function = false)]
 
1413
                public ProxyInfo ();
 
1414
                public unowned string get_host ();
 
1415
                public unowned string get_password ();
 
1416
                public int get_port ();
 
1417
                public unowned string get_username ();
 
1418
                public void set_host (string host);
 
1419
                public void set_password (string password);
 
1420
                public void set_port (int port);
 
1421
                public void set_type (Purple.ProxyType type);
 
1422
                public void set_username (string username);
 
1423
        }
 
1424
        [Compact]
 
1425
        [CCode (free_function = "purple_request_field_destroy", cheader_filename = "purple.h")]
 
1426
        public class RequestField {
 
1427
                public weak Purple.RequestFieldGroup group;
 
1428
                public weak string id;
 
1429
                public weak string label;
 
1430
                public bool required;
 
1431
                public Purple.RequestFieldType type;
 
1432
                public weak string type_hint;
 
1433
                public void* u;
 
1434
                public void* ui_data;
 
1435
                public bool visible;
 
1436
                [CCode (has_construct_function = false)]
 
1437
                public RequestField (string id, string text, Purple.RequestFieldType type);
 
1438
                public unowned Purple.Account account_get_default_value ();
 
1439
                public unowned Purple.FilterAccountFunc account_get_filter ();
 
1440
                public bool account_get_show_all ();
 
1441
                public unowned Purple.Account account_get_value ();
 
1442
                public static unowned Purple.RequestField account_new (string id, string text, Purple.Account account);
 
1443
                public void account_set_default_value (Purple.Account default_value);
 
1444
                public void account_set_filter (Purple.FilterAccountFunc filter_func);
 
1445
                public void account_set_show_all (bool show_all);
 
1446
                public void account_set_value (Purple.Account value);
 
1447
                public bool bool_get_default_value ();
 
1448
                public bool bool_get_value ();
 
1449
                public static unowned Purple.RequestField bool_new (string id, string text, bool default_value);
 
1450
                public void bool_set_default_value (bool default_value);
 
1451
                public void bool_set_value (bool value);
 
1452
                public void choice_add (string label);
 
1453
                public int choice_get_default_value ();
 
1454
                public unowned GLib.List choice_get_labels ();
 
1455
                public int choice_get_value ();
 
1456
                public static unowned Purple.RequestField choice_new (string id, string text, int default_value);
 
1457
                public void choice_set_default_value (int default_value);
 
1458
                public void choice_set_value (int value);
 
1459
                public unowned Purple.RequestFieldGroup get_group ();
 
1460
                public unowned string get_id ();
 
1461
                public unowned string get_label ();
 
1462
                public unowned string get_type_hint ();
 
1463
                public void* get_ui_data ();
 
1464
                public unowned string image_get_buffer ();
 
1465
                public uint image_get_scale_x ();
 
1466
                public uint image_get_scale_y ();
 
1467
                public size_t image_get_size ();
 
1468
                public static unowned Purple.RequestField image_new (string id, string text, string buf, size_t size);
 
1469
                public void image_set_scale (uint x, uint y);
 
1470
                public int int_get_default_value ();
 
1471
                public int int_get_value ();
 
1472
                public static unowned Purple.RequestField int_new (string id, string text, int default_value);
 
1473
                public void int_set_default_value (int default_value);
 
1474
                public void int_set_value (int value);
 
1475
                public bool is_required ();
 
1476
                public bool is_visible ();
 
1477
                public static unowned Purple.RequestField label_new (string id, string text);
 
1478
                public void list_add (string item, void* data);
 
1479
                public void list_add_selected (string item);
 
1480
                public void list_clear_selected ();
 
1481
                public void* list_get_data (string text);
 
1482
                public unowned GLib.List list_get_items ();
 
1483
                public bool list_get_multi_select ();
 
1484
                public unowned GLib.List list_get_selected ();
 
1485
                public bool list_is_selected (string item);
 
1486
                public static unowned Purple.RequestField list_new (string id, string text);
 
1487
                public void list_set_multi_select (bool multi_select);
 
1488
                public void list_set_selected (GLib.List items);
 
1489
                public void set_label (string label);
 
1490
                public void set_required (bool required);
 
1491
                public void set_type_hint (string type_hint);
 
1492
                public void set_ui_data (void* ui_data);
 
1493
                public void set_visible (bool visible);
 
1494
                public unowned string string_get_default_value ();
 
1495
                public unowned string string_get_value ();
 
1496
                public bool string_is_editable ();
 
1497
                public bool string_is_masked ();
 
1498
                public bool string_is_multiline ();
 
1499
                public static unowned Purple.RequestField string_new (string id, string text, string default_value, bool multiline);
 
1500
                public void string_set_default_value (string default_value);
 
1501
                public void string_set_editable (bool editable);
 
1502
                public void string_set_masked (bool masked);
 
1503
                public void string_set_value (string value);
 
1504
        }
 
1505
        [Compact]
 
1506
        [CCode (free_function = "purple_request_field_group_destroy", cheader_filename = "purple.h")]
 
1507
        public class RequestFieldGroup {
 
1508
                public weak GLib.List fields;
 
1509
                public weak Purple.RequestFields fields_list;
 
1510
                public weak string title;
 
1511
                [CCode (has_construct_function = false)]
 
1512
                public RequestFieldGroup (string title);
 
1513
                public void add_field (Purple.RequestField field);
 
1514
                public unowned GLib.List get_fields ();
 
1515
                public unowned string get_title ();
 
1516
        }
 
1517
        [Compact]
 
1518
        [CCode (free_function = "purple_request_fields_destroy", cheader_filename = "purple.h")]
 
1519
        public class RequestFields {
 
1520
                public weak GLib.HashTable fields;
 
1521
                public weak GLib.List groups;
 
1522
                public weak GLib.List required_fields;
 
1523
                public void* ui_data;
 
1524
                [CCode (has_construct_function = false)]
 
1525
                public RequestFields ();
 
1526
                public void add_group (Purple.RequestFieldGroup group);
 
1527
                public bool all_required_filled ();
 
1528
                public bool exists (string id);
 
1529
                public unowned Purple.Account get_account (string id);
 
1530
                public bool get_bool (string id);
 
1531
                public int get_choice (string id);
 
1532
                public unowned Purple.RequestField get_field (string id);
 
1533
                public unowned GLib.List get_groups ();
 
1534
                public int get_integer (string id);
 
1535
                public unowned GLib.List get_required ();
 
1536
                public unowned string get_string (string id);
 
1537
                public bool is_field_required (string id);
 
1538
        }
 
1539
        [Compact]
 
1540
        [CCode (cheader_filename = "purple.h")]
 
1541
        public class RequestUiOps {
 
1542
                public weak GLib.Callback close_request;
 
1543
                public weak GLib.Callback request_action;
 
1544
                public weak GLib.Callback request_choice;
 
1545
                public weak GLib.Callback request_fields;
 
1546
                public weak GLib.Callback request_file;
 
1547
                public weak GLib.Callback request_folder;
 
1548
                public weak GLib.Callback request_input;
 
1549
        }
 
1550
        [Compact]
 
1551
        [CCode (ref_function = "purple_roomlist_ref", ref_function_void = true, unref_function = "purple_roomlist_unref", cheader_filename = "purple.h")]
 
1552
        public class Roomlist {
 
1553
                public weak Purple.Account account;
 
1554
                public weak GLib.List fields;
 
1555
                public bool in_progress;
 
1556
                public void* proto_data;
 
1557
                public uint @ref;
 
1558
                public weak GLib.List rooms;
 
1559
                public void* ui_data;
 
1560
                [CCode (has_construct_function = false)]
 
1561
                public Roomlist (Purple.Account account);
 
1562
                public void cancel_get_list ();
 
1563
                public void expand_category (Purple.RoomlistRoom category);
 
1564
                public unowned GLib.List get_fields ();
 
1565
                public bool get_in_progress ();
 
1566
                public static unowned Purple.Roomlist get_list (Purple.Connection gc);
 
1567
                public static unowned Purple.RoomlistUiOps get_ui_ops ();
 
1568
                public void set_fields (GLib.List fields);
 
1569
                public void set_in_progress (bool in_progress);
 
1570
                public static void set_ui_ops (Purple.RoomlistUiOps ops);
 
1571
                public static void show_with_account (Purple.Account account);
 
1572
        }
 
1573
        [Compact]
 
1574
        [CCode (cheader_filename = "purple.h")]
 
1575
        public class RoomlistField {
 
1576
                public bool hidden;
 
1577
                public weak string label;
 
1578
                public weak string name;
 
1579
                public Purple.RoomlistFieldType type;
 
1580
                [CCode (has_construct_function = false)]
 
1581
                public RoomlistField (Purple.RoomlistFieldType type, string label, string name, bool hidden);
 
1582
                public bool get_hidden ();
 
1583
                public unowned string get_label ();
 
1584
        }
 
1585
        [Compact]
 
1586
        [CCode (cheader_filename = "purple.h")]
 
1587
        public class RoomlistRoom {
 
1588
                public bool expanded_once;
 
1589
                public weak GLib.List fields;
 
1590
                public weak string name;
 
1591
                public weak Purple.RoomlistRoom parent;
 
1592
                public Purple.RoomlistRoomType type;
 
1593
                [CCode (has_construct_function = false)]
 
1594
                public RoomlistRoom (Purple.RoomlistRoomType type, string name, Purple.RoomlistRoom parent);
 
1595
                public static void add (Purple.Roomlist list, Purple.RoomlistRoom room);
 
1596
                public static void add_field (Purple.Roomlist list, Purple.RoomlistRoom room, void* field);
 
1597
                public unowned GLib.List get_fields ();
 
1598
                public unowned string get_name ();
 
1599
                public unowned Purple.RoomlistRoom get_parent ();
 
1600
                public static void join (Purple.Roomlist list, Purple.RoomlistRoom room);
 
1601
        }
 
1602
        [Compact]
 
1603
        [CCode (cheader_filename = "purple.h")]
 
1604
        public class RoomlistUiOps {
 
1605
                public weak GLib.Callback add_room;
 
1606
                public weak GLib.Callback create;
 
1607
                public weak GLib.Callback destroy;
 
1608
                public weak GLib.Callback in_progress;
 
1609
                public weak GLib.Callback set_fields;
 
1610
                public weak GLib.Callback show_with_account;
 
1611
        }
 
1612
        [Compact]
 
1613
        [CCode (cheader_filename = "purple.h")]
 
1614
        public class SavedStatus {
 
1615
                [CCode (cname = "purple_savedstatus_new", has_construct_function = false)]
 
1616
                public SavedStatus (string title, Purple.StatusPrimitive type);
 
1617
                [CCode (cname = "purple_savedstatus_activate")]
 
1618
                public void activate ();
 
1619
                [CCode (cname = "purple_savedstatus_activate_for_account")]
 
1620
                public void activate_for_account (Purple.Account account);
 
1621
                [CCode (cname = "purple_savedstatus_delete")]
 
1622
                public static bool @delete (string title);
 
1623
                [CCode (cname = "purple_savedstatus_delete_by_status")]
 
1624
                public void delete_by_status ();
 
1625
                [CCode (cname = "purple_savedstatus_find")]
 
1626
                public static unowned Purple.SavedStatus find (string title);
 
1627
                [CCode (cname = "purple_savedstatus_find_by_creation_time")]
 
1628
                public static unowned Purple.SavedStatus find_by_creation_time (ulong creation_time);
 
1629
                [CCode (cname = "purple_savedstatus_find_transient_by_type_and_message")]
 
1630
                public static unowned Purple.SavedStatus find_transient_by_type_and_message (Purple.StatusPrimitive type, string message);
 
1631
                [CCode (cname = "purple_savedstatus_get_creation_time")]
 
1632
                public ulong get_creation_time ();
 
1633
                [CCode (cname = "purple_savedstatus_get_current")]
 
1634
                public static unowned Purple.SavedStatus get_current ();
 
1635
                [CCode (cname = "purple_savedstatus_get_default")]
 
1636
                public static unowned Purple.SavedStatus get_default ();
 
1637
                [CCode (cname = "purple_savedstatus_get_idleaway")]
 
1638
                public static unowned Purple.SavedStatus get_idleaway ();
 
1639
                [CCode (cname = "purple_savedstatus_get_message")]
 
1640
                public unowned string get_message ();
 
1641
                [CCode (cname = "purple_savedstatus_get_startup")]
 
1642
                public static unowned Purple.SavedStatus get_startup ();
 
1643
                [CCode (cname = "purple_savedstatus_get_substatus")]
 
1644
                public unowned Purple.SavedStatusSub get_substatus (Purple.Account account);
 
1645
                [CCode (cname = "purple_savedstatus_get_title")]
 
1646
                public unowned string get_title ();
 
1647
                [CCode (cname = "purple_savedstatus_has_substatuses")]
 
1648
                public bool has_substatuses ();
 
1649
                [CCode (cname = "purple_savedstatus_is_idleaway")]
 
1650
                public static bool is_idleaway ();
 
1651
                [CCode (cname = "purple_savedstatus_is_transient")]
 
1652
                public bool is_transient ();
 
1653
                [CCode (cname = "purple_savedstatus_set_idleaway")]
 
1654
                public static void set_idleaway (bool idleaway);
 
1655
                [CCode (cname = "purple_savedstatus_set_message")]
 
1656
                public void set_message (string message);
 
1657
                [CCode (cname = "purple_savedstatus_set_substatus")]
 
1658
                public void set_substatus (Purple.Account account, Purple.StatusType type, string message);
 
1659
                [CCode (cname = "purple_savedstatus_set_title")]
 
1660
                public void set_title (string title);
 
1661
                [CCode (cname = "purple_savedstatus_set_type")]
 
1662
                public void set_type (Purple.StatusPrimitive type);
 
1663
                [CCode (cname = "purple_savedstatus_substatus_get_message")]
 
1664
                public static unowned string substatus_get_message (Purple.SavedStatusSub substatus);
 
1665
                [CCode (cname = "purple_savedstatus_substatus_get_type")]
 
1666
                public static unowned Purple.StatusType substatus_get_type (Purple.SavedStatusSub substatus);
 
1667
                [CCode (cname = "purple_savedstatus_unset_substatus")]
 
1668
                public void unset_substatus (Purple.Account account);
 
1669
        }
 
1670
        [Compact]
 
1671
        [CCode (cheader_filename = "purple.h")]
 
1672
        public class SavedStatusSub {
 
1673
        }
 
1674
        [Compact]
 
1675
        [CCode (cheader_filename = "purple.h")]
 
1676
        public class Smiley {
 
1677
                [CCode (has_construct_function = false)]
 
1678
                public Smiley (Purple.StoredImage img, string shortcut);
 
1679
                public void @delete ();
 
1680
                [CCode (has_construct_function = false)]
 
1681
                public Smiley.from_file (string shortcut, string filepath);
 
1682
                public unowned string get_checksum ();
 
1683
                public void* get_data (size_t len);
 
1684
                public unowned string get_extension ();
 
1685
                public unowned string get_full_path ();
 
1686
                public unowned string get_shortcut ();
 
1687
                public unowned Purple.StoredImage get_stored_image ();
 
1688
                public void set_data (uchar[] smiley_data, size_t smiley_data_len);
 
1689
                public bool set_shortcut (string shortcut);
 
1690
        }
 
1691
        [Compact]
 
1692
        [CCode (cheader_filename = "purple.h")]
 
1693
        public class SmileyClass {
 
1694
        }
 
1695
        [Compact]
 
1696
        [CCode (cheader_filename = "purple.h")]
 
1697
        public class SoundTheme {
 
1698
                public weak Purple.Theme parent;
 
1699
                public void* priv;
 
1700
                public unowned string get_file (string event);
 
1701
                public unowned string get_file_full (string event);
 
1702
                public void set_file (string event, string filename);
 
1703
        }
 
1704
        [Compact]
 
1705
        [CCode (cheader_filename = "purple.h")]
 
1706
        public class SoundThemeClass {
 
1707
                public weak Purple.ThemeClass parent_class;
 
1708
        }
 
1709
        [Compact]
 
1710
        [CCode (cheader_filename = "purple.h")]
 
1711
        public class SoundThemeLoader {
 
1712
                public weak Purple.ThemeLoader parent;
 
1713
        }
 
1714
        [Compact]
 
1715
        [CCode (cheader_filename = "purple.h")]
 
1716
        public class SoundThemeLoaderClass {
 
1717
                public weak Purple.ThemeLoaderClass parent_class;
 
1718
        }
 
1719
        [Compact]
 
1720
        [CCode (cheader_filename = "purple.h")]
 
1721
        public class SoundUiOps {
 
1722
                public weak GLib.Callback init;
 
1723
                public weak GLib.Callback play_event;
 
1724
                public weak GLib.Callback play_file;
 
1725
                public weak GLib.Callback uninit;
 
1726
        }
 
1727
        [Compact]
 
1728
        [CCode (cheader_filename = "purple.h")]
 
1729
        public class SrvQueryData {
 
1730
        }
 
1731
        [Compact]
 
1732
        [CCode (cheader_filename = "purple.h")]
 
1733
        public class SrvResponse {
 
1734
                [CCode (array_length = false)]
 
1735
                public weak DBus.ObjectPath[] hostname;
 
1736
                public int port;
 
1737
                public int pref;
 
1738
                public int weight;
 
1739
        }
 
1740
        [Compact]
 
1741
        [CCode (cheader_filename = "purple.h")]
 
1742
        public class SslConnection {
 
1743
                public weak Purple.SslInputFunction connect_cb;
 
1744
                public void* connect_cb_data;
 
1745
                public weak Purple.ProxyConnectData connect_data;
 
1746
                public weak Purple.SslErrorFunction error_cb;
 
1747
                public int fd;
 
1748
                public weak string host;
 
1749
                public uint inpa;
 
1750
                public int port;
 
1751
                public void* private_data;
 
1752
                public weak Purple.SslInputFunction recv_cb;
 
1753
                public void* recv_cb_data;
 
1754
                public weak Purple.CertificateVerifier verifier;
 
1755
        }
 
1756
        [Compact]
 
1757
        [CCode (cheader_filename = "purple.h")]
 
1758
        public class SslOps {
 
1759
                public weak GLib.Callback close;
 
1760
                public weak GLib.Callback connectfunc;
 
1761
                public weak GLib.Callback get_peer_certificates;
 
1762
                public weak GLib.Callback init;
 
1763
                public weak GLib.Callback read;
 
1764
                public weak GLib.Callback uninit;
 
1765
                public weak GLib.Callback write;
 
1766
        }
 
1767
        [Compact]
 
1768
        [CCode (free_function = "purple_status_destroy", cheader_filename = "purple.h")]
 
1769
        public class Status {
 
1770
                [CCode (has_construct_function = false)]
 
1771
                public Status (Purple.StatusType status_type, Purple.Presence presence);
 
1772
                public int compare (Purple.Status status2);
 
1773
                public bool get_attr_boolean (string id);
 
1774
                public int get_attr_int (string id);
 
1775
                public unowned string get_attr_string (string id);
 
1776
                public unowned Purple.Value get_attr_value (string id);
 
1777
                public static void* get_handle ();
 
1778
                public unowned string get_id ();
 
1779
                public unowned string get_name ();
 
1780
                public unowned Purple.Presence get_presence ();
 
1781
                public static void init ();
 
1782
                public bool is_active ();
 
1783
                public bool is_available ();
 
1784
                public bool is_exclusive ();
 
1785
                public bool is_independent ();
 
1786
                public bool is_online ();
 
1787
                public void set_active (bool active);
 
1788
                public void set_active_with_attrs (bool active, void* args);
 
1789
                public void set_active_with_attrs_list (bool active, GLib.List attrs);
 
1790
                public void set_attr_boolean (string id, bool value);
 
1791
                public void set_attr_int (string id, int value);
 
1792
                public void set_attr_string (string id, string value);
 
1793
                public static void uninit ();
 
1794
        }
 
1795
        [Compact]
 
1796
        [CCode (free_function = "purple_status_attr_destroy", cheader_filename = "purple.h")]
 
1797
        public class StatusAttr {
 
1798
                [CCode (has_construct_function = false)]
 
1799
                public StatusAttr (string id, string name, Purple.Value value_type);
 
1800
                public unowned string get_id ();
 
1801
                public unowned string get_name ();
 
1802
                public unowned Purple.Value get_value ();
 
1803
        }
 
1804
        [Compact]
 
1805
        [CCode (free_function = "purple_status_type_destroy", cheader_filename = "purple.h")]
 
1806
        public class StatusType {
 
1807
                [CCode (has_construct_function = false)]
 
1808
                public StatusType (Purple.StatusPrimitive primitive, string id, string name, bool user_settable);
 
1809
                public void add_attr (string id, string name, Purple.Value value);
 
1810
                public void add_attrs (string id, string name, Purple.Value value);
 
1811
                public void add_attrs_vargs (void* args);
 
1812
                public static unowned Purple.StatusType find_with_id (GLib.List status_types, string id);
 
1813
                [CCode (has_construct_function = false)]
 
1814
                public StatusType.full (Purple.StatusPrimitive primitive, string id, string name, bool saveable, bool user_settable, bool independent);
 
1815
                public unowned Purple.StatusAttr get_attr (string id);
 
1816
                public unowned GLib.List get_attrs ();
 
1817
                public unowned string get_id ();
 
1818
                public unowned string get_name ();
 
1819
                public unowned string get_primary_attr ();
 
1820
                public Purple.StatusPrimitive get_primitive ();
 
1821
                public bool is_available ();
 
1822
                public bool is_exclusive ();
 
1823
                public bool is_independent ();
 
1824
                public bool is_saveable ();
 
1825
                public bool is_user_settable ();
 
1826
                public void set_primary_attr (string attr_id);
 
1827
                [CCode (has_construct_function = false)]
 
1828
                public StatusType.with_attrs (Purple.StatusPrimitive primitive, string id, string name, bool saveable, bool user_settable, bool independent, string attr_id, string attr_name, Purple.Value attr_value);
 
1829
        }
 
1830
        [Compact]
 
1831
        [CCode (cheader_filename = "purple.h")]
 
1832
        public class StoredImage {
 
1833
        }
 
1834
        [Compact]
 
1835
        [CCode (ref_function = "purple_stringref_ref", unref_function = "purple_stringref_unref", cheader_filename = "purple.h")]
 
1836
        public class Stringref {
 
1837
                [CCode (has_construct_function = false)]
 
1838
                public Stringref (string value);
 
1839
                public int cmp (Purple.Stringref s2);
 
1840
                public size_t len ();
 
1841
                [CCode (has_construct_function = false)]
 
1842
                public Stringref.noref (string value);
 
1843
                public static unowned Purple.Stringref printf (string format);
 
1844
                public unowned string value ();
 
1845
        }
 
1846
        [Compact]
 
1847
        [CCode (cheader_filename = "purple.h")]
 
1848
        public class StunNatDiscovery {
 
1849
                public ulong lookup_time;
 
1850
                [CCode (array_length = false)]
 
1851
                public weak DBus.ObjectPath[] publicip;
 
1852
                public weak string servername;
 
1853
                public Purple.StunStatus status;
 
1854
                public Purple.StunNatType type;
 
1855
        }
 
1856
        [Compact]
 
1857
        [CCode (cheader_filename = "purple.h")]
 
1858
        public class Theme {
 
1859
                public weak GLib.Object parent;
 
1860
                public void* priv;
 
1861
                public unowned string get_author ();
 
1862
                public unowned string get_description ();
 
1863
                public unowned string get_dir ();
 
1864
                public unowned string get_image ();
 
1865
                public unowned string get_image_full ();
 
1866
                public unowned string get_name ();
 
1867
                public unowned string get_type_string ();
 
1868
                public void set_author (string author);
 
1869
                public void set_description (string description);
 
1870
                public void set_dir (string dir);
 
1871
                public void set_image (string img);
 
1872
                public void set_name (string name);
 
1873
        }
 
1874
        [Compact]
 
1875
        [CCode (cheader_filename = "purple.h")]
 
1876
        public class ThemeClass {
 
1877
                public weak GLib.ObjectClass parent_class;
 
1878
        }
 
1879
        [Compact]
 
1880
        [CCode (cheader_filename = "purple.h")]
 
1881
        public class ThemeLoader {
 
1882
                public weak GLib.Object parent;
 
1883
                public void* priv;
 
1884
                public unowned Purple.Theme build (string dir);
 
1885
                public unowned string get_type_string ();
 
1886
        }
 
1887
        [Compact]
 
1888
        [CCode (cheader_filename = "purple.h")]
 
1889
        public class ThemeLoaderClass {
 
1890
                public weak GLib.ObjectClass parent_class;
 
1891
                public weak GLib.Callback purple_theme_loader_build;
 
1892
        }
 
1893
        [Compact]
 
1894
        [CCode (cheader_filename = "purple.h")]
 
1895
        public class ThemeManager {
 
1896
                public weak GLib.Object parent;
 
1897
                public static void add_theme (Purple.Theme theme);
 
1898
                public static unowned Purple.Theme find_theme (string name, string type);
 
1899
                public static void for_each_theme (Purple.PTFunc func);
 
1900
                public static void init ();
 
1901
                public static unowned Purple.Theme load_theme (string theme_dir, string type);
 
1902
                public static void refresh ();
 
1903
                public static void register_type (Purple.ThemeLoader loader);
 
1904
                public static void remove_theme (Purple.Theme theme);
 
1905
                public static void uninit ();
 
1906
                public static void unregister_type (Purple.ThemeLoader loader);
 
1907
        }
 
1908
        [Compact]
 
1909
        [CCode (cheader_filename = "purple.h")]
 
1910
        public class ThemeManagerClass {
 
1911
                public weak GLib.ObjectClass parent_class;
 
1912
        }
 
1913
        [Compact]
 
1914
        [CCode (free_function = "purple_txt_response_destroy", cheader_filename = "purple.h")]
 
1915
        public class TxtResponse {
 
1916
                public unowned string get_content ();
 
1917
        }
 
1918
        [Compact]
 
1919
        [CCode (cheader_filename = "purple.h")]
 
1920
        public class UPnPMappingAddRemove {
 
1921
        }
 
1922
        [Compact]
 
1923
        [CCode (cheader_filename = "purple.h")]
 
1924
        public class UtilFetchUrlData {
 
1925
        }
 
1926
        [Compact]
 
1927
        [CCode (free_function = "purple_value_destroy", cheader_filename = "purple.h")]
 
1928
        public class Value {
 
1929
                public void* data;
 
1930
                public uint flags;
 
1931
                public Purple.Type type;
 
1932
                public void* u;
 
1933
                [CCode (has_construct_function = false)]
 
1934
                public Value (Purple.Type type);
 
1935
                public unowned Purple.Value dup ();
 
1936
                public bool get_boolean ();
 
1937
                public void* get_boxed ();
 
1938
                public unowned DBus.ObjectPath get_char ();
 
1939
                public int get_enum ();
 
1940
                public int get_int ();
 
1941
                public int64 get_int64 ();
 
1942
                public long get_long ();
 
1943
                public void* get_object ();
 
1944
                public void* get_pointer ();
 
1945
                public short get_short ();
 
1946
                public unowned string get_specific_type ();
 
1947
                public unowned string get_string ();
 
1948
                public uint get_subtype ();
 
1949
                public uint get_uchar ();
 
1950
                public uint get_uint ();
 
1951
                public uint64 get_uint64 ();
 
1952
                public uint get_ulong ();
 
1953
                public uint get_ushort ();
 
1954
                public bool is_outgoing ();
 
1955
                [CCode (has_construct_function = false)]
 
1956
                public Value.outgoing (Purple.Type type);
 
1957
                public void set_boolean (bool data);
 
1958
                public void set_boxed (void* data);
 
1959
                public void set_char (DBus.ObjectPath data);
 
1960
                public void set_enum (int data);
 
1961
                public void set_int (int data);
 
1962
                public void set_int64 (int64 data);
 
1963
                public void set_long (long data);
 
1964
                public void set_object (void* data);
 
1965
                public void set_pointer (void* data);
 
1966
                public void set_short (short data);
 
1967
                public void set_string (string data);
 
1968
                public void set_uchar (uint data);
 
1969
                public void set_uint (uint data);
 
1970
                public void set_uint64 (uint64 data);
 
1971
                public void set_ulong (uint data);
 
1972
                public void set_ushort (uint data);
 
1973
        }
 
1974
        [Compact]
 
1975
        [CCode (free_function = "purple_whiteboard_destroy", cheader_filename = "purple.h")]
 
1976
        public class Whiteboard {
 
1977
                public weak Purple.Account account;
 
1978
                public weak GLib.List draw_list;
 
1979
                public void* proto_data;
 
1980
                public weak Purple.WhiteboardPrplOps prpl_ops;
 
1981
                public int state;
 
1982
                public void* ui_data;
 
1983
                public weak string who;
 
1984
                public void clear ();
 
1985
                public static unowned Purple.Whiteboard create (Purple.Account account, string who, int state);
 
1986
                public void draw_line (int x1, int y1, int x2, int y2, int color, int size);
 
1987
                public static void draw_list_destroy (GLib.List draw_list);
 
1988
                public void draw_point (int x, int y, int color, int size);
 
1989
                public bool get_brush (int size, int color);
 
1990
                public bool get_dimensions (int width, int height);
 
1991
                public static unowned Purple.Whiteboard get_session (Purple.Account account, string who);
 
1992
                public void send_brush (int size, int color);
 
1993
                public void send_clear ();
 
1994
                public void send_draw_list (GLib.List list);
 
1995
                public void set_brush (int size, int color);
 
1996
                public void set_dimensions (int width, int height);
 
1997
                public void set_prpl_ops (Purple.WhiteboardPrplOps ops);
 
1998
                public static void set_ui_ops (Purple.WhiteboardUiOps ops);
 
1999
                public void start ();
 
2000
        }
 
2001
        [Compact]
 
2002
        [CCode (cheader_filename = "purple.h")]
 
2003
        public class WhiteboardPrplOps {
 
2004
                public weak GLib.Callback clear;
 
2005
                public weak GLib.Callback end;
 
2006
                public weak GLib.Callback get_brush;
 
2007
                public weak GLib.Callback get_dimensions;
 
2008
                public weak GLib.Callback send_draw_list;
 
2009
                public weak GLib.Callback set_brush;
 
2010
                public weak GLib.Callback set_dimensions;
 
2011
                public weak GLib.Callback start;
 
2012
        }
 
2013
        [Compact]
 
2014
        [CCode (cheader_filename = "purple.h")]
 
2015
        public class WhiteboardUiOps {
 
2016
                public weak GLib.Callback clear;
 
2017
                public weak GLib.Callback create;
 
2018
                public weak GLib.Callback destroy;
 
2019
                public weak GLib.Callback draw_line;
 
2020
                public weak GLib.Callback draw_point;
 
2021
                public weak GLib.Callback set_brush;
 
2022
                public weak GLib.Callback set_dimensions;
 
2023
        }
 
2024
        [Compact]
 
2025
        [CCode (ref_function = "purple_xfer_ref", ref_function_void = true, unref_function = "purple_xfer_unref", cheader_filename = "purple.h")]
 
2026
        public class Xfer {
 
2027
                public weak Purple.Account account;
 
2028
                public size_t bytes_remaining;
 
2029
                public size_t bytes_sent;
 
2030
                public size_t current_buffer_size;
 
2031
                public void* data;
 
2032
                public weak GLib.FileStream dest_fp;
 
2033
                public ulong end_time;
 
2034
                public int fd;
 
2035
                public weak string filename;
 
2036
                public weak string local_filename;
 
2037
                public int local_port;
 
2038
                public weak string message;
 
2039
                public void* ops;
 
2040
                public uint @ref;
 
2041
                public weak string remote_ip;
 
2042
                public int remote_port;
 
2043
                public size_t size;
 
2044
                public ulong start_time;
 
2045
                public Purple.XferStatusType status;
 
2046
                public Purple.XferType type;
 
2047
                public void* ui_data;
 
2048
                public weak Purple.XferUiOps ui_ops;
 
2049
                public int watcher;
 
2050
                public weak string who;
 
2051
                [CCode (has_construct_function = false)]
 
2052
                public Xfer (Purple.Account account, Purple.XferType type, string who);
 
2053
                public void add ();
 
2054
                public void cancel_local ();
 
2055
                public void cancel_remote ();
 
2056
                public void conversation_write (string message, bool is_error);
 
2057
                public void end ();
 
2058
                public static void error (Purple.XferType type, Purple.Account account, string who, string msg);
 
2059
                public unowned Purple.Account get_account ();
 
2060
                public size_t get_bytes_remaining ();
 
2061
                public size_t get_bytes_sent ();
 
2062
                public ulong get_end_time ();
 
2063
                public unowned string get_filename ();
 
2064
                public unowned string get_local_filename ();
 
2065
                public uint get_local_port ();
 
2066
                public double get_progress ();
 
2067
                public unowned string get_remote_ip ();
 
2068
                public uint get_remote_port ();
 
2069
                public unowned string get_remote_user ();
 
2070
                public size_t get_size ();
 
2071
                public ulong get_start_time ();
 
2072
                public Purple.XferStatusType get_status ();
 
2073
                public unowned Purple.XferUiOps get_ui_ops ();
 
2074
                public bool is_canceled ();
 
2075
                public bool is_completed ();
 
2076
                public void prpl_ready ();
 
2077
                public ssize_t read (uchar[] buffer);
 
2078
                public void request ();
 
2079
                public void request_accepted (string filename);
 
2080
                public void request_denied ();
 
2081
                public void set_ack_fnc (GLib.Callback fnc);
 
2082
                public void set_bytes_sent (size_t bytes_sent);
 
2083
                public void set_cancel_recv_fnc (GLib.Callback fnc);
 
2084
                public void set_cancel_send_fnc (GLib.Callback fnc);
 
2085
                public void set_completed (bool completed);
 
2086
                public void set_end_fnc (GLib.Callback fnc);
 
2087
                public void set_filename (string filename);
 
2088
                public void set_init_fnc (GLib.Callback fnc);
 
2089
                public void set_local_filename (string filename);
 
2090
                public void set_message (string message);
 
2091
                public void set_read_fnc (GLib.Callback fnc);
 
2092
                public void set_request_denied_fnc (GLib.Callback fnc);
 
2093
                public void set_size (size_t size);
 
2094
                public void set_start_fnc (GLib.Callback fnc);
 
2095
                public void set_write_fnc (GLib.Callback fnc);
 
2096
                public void start (int fd, string ip, uint port);
 
2097
                public void ui_ready ();
 
2098
                public void update_progress ();
 
2099
                public ssize_t write (uchar[] buffer, size_t size);
 
2100
        }
 
2101
        [Compact]
 
2102
        [CCode (cheader_filename = "purple.h")]
 
2103
        public class XferUiOps {
 
2104
                public weak GLib.Callback add_xfer;
 
2105
                public weak GLib.Callback cancel_local;
 
2106
                public weak GLib.Callback cancel_remote;
 
2107
                public weak GLib.Callback data_not_sent;
 
2108
                public weak GLib.Callback destroy;
 
2109
                public weak GLib.Callback new_xfer;
 
2110
                public weak GLib.Callback ui_read;
 
2111
                public weak GLib.Callback ui_write;
 
2112
                public weak GLib.Callback update_progress;
 
2113
        }
 
2114
        [Compact]
 
2115
        [CCode (copy_function = "xmlnode_copy", free_function = "xmlnode_free", cheader_filename = "purple.h")]
 
2116
        public class xmlnode {
 
2117
                public weak string data;
 
2118
                public size_t data_sz;
 
2119
                public weak Purple.xmlnode lastchild;
 
2120
                public weak string name;
 
2121
                public weak GLib.HashTable namespace_map;
 
2122
                public weak Purple.xmlnode next;
 
2123
                public weak Purple.xmlnode parent;
 
2124
                public weak string prefix;
 
2125
                public Purple.XMLNodeType type;
 
2126
                public weak string xmlns;
 
2127
                [CCode (cname = "xmlnode_new", type = "xmlnode*", has_construct_function = false)]
 
2128
                public xmlnode (string name);
 
2129
                [CCode (cname = "xmlnode_new_child", type = "xmlnode*", has_construct_function = false)]
 
2130
                public xmlnode.child (Purple.xmlnode parent, string name);
 
2131
                [CCode (cname = "xmlnode_copy")]
 
2132
                public static unowned Purple.xmlnode copy (Purple.xmlnode src);
 
2133
                [CCode (cname = "xmlnode_from_file")]
 
2134
                public static unowned Purple.xmlnode from_file (string dir, string filename, string description, string process);
 
2135
                [CCode (cname = "xmlnode_from_str")]
 
2136
                public static unowned Purple.xmlnode from_str (string str, ssize_t size);
 
2137
                [CCode (cname = "xmlnode_get_attrib")]
 
2138
                public static unowned string get_attrib (Purple.xmlnode node, string attr);
 
2139
                [CCode (cname = "xmlnode_get_attrib_with_namespace")]
 
2140
                public static unowned string get_attrib_with_namespace (Purple.xmlnode node, string attr, string xmlns);
 
2141
                [CCode (cname = "xmlnode_get_child")]
 
2142
                public static unowned Purple.xmlnode get_child (Purple.xmlnode parent, string name);
 
2143
                [CCode (cname = "xmlnode_get_child_with_namespace")]
 
2144
                public static unowned Purple.xmlnode get_child_with_namespace (Purple.xmlnode parent, string name, string xmlns);
 
2145
                [CCode (cname = "xmlnode_get_data")]
 
2146
                public static unowned string get_data (Purple.xmlnode node);
 
2147
                [CCode (cname = "xmlnode_get_data_unescaped")]
 
2148
                public static unowned string get_data_unescaped (Purple.xmlnode node);
 
2149
                [CCode (cname = "xmlnode_get_namespace")]
 
2150
                public static unowned string get_namespace (Purple.xmlnode node);
 
2151
                [CCode (cname = "xmlnode_get_next_twin")]
 
2152
                public static unowned Purple.xmlnode get_next_twin (Purple.xmlnode node);
 
2153
                [CCode (cname = "xmlnode_get_parent")]
 
2154
                public static unowned Purple.xmlnode get_parent (Purple.xmlnode child);
 
2155
                [CCode (cname = "xmlnode_get_prefix")]
 
2156
                public static unowned string get_prefix (Purple.xmlnode node);
 
2157
                [CCode (cname = "xmlnode_insert_child")]
 
2158
                public static void insert_child (Purple.xmlnode parent, Purple.xmlnode child);
 
2159
                [CCode (cname = "xmlnode_insert_data")]
 
2160
                public static void insert_data (Purple.xmlnode node, string data, ssize_t size);
 
2161
                [CCode (cname = "xmlnode_remove_attrib")]
 
2162
                public static void remove_attrib (Purple.xmlnode node, string attr);
 
2163
                [CCode (cname = "xmlnode_remove_attrib_with_namespace")]
 
2164
                public static void remove_attrib_with_namespace (Purple.xmlnode node, string attr, string xmlns);
 
2165
                [CCode (cname = "xmlnode_set_attrib")]
 
2166
                public static void set_attrib (Purple.xmlnode node, string attr, string value);
 
2167
                [CCode (cname = "xmlnode_set_attrib_full")]
 
2168
                public static void set_attrib_full (Purple.xmlnode node, string attr, string xmlns, string prefix, string value);
 
2169
                [CCode (cname = "xmlnode_set_attrib_with_namespace")]
 
2170
                public static void set_attrib_with_namespace (Purple.xmlnode node, string attr, string xmlns, string value);
 
2171
                [CCode (cname = "xmlnode_set_attrib_with_prefix")]
 
2172
                public static void set_attrib_with_prefix (Purple.xmlnode node, string attr, string prefix, string value);
 
2173
                [CCode (cname = "xmlnode_set_namespace")]
 
2174
                public static void set_namespace (Purple.xmlnode node, string xmlns);
 
2175
                [CCode (cname = "xmlnode_set_prefix")]
 
2176
                public static void set_prefix (Purple.xmlnode node, string prefix);
 
2177
                [CCode (cname = "xmlnode_to_formatted_str")]
 
2178
                public static unowned string to_formatted_str (Purple.xmlnode node, int len);
 
2179
                [CCode (cname = "xmlnode_to_str")]
 
2180
                public static unowned string to_str (Purple.xmlnode node, int len);
 
2181
        }
 
2182
        [CCode (cprefix = "PURPLE_ACCOUNT_REQUEST_", has_type_id = false, cheader_filename = "purple.h")]
 
2183
        public enum AccountRequestType {
 
2184
                AUTHORIZATION
 
2185
        }
 
2186
        [CCode (cprefix = "PURPLE_BLIST_NODE_FLAG_NO_", has_type_id = false, cheader_filename = "purple.h")]
 
2187
        public enum BlistNodeFlags {
 
2188
                SAVE
 
2189
        }
 
2190
        [CCode (cprefix = "PURPLE_BLIST_", has_type_id = false, cheader_filename = "purple.h")]
 
2191
        public enum BlistNodeType {
 
2192
                GROUP_NODE,
 
2193
                CONTACT_NODE,
 
2194
                BUDDY_NODE,
 
2195
                CHAT_NODE,
 
2196
                OTHER_NODE
 
2197
        }
 
2198
        [CCode (cprefix = "PURPLE_CERTIFICATE_", has_type_id = false, cheader_filename = "purple.h")]
 
2199
        public enum CertificateVerificationStatus {
 
2200
                INVALID,
 
2201
                VALID
 
2202
        }
 
2203
        [CCode (cprefix = "PURPLE_CIPHER_BATCH_MODE_", has_type_id = false, cheader_filename = "purple.h")]
 
2204
        public enum CipherBatchMode {
 
2205
                ECB,
 
2206
                CBC
 
2207
        }
 
2208
        [CCode (cprefix = "PURPLE_CIPHER_CAPS_", has_type_id = false, cheader_filename = "purple.h")]
 
2209
        public enum CipherCaps {
 
2210
                SET_OPT,
 
2211
                GET_OPT,
 
2212
                INIT,
 
2213
                RESET,
 
2214
                UNINIT,
 
2215
                SET_IV,
 
2216
                APPEND,
 
2217
                DIGEST,
 
2218
                ENCRYPT,
 
2219
                DECRYPT,
 
2220
                SET_SALT,
 
2221
                GET_SALT_SIZE,
 
2222
                SET_KEY,
 
2223
                GET_KEY_SIZE,
 
2224
                SET_BATCH_MODE,
 
2225
                GET_BATCH_MODE,
 
2226
                GET_BLOCK_SIZE,
 
2227
                SET_KEY_WITH_LEN,
 
2228
                UNKNOWN
 
2229
        }
 
2230
        [CCode (cprefix = "PURPLE_CMD_FLAG_", has_type_id = false, cheader_filename = "purple.h")]
 
2231
        public enum CmdFlag {
 
2232
                IM,
 
2233
                CHAT,
 
2234
                PRPL_ONLY,
 
2235
                ALLOW_WRONG_ARGS
 
2236
        }
 
2237
        [CCode (cprefix = "PURPLE_CMD_P_", has_type_id = false, cheader_filename = "purple.h")]
 
2238
        public enum CmdPriority {
 
2239
                VERY_LOW,
 
2240
                LOW,
 
2241
                DEFAULT,
 
2242
                PRPL,
 
2243
                PLUGIN,
 
2244
                ALIAS,
 
2245
                HIGH,
 
2246
                VERY_HIGH
 
2247
        }
 
2248
        [CCode (cprefix = "PURPLE_CMD_RET_", has_type_id = false, cheader_filename = "purple.h")]
 
2249
        public enum CmdRet {
 
2250
                OK,
 
2251
                FAILED,
 
2252
                CONTINUE
 
2253
        }
 
2254
        [CCode (cprefix = "PURPLE_CMD_STATUS_", has_type_id = false, cheader_filename = "purple.h")]
 
2255
        public enum CmdStatus {
 
2256
                OK,
 
2257
                FAILED,
 
2258
                NOT_FOUND,
 
2259
                WRONG_ARGS,
 
2260
                WRONG_PRPL,
 
2261
                WRONG_TYPE
 
2262
        }
 
2263
        [CCode (cprefix = "PURPLE_CONNECTION_ERROR_", has_type_id = false, cheader_filename = "purple.h")]
 
2264
        public enum ConnectionError {
 
2265
                NETWORK_ERROR,
 
2266
                INVALID_USERNAME,
 
2267
                AUTHENTICATION_FAILED,
 
2268
                AUTHENTICATION_IMPOSSIBLE,
 
2269
                NO_SSL_SUPPORT,
 
2270
                ENCRYPTION_ERROR,
 
2271
                NAME_IN_USE,
 
2272
                INVALID_SETTINGS,
 
2273
                CERT_NOT_PROVIDED,
 
2274
                CERT_UNTRUSTED,
 
2275
                CERT_EXPIRED,
 
2276
                CERT_NOT_ACTIVATED,
 
2277
                CERT_HOSTNAME_MISMATCH,
 
2278
                CERT_FINGERPRINT_MISMATCH,
 
2279
                CERT_SELF_SIGNED,
 
2280
                CERT_OTHER_ERROR,
 
2281
                OTHER_ERROR
 
2282
        }
 
2283
        [CCode (cprefix = "PURPLE_CONNECTION_", has_type_id = false, cheader_filename = "purple.h")]
 
2284
        public enum ConnectionFlags {
 
2285
                HTML,
 
2286
                NO_BGCOLOR,
 
2287
                AUTO_RESP,
 
2288
                FORMATTING_WBFO,
 
2289
                NO_NEWLINES,
 
2290
                NO_FONTSIZE,
 
2291
                NO_URLDESC,
 
2292
                NO_IMAGES,
 
2293
                ALLOW_CUSTOM_SMILEY
 
2294
        }
 
2295
        [CCode (cprefix = "PURPLE_", has_type_id = false, cheader_filename = "purple.h")]
 
2296
        public enum ConnectionState {
 
2297
                DISCONNECTED,
 
2298
                CONNECTED,
 
2299
                CONNECTING
 
2300
        }
 
2301
        [CCode (cprefix = "PURPLE_CBFLAGS_", has_type_id = false, cheader_filename = "purple.h")]
 
2302
        public enum ConvChatBuddyFlags {
 
2303
                NONE,
 
2304
                VOICE,
 
2305
                HALFOP,
 
2306
                OP,
 
2307
                FOUNDER,
 
2308
                TYPING
 
2309
        }
 
2310
        [CCode (cprefix = "PURPLE_CONV_", has_type_id = false, cheader_filename = "purple.h")]
 
2311
        public enum ConvUpdateType {
 
2312
                UPDATE_ADD,
 
2313
                UPDATE_REMOVE,
 
2314
                UPDATE_ACCOUNT,
 
2315
                UPDATE_TYPING,
 
2316
                UPDATE_UNSEEN,
 
2317
                UPDATE_LOGGING,
 
2318
                UPDATE_TOPIC,
 
2319
                ACCOUNT_ONLINE,
 
2320
                ACCOUNT_OFFLINE,
 
2321
                UPDATE_AWAY,
 
2322
                UPDATE_ICON,
 
2323
                UPDATE_TITLE,
 
2324
                UPDATE_CHATLEFT,
 
2325
                UPDATE_FEATURES
 
2326
        }
 
2327
        [CCode (cprefix = "PURPLE_CONV_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2328
        public enum ConversationType {
 
2329
                UNKNOWN,
 
2330
                IM,
 
2331
                CHAT,
 
2332
                MISC,
 
2333
                ANY
 
2334
        }
 
2335
        [CCode (cprefix = "PURPLE_DEBUG_", has_type_id = false, cheader_filename = "purple.h")]
 
2336
        public enum DebugLevel {
 
2337
                ALL,
 
2338
                MISC,
 
2339
                INFO,
 
2340
                WARNING,
 
2341
                ERROR,
 
2342
                FATAL
 
2343
        }
 
2344
        [CCode (cprefix = "PURPLE_DESKTOP_ITEM_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2345
        public enum DesktopItemType {
 
2346
                NULL,
 
2347
                OTHER,
 
2348
                APPLICATION,
 
2349
                LINK,
 
2350
                FSDEVICE,
 
2351
                MIME_TYPE,
 
2352
                DIRECTORY,
 
2353
                SERVICE,
 
2354
                SERVICE_TYPE
 
2355
        }
 
2356
        [CCode (cprefix = "PURPLE_ICON_SCALE_", has_type_id = false, cheader_filename = "purple.h")]
 
2357
        public enum IconScaleRules {
 
2358
                DISPLAY,
 
2359
                SEND
 
2360
        }
 
2361
        [CCode (cprefix = "PURPLE_INPUT_", has_type_id = false, cheader_filename = "purple.h")]
 
2362
        public enum InputCondition {
 
2363
                READ,
 
2364
                WRITE
 
2365
        }
 
2366
        [CCode (cprefix = "PURPLE_LOG_READ_NO_", has_type_id = false, cheader_filename = "purple.h")]
 
2367
        public enum LogReadFlags {
 
2368
                NEWLINE
 
2369
        }
 
2370
        [CCode (cprefix = "PURPLE_LOG_", has_type_id = false, cheader_filename = "purple.h")]
 
2371
        public enum LogType {
 
2372
                IM,
 
2373
                CHAT,
 
2374
                SYSTEM
 
2375
        }
 
2376
        [CCode (cprefix = "PURPLE_MEDIA_CANDIDATE_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2377
        public enum MediaCandidateType {
 
2378
                HOST,
 
2379
                SRFLX,
 
2380
                PRFLX,
 
2381
                RELAY,
 
2382
                MULTICAST
 
2383
        }
 
2384
        [CCode (cprefix = "PURPLE_MEDIA_CAPS_", has_type_id = false, cheader_filename = "purple.h")]
 
2385
        public enum MediaCaps {
 
2386
                NONE,
 
2387
                AUDIO,
 
2388
                AUDIO_SINGLE_DIRECTION,
 
2389
                VIDEO,
 
2390
                VIDEO_SINGLE_DIRECTION,
 
2391
                AUDIO_VIDEO,
 
2392
                MODIFY_SESSION,
 
2393
                CHANGE_DIRECTION
 
2394
        }
 
2395
        [CCode (cprefix = "PURPLE_MEDIA_COMPONENT_", has_type_id = false, cheader_filename = "purple.h")]
 
2396
        public enum MediaComponentType {
 
2397
                NONE,
 
2398
                RTP,
 
2399
                RTCP
 
2400
        }
 
2401
        [CCode (cprefix = "PURPLE_MEDIA_ELEMENT_", has_type_id = false, cheader_filename = "purple.h")]
 
2402
        public enum MediaElementType {
 
2403
                NONE,
 
2404
                AUDIO,
 
2405
                VIDEO,
 
2406
                AUDIO_VIDEO,
 
2407
                NO_SRCS,
 
2408
                ONE_SRC,
 
2409
                MULTI_SRC,
 
2410
                REQUEST_SRC,
 
2411
                NO_SINKS,
 
2412
                ONE_SINK,
 
2413
                MULTI_SINK,
 
2414
                REQUEST_SINK,
 
2415
                UNIQUE,
 
2416
                SRC,
 
2417
                SINK
 
2418
        }
 
2419
        [CCode (cprefix = "PURPLE_MEDIA_INFO_", has_type_id = false, cheader_filename = "purple.h")]
 
2420
        public enum MediaInfoType {
 
2421
                HANGUP,
 
2422
                ACCEPT,
 
2423
                REJECT,
 
2424
                MUTE,
 
2425
                UNMUTE,
 
2426
                PAUSE,
 
2427
                UNPAUSE,
 
2428
                HOLD,
 
2429
                UNHOLD
 
2430
        }
 
2431
        [CCode (cprefix = "PURPLE_MEDIA_NETWORK_PROTOCOL_", has_type_id = false, cheader_filename = "purple.h")]
 
2432
        public enum MediaNetworkProtocol {
 
2433
                UDP,
 
2434
                TCP
 
2435
        }
 
2436
        [CCode (cprefix = "PURPLE_MEDIA_", has_type_id = false, cheader_filename = "purple.h")]
 
2437
        public enum MediaSessionType {
 
2438
                NONE,
 
2439
                RECV_AUDIO,
 
2440
                SEND_AUDIO,
 
2441
                RECV_VIDEO,
 
2442
                SEND_VIDEO,
 
2443
                AUDIO,
 
2444
                VIDEO
 
2445
        }
 
2446
        [CCode (cprefix = "PURPLE_MEDIA_STATE_", has_type_id = false, cheader_filename = "purple.h")]
 
2447
        public enum MediaState {
 
2448
                NEW,
 
2449
                CONNECTED,
 
2450
                END
 
2451
        }
 
2452
        [CCode (cprefix = "PURPLE_MESSAGE_", has_type_id = false, cheader_filename = "purple.h")]
 
2453
        public enum MessageFlags {
 
2454
                SEND,
 
2455
                RECV,
 
2456
                SYSTEM,
 
2457
                AUTO_RESP,
 
2458
                ACTIVE_ONLY,
 
2459
                NICK,
 
2460
                NO_LOG,
 
2461
                WHISPER,
 
2462
                ERROR,
 
2463
                DELAYED,
 
2464
                RAW,
 
2465
                IMAGES,
 
2466
                NOTIFY,
 
2467
                NO_LINKIFY,
 
2468
                INVISIBLE
 
2469
        }
 
2470
        [CCode (cprefix = "PURPLE_NOTIFY_MSG_", has_type_id = false, cheader_filename = "purple.h")]
 
2471
        public enum NotifyMsgType {
 
2472
                ERROR,
 
2473
                WARNING,
 
2474
                INFO
 
2475
        }
 
2476
        [CCode (cprefix = "PURPLE_NOTIFY_BUTTON_", has_type_id = false, cheader_filename = "purple.h")]
 
2477
        public enum NotifySearchButtonType {
 
2478
                LABELED,
 
2479
                CONTINUE,
 
2480
                ADD,
 
2481
                INFO,
 
2482
                IM,
 
2483
                JOIN,
 
2484
                INVITE
 
2485
        }
 
2486
        [CCode (cprefix = "PURPLE_NOTIFY_", has_type_id = false, cheader_filename = "purple.h")]
 
2487
        public enum NotifyType {
 
2488
                MESSAGE,
 
2489
                EMAIL,
 
2490
                EMAILS,
 
2491
                FORMATTED,
 
2492
                SEARCHRESULTS,
 
2493
                USERINFO,
 
2494
                URI
 
2495
        }
 
2496
        [CCode (cprefix = "PURPLE_NOTIFY_USER_INFO_ENTRY_", has_type_id = false, cheader_filename = "purple.h")]
 
2497
        public enum NotifyUserInfoEntryType {
 
2498
                PAIR,
 
2499
                SECTION_BREAK,
 
2500
                SECTION_HEADER
 
2501
        }
 
2502
        [CCode (cprefix = "PURPLE_PLUGIN_PREF_", has_type_id = false, cheader_filename = "purple.h")]
 
2503
        public enum PluginPrefType {
 
2504
                NONE,
 
2505
                CHOICE,
 
2506
                INFO,
 
2507
                STRING_FORMAT
 
2508
        }
 
2509
        [CCode (cprefix = "PURPLE_PLUGIN_", has_type_id = false, cheader_filename = "purple.h")]
 
2510
        public enum PluginType {
 
2511
                UNKNOWN,
 
2512
                STANDARD,
 
2513
                LOADER,
 
2514
                PROTOCOL
 
2515
        }
 
2516
        [CCode (cprefix = "PURPLE_PMP_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2517
        public enum PmpType {
 
2518
                UDP,
 
2519
                TCP
 
2520
        }
 
2521
        [CCode (cprefix = "PURPLE_POUNCE_", has_type_id = false, cheader_filename = "purple.h")]
 
2522
        public enum PounceEvent {
 
2523
                NONE,
 
2524
                SIGNON,
 
2525
                SIGNOFF,
 
2526
                AWAY,
 
2527
                AWAY_RETURN,
 
2528
                IDLE,
 
2529
                IDLE_RETURN,
 
2530
                TYPING,
 
2531
                TYPED,
 
2532
                TYPING_STOPPED,
 
2533
                MESSAGE_RECEIVED
 
2534
        }
 
2535
        [CCode (cprefix = "PURPLE_POUNCE_OPTION_", has_type_id = false, cheader_filename = "purple.h")]
 
2536
        public enum PounceOption {
 
2537
                NONE,
 
2538
                AWAY
 
2539
        }
 
2540
        [CCode (cprefix = "PURPLE_PREF_", has_type_id = false, cheader_filename = "purple.h")]
 
2541
        public enum PrefType {
 
2542
                NONE,
 
2543
                BOOLEAN,
 
2544
                INT,
 
2545
                STRING,
 
2546
                STRING_LIST,
 
2547
                PATH,
 
2548
                PATH_LIST
 
2549
        }
 
2550
        [CCode (cprefix = "PURPLE_PRESENCE_CONTEXT_", has_type_id = false, cheader_filename = "purple.h")]
 
2551
        public enum PresenceContext {
 
2552
                UNSET,
 
2553
                ACCOUNT,
 
2554
                CONV,
 
2555
                BUDDY
 
2556
        }
 
2557
        [CCode (cprefix = "PURPLE_PRIVACY_", has_type_id = false, cheader_filename = "purple.h")]
 
2558
        public enum PrivacyType {
 
2559
                ALLOW_ALL,
 
2560
                DENY_ALL,
 
2561
                ALLOW_USERS,
 
2562
                DENY_USERS,
 
2563
                ALLOW_BUDDYLIST
 
2564
        }
 
2565
        [CCode (cprefix = "OPT_PROTO_", has_type_id = false, cheader_filename = "purple.h")]
 
2566
        public enum ProtocolOptions {
 
2567
                UNIQUE_CHATNAME,
 
2568
                CHAT_TOPIC,
 
2569
                NO_PASSWORD,
 
2570
                MAIL_CHECK,
 
2571
                IM_IMAGE,
 
2572
                PASSWORD_OPTIONAL,
 
2573
                USE_POINTSIZE,
 
2574
                REGISTER_NOSCREENNAME,
 
2575
                SLASH_COMMANDS_NATIVE
 
2576
        }
 
2577
        [CCode (cprefix = "PURPLE_PROXY_", has_type_id = false, cheader_filename = "purple.h")]
 
2578
        public enum ProxyType {
 
2579
                USE_GLOBAL,
 
2580
                NONE,
 
2581
                HTTP,
 
2582
                SOCKS4,
 
2583
                SOCKS5,
 
2584
                USE_ENVVAR
 
2585
        }
 
2586
        [CCode (cprefix = "PURPLE_REQUEST_FIELD_", has_type_id = false, cheader_filename = "purple.h")]
 
2587
        public enum RequestFieldType {
 
2588
                NONE,
 
2589
                STRING,
 
2590
                INTEGER,
 
2591
                BOOLEAN,
 
2592
                CHOICE,
 
2593
                LIST,
 
2594
                LABEL,
 
2595
                IMAGE,
 
2596
                ACCOUNT
 
2597
        }
 
2598
        [CCode (cprefix = "PURPLE_REQUEST_", has_type_id = false, cheader_filename = "purple.h")]
 
2599
        public enum RequestType {
 
2600
                INPUT,
 
2601
                CHOICE,
 
2602
                ACTION,
 
2603
                FIELDS,
 
2604
                FILE,
 
2605
                FOLDER
 
2606
        }
 
2607
        [CCode (cprefix = "PURPLE_ROOMLIST_FIELD_", has_type_id = false, cheader_filename = "purple.h")]
 
2608
        public enum RoomlistFieldType {
 
2609
                BOOL,
 
2610
                INT,
 
2611
                STRING
 
2612
        }
 
2613
        [CCode (cprefix = "PURPLE_ROOMLIST_ROOMTYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2614
        public enum RoomlistRoomType {
 
2615
                CATEGORY,
 
2616
                ROOM
 
2617
        }
 
2618
        [CCode (cprefix = "PURPLE_", has_type_id = false, cheader_filename = "purple.h")]
 
2619
        public enum SoundEventID {
 
2620
                SOUND_BUDDY_ARRIVE,
 
2621
                SOUND_BUDDY_LEAVE,
 
2622
                SOUND_RECEIVE,
 
2623
                SOUND_FIRST_RECEIVE,
 
2624
                SOUND_SEND,
 
2625
                SOUND_CHAT_JOIN,
 
2626
                SOUND_CHAT_LEAVE,
 
2627
                SOUND_CHAT_YOU_SAY,
 
2628
                SOUND_CHAT_SAY,
 
2629
                SOUND_POUNCE_DEFAULT,
 
2630
                SOUND_CHAT_NICK,
 
2631
                NUM_SOUNDS
 
2632
        }
 
2633
        [CCode (cprefix = "PURPLE_SSL_", has_type_id = false, cheader_filename = "purple.h")]
 
2634
        public enum SslErrorType {
 
2635
                HANDSHAKE_FAILED,
 
2636
                CONNECT_FAILED,
 
2637
                CERTIFICATE_INVALID
 
2638
        }
 
2639
        [CCode (cprefix = "PURPLE_STATUS_", has_type_id = false, cheader_filename = "purple.h")]
 
2640
        public enum StatusPrimitive {
 
2641
                UNSET,
 
2642
                OFFLINE,
 
2643
                AVAILABLE,
 
2644
                UNAVAILABLE,
 
2645
                INVISIBLE,
 
2646
                AWAY,
 
2647
                EXTENDED_AWAY,
 
2648
                MOBILE,
 
2649
                TUNE,
 
2650
                NUM_PRIMITIVES
 
2651
        }
 
2652
        [CCode (cprefix = "PURPLE_STRING_FORMAT_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2653
        public enum StringFormatType {
 
2654
                NONE,
 
2655
                MULTILINE,
 
2656
                HTML
 
2657
        }
 
2658
        [CCode (cprefix = "PURPLE_STUN_NAT_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2659
        public enum StunNatType {
 
2660
                PUBLIC_IP,
 
2661
                UNKNOWN_NAT,
 
2662
                FULL_CONE,
 
2663
                RESTRICTED_CONE,
 
2664
                PORT_RESTRICTED_CONE,
 
2665
                SYMMETRIC
 
2666
        }
 
2667
        [CCode (cprefix = "PURPLE_STUN_STATUS_", has_type_id = false, cheader_filename = "purple.h")]
 
2668
        public enum StunStatus {
 
2669
                UNDISCOVERED,
 
2670
                UNKNOWN,
 
2671
                DISCOVERING,
 
2672
                DISCOVERED
 
2673
        }
 
2674
        [CCode (cprefix = "PURPLE_SUBTYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2675
        public enum SubType {
 
2676
                UNKNOWN,
 
2677
                ACCOUNT,
 
2678
                BLIST,
 
2679
                BLIST_BUDDY,
 
2680
                BLIST_GROUP,
 
2681
                BLIST_CHAT,
 
2682
                BUDDY_ICON,
 
2683
                CONNECTION,
 
2684
                CONVERSATION,
 
2685
                PLUGIN,
 
2686
                BLIST_NODE,
 
2687
                CIPHER,
 
2688
                STATUS,
 
2689
                LOG,
 
2690
                XFER,
 
2691
                SAVEDSTATUS,
 
2692
                XMLNODE,
 
2693
                USERINFO,
 
2694
                STORED_IMAGE,
 
2695
                CERTIFICATEPOOL
 
2696
        }
 
2697
        [CCode (cprefix = "PURPLE_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2698
        public enum Type {
 
2699
                UNKNOWN,
 
2700
                SUBTYPE,
 
2701
                CHAR,
 
2702
                UCHAR,
 
2703
                BOOLEAN,
 
2704
                SHORT,
 
2705
                USHORT,
 
2706
                INT,
 
2707
                UINT,
 
2708
                LONG,
 
2709
                ULONG,
 
2710
                INT64,
 
2711
                UINT64,
 
2712
                STRING,
 
2713
                OBJECT,
 
2714
                POINTER,
 
2715
                ENUM,
 
2716
                BOXED
 
2717
        }
 
2718
        [CCode (cprefix = "PURPLE_", has_type_id = false, cheader_filename = "purple.h")]
 
2719
        public enum TypingState {
 
2720
                NOT_TYPING,
 
2721
                TYPING,
 
2722
                TYPED
 
2723
        }
 
2724
        [CCode (cprefix = "XMLNODE_TYPE_", has_type_id = false, cheader_filename = "purple.h")]
 
2725
        public enum XMLNodeType {
 
2726
                TAG,
 
2727
                ATTRIB,
 
2728
                DATA
 
2729
        }
 
2730
        [CCode (cprefix = "PURPLE_XFER_STATUS_", has_type_id = false, cheader_filename = "purple.h")]
 
2731
        public enum XferStatusType {
 
2732
                UNKNOWN,
 
2733
                NOT_STARTED,
 
2734
                ACCEPTED,
 
2735
                STARTED,
 
2736
                DONE,
 
2737
                CANCEL_LOCAL,
 
2738
                CANCEL_REMOTE
 
2739
        }
 
2740
        [CCode (cprefix = "PURPLE_XFER_", has_type_id = false, cheader_filename = "purple.h")]
 
2741
        public enum XferType {
 
2742
                UNKNOWN,
 
2743
                SEND,
 
2744
                RECEIVE
 
2745
        }
 
2746
        [CCode (cheader_filename = "purple.h")]
 
2747
        public delegate void AccountRegistrationCb (Purple.Account account, bool succeeded);
 
2748
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2749
        public delegate void AccountRequestAuthorizationCb (void* p1);
 
2750
        [CCode (cheader_filename = "purple.h")]
 
2751
        public delegate void AccountUnregistrationCb (Purple.Account account, bool succeeded);
 
2752
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2753
        public delegate void Callback ();
 
2754
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2755
        public delegate void CertificateVerifiedCallback (Purple.CertificateVerificationStatus st, void* userdata);
 
2756
        [CCode (cheader_filename = "purple.h")]
 
2757
        public delegate Purple.CmdRet CmdFunc (Purple.Conversation p1, string cmd, string args, string error);
 
2758
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2759
        public delegate void DnsQueryConnectFunction (GLib.SList hosts, void* data, string error_message);
 
2760
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2761
        public delegate void DnsQueryFailedCallback (Purple.DnsQueryData query_data, string error_message);
 
2762
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2763
        public delegate void DnsQueryResolvedCallback (Purple.DnsQueryData query_data, GLib.SList hosts);
 
2764
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2765
        public delegate bool FilterAccountFunc (Purple.Account account);
 
2766
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2767
        public delegate unowned string InfoFieldFormatCallback (string field, size_t len);
 
2768
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2769
        public delegate void InputFunction (void* p1, int p2, Purple.InputCondition p3);
 
2770
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2771
        public delegate void LogSetCallback (GLib.HashTable sets, Purple.LogSet @set);
 
2772
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2773
        public delegate unowned Gst.Element MediaElementCreateCallback (Purple.Media media, string session_id, string participant);
 
2774
        [CCode (cheader_filename = "purple.h")]
 
2775
        public delegate void NetworkListenCallback (int listenfd);
 
2776
        [CCode (cheader_filename = "purple.h")]
 
2777
        public delegate void NotifyCloseCallback ();
 
2778
        [CCode (cheader_filename = "purple.h")]
 
2779
        public delegate void NotifySearchResultsCallback (Purple.Connection c, GLib.List row);
 
2780
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2781
        public delegate void PTFunc (Purple.Theme p1);
 
2782
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2783
        public delegate void PounceCb (Purple.Pounce p1, Purple.PounceEvent p2, void* p3);
 
2784
        [CCode (cheader_filename = "purple.h")]
 
2785
        public delegate void PrefCallback (string name, Purple.PrefType type, void* val);
 
2786
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2787
        public delegate void ProxyConnectFunction (void* data, int source, string error_message);
 
2788
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2789
        public delegate void RequestActionCb (void* p1, int p2);
 
2790
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2791
        public delegate void RequestChoiceCb (void* p1, int p2);
 
2792
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2793
        public delegate void RequestFieldsCb (void* p1, Purple.RequestFields fields);
 
2794
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2795
        public delegate void RequestFileCb (void* p1, string filename);
 
2796
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2797
        public delegate void RequestInputCb (void* p1, string p2);
 
2798
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2799
        public delegate void SignalMarshalFunc (Purple.Callback cb, void* args, void* data, void* return_val);
 
2800
        [CCode (cheader_filename = "purple.h")]
 
2801
        public delegate void SrvCallback (Purple.SrvResponse resp, int results);
 
2802
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2803
        public delegate void SslErrorFunction (Purple.SslConnection p1, Purple.SslErrorType p2, void* p3);
 
2804
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2805
        public delegate void SslInputFunction (void* p1, Purple.SslConnection p2, Purple.InputCondition p3);
 
2806
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2807
        public delegate void StunCallback (Purple.StunNatDiscovery p1);
 
2808
        [CCode (cheader_filename = "purple.h")]
 
2809
        public delegate void TxtCallback (GLib.List responses);
 
2810
        [CCode (cheader_filename = "purple.h")]
 
2811
        public delegate void UPnPCallback (bool success);
 
2812
        [CCode (cheader_filename = "purple.h", has_target = false)]
 
2813
        public delegate void UtilFetchUrlCallback (Purple.UtilFetchUrlData url_data, void* user_data, string url_text, size_t len, string error_message);
 
2814
        [CCode (cheader_filename = "purple.h")]
 
2815
        public const string DBUS_INTERFACE_PURPLE;
 
2816
        [CCode (cheader_filename = "purple.h")]
 
2817
        public const string DBUS_PATH_PURPLE;
 
2818
        [CCode (cheader_filename = "purple.h")]
 
2819
        public const string DBUS_SERVICE_PURPLE;
 
2820
        [CCode (cheader_filename = "purple.h")]
 
2821
        public const int DEFAULT_ACTION_NONE;
 
2822
        [CCode (cheader_filename = "purple.h")]
 
2823
        public const string DESKTOP_ITEM_ACTIONS;
 
2824
        [CCode (cheader_filename = "purple.h")]
 
2825
        public const string DESKTOP_ITEM_COMMENT;
 
2826
        [CCode (cheader_filename = "purple.h")]
 
2827
        public const string DESKTOP_ITEM_DEFAULT_APP;
 
2828
        [CCode (cheader_filename = "purple.h")]
 
2829
        public const string DESKTOP_ITEM_DEV;
 
2830
        [CCode (cheader_filename = "purple.h")]
 
2831
        public const string DESKTOP_ITEM_DOC_PATH;
 
2832
        [CCode (cheader_filename = "purple.h")]
 
2833
        public const string DESKTOP_ITEM_ENCODING;
 
2834
        [CCode (cheader_filename = "purple.h")]
 
2835
        public const string DESKTOP_ITEM_EXEC;
 
2836
        [CCode (cheader_filename = "purple.h")]
 
2837
        public const string DESKTOP_ITEM_FILE_PATTERN;
 
2838
        [CCode (cheader_filename = "purple.h")]
 
2839
        public const string DESKTOP_ITEM_FS_TYPE;
 
2840
        [CCode (cheader_filename = "purple.h")]
 
2841
        public const string DESKTOP_ITEM_GENERIC_NAME;
 
2842
        [CCode (cheader_filename = "purple.h")]
 
2843
        public const string DESKTOP_ITEM_HIDDEN;
 
2844
        [CCode (cheader_filename = "purple.h")]
 
2845
        public const string DESKTOP_ITEM_ICON;
 
2846
        [CCode (cheader_filename = "purple.h")]
 
2847
        public const string DESKTOP_ITEM_MIME_TYPE;
 
2848
        [CCode (cheader_filename = "purple.h")]
 
2849
        public const string DESKTOP_ITEM_MINI_ICON;
 
2850
        [CCode (cheader_filename = "purple.h")]
 
2851
        public const string DESKTOP_ITEM_MOUNT_POINT;
 
2852
        [CCode (cheader_filename = "purple.h")]
 
2853
        public const string DESKTOP_ITEM_NAME;
 
2854
        [CCode (cheader_filename = "purple.h")]
 
2855
        public const string DESKTOP_ITEM_NO_DISPLAY;
 
2856
        [CCode (cheader_filename = "purple.h")]
 
2857
        public const string DESKTOP_ITEM_PATH;
 
2858
        [CCode (cheader_filename = "purple.h")]
 
2859
        public const string DESKTOP_ITEM_PATTERNS;
 
2860
        [CCode (cheader_filename = "purple.h")]
 
2861
        public const string DESKTOP_ITEM_READ_ONLY;
 
2862
        [CCode (cheader_filename = "purple.h")]
 
2863
        public const string DESKTOP_ITEM_SORT_ORDER;
 
2864
        [CCode (cheader_filename = "purple.h")]
 
2865
        public const string DESKTOP_ITEM_SWALLOW_EXEC;
 
2866
        [CCode (cheader_filename = "purple.h")]
 
2867
        public const string DESKTOP_ITEM_SWALLOW_TITLE;
 
2868
        [CCode (cheader_filename = "purple.h")]
 
2869
        public const string DESKTOP_ITEM_TERMINAL;
 
2870
        [CCode (cheader_filename = "purple.h")]
 
2871
        public const string DESKTOP_ITEM_TERMINAL_OPTIONS;
 
2872
        [CCode (cheader_filename = "purple.h")]
 
2873
        public const string DESKTOP_ITEM_TRY_EXEC;
 
2874
        [CCode (cheader_filename = "purple.h")]
 
2875
        public const string DESKTOP_ITEM_TYPE;
 
2876
        [CCode (cheader_filename = "purple.h")]
 
2877
        public const string DESKTOP_ITEM_UNMOUNT_ICON;
 
2878
        [CCode (cheader_filename = "purple.h")]
 
2879
        public const string DESKTOP_ITEM_URL;
 
2880
        [CCode (cheader_filename = "purple.h")]
 
2881
        public const string DESKTOP_ITEM_VERSION;
 
2882
        [CCode (cheader_filename = "purple.h")]
 
2883
        public const string GAIM_DESKTOP_ITEM_ACTIONS;
 
2884
        [CCode (cheader_filename = "purple.h")]
 
2885
        public const string GAIM_DESKTOP_ITEM_COMMENT;
 
2886
        [CCode (cheader_filename = "purple.h")]
 
2887
        public const string GAIM_DESKTOP_ITEM_DEFAULT_APP;
 
2888
        [CCode (cheader_filename = "purple.h")]
 
2889
        public const string GAIM_DESKTOP_ITEM_DEV;
 
2890
        [CCode (cheader_filename = "purple.h")]
 
2891
        public const string GAIM_DESKTOP_ITEM_DOC_PATH;
 
2892
        [CCode (cheader_filename = "purple.h")]
 
2893
        public const string GAIM_DESKTOP_ITEM_ENCODING;
 
2894
        [CCode (cheader_filename = "purple.h")]
 
2895
        public const string GAIM_DESKTOP_ITEM_EXEC;
 
2896
        [CCode (cheader_filename = "purple.h")]
 
2897
        public const string GAIM_DESKTOP_ITEM_FILE_PATTERN;
 
2898
        [CCode (cheader_filename = "purple.h")]
 
2899
        public const string GAIM_DESKTOP_ITEM_FS_TYPE;
 
2900
        [CCode (cheader_filename = "purple.h")]
 
2901
        public const string GAIM_DESKTOP_ITEM_GENERIC_NAME;
 
2902
        [CCode (cheader_filename = "purple.h")]
 
2903
        public const string GAIM_DESKTOP_ITEM_HIDDEN;
 
2904
        [CCode (cheader_filename = "purple.h")]
 
2905
        public const string GAIM_DESKTOP_ITEM_ICON;
 
2906
        [CCode (cheader_filename = "purple.h")]
 
2907
        public const string GAIM_DESKTOP_ITEM_MIME_TYPE;
 
2908
        [CCode (cheader_filename = "purple.h")]
 
2909
        public const string GAIM_DESKTOP_ITEM_MINI_ICON;
 
2910
        [CCode (cheader_filename = "purple.h")]
 
2911
        public const string GAIM_DESKTOP_ITEM_MOUNT_POINT;
 
2912
        [CCode (cheader_filename = "purple.h")]
 
2913
        public const string GAIM_DESKTOP_ITEM_NAME;
 
2914
        [CCode (cheader_filename = "purple.h")]
 
2915
        public const string GAIM_DESKTOP_ITEM_NO_DISPLAY;
 
2916
        [CCode (cheader_filename = "purple.h")]
 
2917
        public const string GAIM_DESKTOP_ITEM_PATH;
 
2918
        [CCode (cheader_filename = "purple.h")]
 
2919
        public const string GAIM_DESKTOP_ITEM_PATTERNS;
 
2920
        [CCode (cheader_filename = "purple.h")]
 
2921
        public const string GAIM_DESKTOP_ITEM_READ_ONLY;
 
2922
        [CCode (cheader_filename = "purple.h")]
 
2923
        public const string GAIM_DESKTOP_ITEM_SORT_ORDER;
 
2924
        [CCode (cheader_filename = "purple.h")]
 
2925
        public const string GAIM_DESKTOP_ITEM_SWALLOW_EXEC;
 
2926
        [CCode (cheader_filename = "purple.h")]
 
2927
        public const string GAIM_DESKTOP_ITEM_SWALLOW_TITLE;
 
2928
        [CCode (cheader_filename = "purple.h")]
 
2929
        public const string GAIM_DESKTOP_ITEM_TERMINAL;
 
2930
        [CCode (cheader_filename = "purple.h")]
 
2931
        public const string GAIM_DESKTOP_ITEM_TERMINAL_OPTIONS;
 
2932
        [CCode (cheader_filename = "purple.h")]
 
2933
        public const string GAIM_DESKTOP_ITEM_TRY_EXEC;
 
2934
        [CCode (cheader_filename = "purple.h")]
 
2935
        public const string GAIM_DESKTOP_ITEM_TYPE;
 
2936
        [CCode (cheader_filename = "purple.h")]
 
2937
        public const string GAIM_DESKTOP_ITEM_UNMOUNT_ICON;
 
2938
        [CCode (cheader_filename = "purple.h")]
 
2939
        public const string GAIM_DESKTOP_ITEM_URL;
 
2940
        [CCode (cheader_filename = "purple.h")]
 
2941
        public const string GAIM_DESKTOP_ITEM_VERSION;
 
2942
        [CCode (cheader_filename = "purple.h")]
 
2943
        public const int MAJOR_VERSION;
 
2944
        [CCode (cheader_filename = "purple.h")]
 
2945
        public const int MICRO_VERSION;
 
2946
        [CCode (cheader_filename = "purple.h")]
 
2947
        public const int MINOR_VERSION;
 
2948
        [CCode (cheader_filename = "purple.h")]
 
2949
        public const int NO_TZ_OFF;
 
2950
        [CCode (cheader_filename = "purple.h")]
 
2951
        public const int PLUGINS;
 
2952
        [CCode (cheader_filename = "purple.h")]
 
2953
        public const int PLUGIN_FLAG_INVISIBLE;
 
2954
        [CCode (cheader_filename = "purple.h")]
 
2955
        public const int PLUGIN_MAGIC;
 
2956
        [CCode (cheader_filename = "purple.h")]
 
2957
        public const int PMP_LIFETIME;
 
2958
        [CCode (cheader_filename = "purple.h")]
 
2959
        public const int PRIORITY_DEFAULT;
 
2960
        [CCode (cheader_filename = "purple.h")]
 
2961
        public const int PRIORITY_HIGHEST;
 
2962
        [CCode (cheader_filename = "purple.h")]
 
2963
        public const int PRIORITY_LOWEST;
 
2964
        [CCode (cheader_filename = "purple.h")]
 
2965
        public const int SIGNAL_PRIORITY_DEFAULT;
 
2966
        [CCode (cheader_filename = "purple.h")]
 
2967
        public const int SIGNAL_PRIORITY_HIGHEST;
 
2968
        [CCode (cheader_filename = "purple.h")]
 
2969
        public const int SIGNAL_PRIORITY_LOWEST;
 
2970
        [CCode (cheader_filename = "purple.h")]
 
2971
        public const int SSL_DEFAULT_PORT;
 
2972
        [CCode (cheader_filename = "purple.h")]
 
2973
        public const string TUNE_ALBUM;
 
2974
        [CCode (cheader_filename = "purple.h")]
 
2975
        public const string TUNE_ARTIST;
 
2976
        [CCode (cheader_filename = "purple.h")]
 
2977
        public const string TUNE_COMMENT;
 
2978
        [CCode (cheader_filename = "purple.h")]
 
2979
        public const string TUNE_FULL;
 
2980
        [CCode (cheader_filename = "purple.h")]
 
2981
        public const string TUNE_GENRE;
 
2982
        [CCode (cheader_filename = "purple.h")]
 
2983
        public const string TUNE_TIME;
 
2984
        [CCode (cheader_filename = "purple.h")]
 
2985
        public const string TUNE_TITLE;
 
2986
        [CCode (cheader_filename = "purple.h")]
 
2987
        public const string TUNE_TRACK;
 
2988
        [CCode (cheader_filename = "purple.h")]
 
2989
        public const string TUNE_URL;
 
2990
        [CCode (cheader_filename = "purple.h")]
 
2991
        public const string TUNE_YEAR;
 
2992
        [CCode (cheader_filename = "purple.h")]
 
2993
        public static void accounts_add (Purple.Account account);
 
2994
        [CCode (cheader_filename = "purple.h")]
 
2995
        public static void accounts_delete (Purple.Account account);
 
2996
        [CCode (cheader_filename = "purple.h")]
 
2997
        public static unowned Purple.Account accounts_find (string name, string protocol);
 
2998
        [CCode (cheader_filename = "purple.h")]
 
2999
        public static unowned Purple.Account accounts_find_any (string name, string protocol);
 
3000
        [CCode (cheader_filename = "purple.h")]
 
3001
        public static unowned Purple.Account accounts_find_connected (string name, string protocol);
 
3002
        [CCode (cheader_filename = "purple.h")]
 
3003
        public static unowned Purple.Account accounts_find_ext (string name, string protocol_id, GLib.Callback account_test);
 
3004
        [CCode (cheader_filename = "purple.h")]
 
3005
        public static unowned GLib.List accounts_get_all ();
 
3006
        [CCode (cheader_filename = "purple.h")]
 
3007
        public static unowned GLib.List accounts_get_all_active ();
 
3008
        [CCode (cheader_filename = "purple.h")]
 
3009
        public static void* accounts_get_handle ();
 
3010
        [CCode (cheader_filename = "purple.h")]
 
3011
        public static unowned Purple.AccountUiOps accounts_get_ui_ops ();
 
3012
        [CCode (cheader_filename = "purple.h")]
 
3013
        public static void accounts_init ();
 
3014
        [CCode (cheader_filename = "purple.h")]
 
3015
        public static void accounts_remove (Purple.Account account);
 
3016
        [CCode (cheader_filename = "purple.h")]
 
3017
        public static void accounts_reorder (Purple.Account account, int new_index);
 
3018
        [CCode (cheader_filename = "purple.h")]
 
3019
        public static void accounts_restore_current_statuses ();
 
3020
        [CCode (cheader_filename = "purple.h")]
 
3021
        public static void accounts_set_ui_ops (Purple.AccountUiOps ops);
 
3022
        [CCode (cheader_filename = "purple.h")]
 
3023
        public static void accounts_uninit ();
 
3024
        [CCode (cheader_filename = "purple.h")]
 
3025
        public static unowned uchar[] base16_decode (string str, size_t ret_len);
 
3026
        [CCode (cheader_filename = "purple.h")]
 
3027
        public static unowned string base16_encode (uchar[] data, size_t len);
 
3028
        [CCode (cheader_filename = "purple.h")]
 
3029
        public static unowned string base16_encode_chunked (uchar[] data, size_t len);
 
3030
        [CCode (cheader_filename = "purple.h")]
 
3031
        public static unowned uchar[] base64_decode (string str, size_t ret_len);
 
3032
        [CCode (cheader_filename = "purple.h")]
 
3033
        public static unowned string base64_encode (uchar[] data, size_t len);
 
3034
        [CCode (cheader_filename = "purple.h")]
 
3035
        public static void blist_add_account (Purple.Account account);
 
3036
        [CCode (cheader_filename = "purple.h")]
 
3037
        public static void blist_add_buddy (Purple.Buddy buddy, Purple.Contact contact, Purple.Group group, Purple.BlistNode node);
 
3038
        [CCode (cheader_filename = "purple.h")]
 
3039
        public static void blist_add_chat (Purple.Chat chat, Purple.Group group, Purple.BlistNode node);
 
3040
        [CCode (cheader_filename = "purple.h")]
 
3041
        public static void blist_add_contact (Purple.Contact contact, Purple.Group group, Purple.BlistNode node);
 
3042
        [CCode (cheader_filename = "purple.h")]
 
3043
        public static void blist_add_group (Purple.Group group, Purple.BlistNode node);
 
3044
        [CCode (cheader_filename = "purple.h")]
 
3045
        public static void blist_alias_buddy (Purple.Buddy buddy, string alias);
 
3046
        [CCode (cheader_filename = "purple.h")]
 
3047
        public static void blist_alias_chat (Purple.Chat chat, string alias);
 
3048
        [CCode (cheader_filename = "purple.h")]
 
3049
        public static void blist_alias_contact (Purple.Contact contact, string alias);
 
3050
        [CCode (cheader_filename = "purple.h")]
 
3051
        public static void blist_destroy ();
 
3052
        [CCode (cheader_filename = "purple.h")]
 
3053
        public static unowned Purple.Chat blist_find_chat (Purple.Account account, string name);
 
3054
        [CCode (cheader_filename = "purple.h")]
 
3055
        public static unowned GLib.SList blist_get_buddies ();
 
3056
        [CCode (cheader_filename = "purple.h")]
 
3057
        public static int blist_get_group_online_count (Purple.Group group);
 
3058
        [CCode (cheader_filename = "purple.h")]
 
3059
        public static int blist_get_group_size (Purple.Group group, bool offline);
 
3060
        [CCode (cheader_filename = "purple.h")]
 
3061
        public static void* blist_get_handle ();
 
3062
        [CCode (cheader_filename = "purple.h")]
 
3063
        public static unowned Purple.BlistNode blist_get_root ();
 
3064
        [CCode (cheader_filename = "purple.h")]
 
3065
        public static void* blist_get_ui_data ();
 
3066
        [CCode (cheader_filename = "purple.h")]
 
3067
        public static unowned Purple.BlistUiOps blist_get_ui_ops ();
 
3068
        [CCode (cheader_filename = "purple.h")]
 
3069
        public static void blist_init ();
 
3070
        [CCode (cheader_filename = "purple.h")]
 
3071
        public static void blist_load ();
 
3072
        [CCode (cheader_filename = "purple.h")]
 
3073
        public static void blist_merge_contact (Purple.Contact source, Purple.BlistNode node);
 
3074
        [CCode (cheader_filename = "purple.h")]
 
3075
        public static unowned Purple.BuddyList blist_new ();
 
3076
        [CCode (cheader_filename = "purple.h")]
 
3077
        public static void blist_remove_account (Purple.Account account);
 
3078
        [CCode (cheader_filename = "purple.h")]
 
3079
        public static void blist_remove_buddy (Purple.Buddy buddy);
 
3080
        [CCode (cheader_filename = "purple.h")]
 
3081
        public static void blist_remove_chat (Purple.Chat chat);
 
3082
        [CCode (cheader_filename = "purple.h")]
 
3083
        public static void blist_remove_contact (Purple.Contact contact);
 
3084
        [CCode (cheader_filename = "purple.h")]
 
3085
        public static void blist_remove_group (Purple.Group group);
 
3086
        [CCode (cheader_filename = "purple.h")]
 
3087
        public static void blist_rename_buddy (Purple.Buddy buddy, string name);
 
3088
        [CCode (cheader_filename = "purple.h")]
 
3089
        public static void blist_rename_group (Purple.Group group, string name);
 
3090
        [CCode (cheader_filename = "purple.h")]
 
3091
        public static void blist_request_add_buddy (Purple.Account account, string username, string group, string alias);
 
3092
        [CCode (cheader_filename = "purple.h")]
 
3093
        public static void blist_request_add_chat (Purple.Account account, Purple.Group group, string alias, string name);
 
3094
        [CCode (cheader_filename = "purple.h")]
 
3095
        public static void blist_request_add_group ();
 
3096
        [CCode (cheader_filename = "purple.h")]
 
3097
        public static void blist_schedule_save ();
 
3098
        [CCode (cheader_filename = "purple.h")]
 
3099
        public static void blist_server_alias_buddy (Purple.Buddy buddy, string alias);
 
3100
        [CCode (cheader_filename = "purple.h")]
 
3101
        public static void blist_set_ui_data (void* ui_data);
 
3102
        [CCode (cheader_filename = "purple.h")]
 
3103
        public static void blist_set_ui_ops (Purple.BlistUiOps ops);
 
3104
        [CCode (cheader_filename = "purple.h")]
 
3105
        public static void blist_set_visible (bool show);
 
3106
        [CCode (cheader_filename = "purple.h")]
 
3107
        public static void blist_show ();
 
3108
        [CCode (cheader_filename = "purple.h")]
 
3109
        public static void blist_uninit ();
 
3110
        [CCode (cheader_filename = "purple.h")]
 
3111
        public static void blist_update_buddy_icon (Purple.Buddy buddy);
 
3112
        [CCode (cheader_filename = "purple.h")]
 
3113
        public static void blist_update_buddy_status (Purple.Buddy buddy, Purple.Status old_status);
 
3114
        [CCode (cheader_filename = "purple.h")]
 
3115
        public static void blist_update_node_icon (Purple.BlistNode node);
 
3116
        [CCode (cheader_filename = "purple.h")]
 
3117
        public static int build_dir (string path, int mode);
 
3118
        [CCode (cheader_filename = "purple.h")]
 
3119
        public static unowned Purple.Cipher ciphers_find_cipher (string name);
 
3120
        [CCode (cheader_filename = "purple.h")]
 
3121
        public static unowned GLib.List ciphers_get_ciphers ();
 
3122
        [CCode (cheader_filename = "purple.h")]
 
3123
        public static void* ciphers_get_handle ();
 
3124
        [CCode (cheader_filename = "purple.h")]
 
3125
        public static void ciphers_init ();
 
3126
        [CCode (cheader_filename = "purple.h")]
 
3127
        public static unowned Purple.Cipher ciphers_register_cipher (string name, Purple.CipherOps ops);
 
3128
        [CCode (cheader_filename = "purple.h")]
 
3129
        public static void ciphers_uninit ();
 
3130
        [CCode (cheader_filename = "purple.h")]
 
3131
        public static bool ciphers_unregister_cipher (Purple.Cipher cipher);
 
3132
        [CCode (cheader_filename = "purple.h")]
 
3133
        public static Purple.CmdStatus cmd_do_command (Purple.Conversation conv, string cmdline, string markup, string errormsg);
 
3134
        [CCode (cheader_filename = "purple.h")]
 
3135
        public static unowned GLib.List cmd_help (Purple.Conversation conv, string cmd);
 
3136
        [CCode (cheader_filename = "purple.h")]
 
3137
        public static unowned GLib.List cmd_list (Purple.Conversation conv);
 
3138
        [CCode (cheader_filename = "purple.h")]
 
3139
        public static unowned Purple.CmdId cmd_register (string cmd, string args, Purple.CmdPriority p, Purple.CmdFlag f, string prpl_id, Purple.CmdFunc func, string helpstr, void* data);
 
3140
        [CCode (cheader_filename = "purple.h")]
 
3141
        public static void cmd_unregister (Purple.CmdId id);
 
3142
        [CCode (cheader_filename = "purple.h")]
 
3143
        public static void* cmds_get_handle ();
 
3144
        [CCode (cheader_filename = "purple.h")]
 
3145
        public static void cmds_init ();
 
3146
        [CCode (cheader_filename = "purple.h")]
 
3147
        public static void cmds_uninit ();
 
3148
        [CCode (cheader_filename = "purple.h")]
 
3149
        public static void connections_disconnect_all ();
 
3150
        [CCode (cheader_filename = "purple.h")]
 
3151
        public static unowned GLib.List connections_get_all ();
 
3152
        [CCode (cheader_filename = "purple.h")]
 
3153
        public static unowned GLib.List connections_get_connecting ();
 
3154
        [CCode (cheader_filename = "purple.h")]
 
3155
        public static void* connections_get_handle ();
 
3156
        [CCode (cheader_filename = "purple.h")]
 
3157
        public static unowned Purple.ConnectionUiOps connections_get_ui_ops ();
 
3158
        [CCode (cheader_filename = "purple.h")]
 
3159
        public static void connections_init ();
 
3160
        [CCode (cheader_filename = "purple.h")]
 
3161
        public static void connections_set_ui_ops (Purple.ConnectionUiOps ops);
 
3162
        [CCode (cheader_filename = "purple.h")]
 
3163
        public static void connections_uninit ();
 
3164
        [CCode (cheader_filename = "purple.h")]
 
3165
        public static bool conv_custom_smiley_add (Purple.Conversation conv, string smile, string cksum_type, string chksum, bool remote);
 
3166
        [CCode (cheader_filename = "purple.h")]
 
3167
        public static void conv_custom_smiley_close (Purple.Conversation conv, string smile);
 
3168
        [CCode (cheader_filename = "purple.h")]
 
3169
        public static void conv_custom_smiley_write (Purple.Conversation conv, string smile, uchar[] data, size_t size);
 
3170
        [CCode (cheader_filename = "purple.h")]
 
3171
        public static bool conv_present_error (string who, Purple.Account account, string what);
 
3172
        [CCode (cheader_filename = "purple.h")]
 
3173
        public static void conv_send_confirm (Purple.Conversation conv, string message);
 
3174
        [CCode (cheader_filename = "purple.h")]
 
3175
        public static void* conversations_get_handle ();
 
3176
        [CCode (cheader_filename = "purple.h")]
 
3177
        public static void conversations_init ();
 
3178
        [CCode (cheader_filename = "purple.h")]
 
3179
        public static void conversations_set_ui_ops (Purple.ConversationUiOps ops);
 
3180
        [CCode (cheader_filename = "purple.h")]
 
3181
        public static void conversations_uninit ();
 
3182
        [CCode (cheader_filename = "purple.h")]
 
3183
        public static unowned string date_format_full (void* tm);
 
3184
        [CCode (cheader_filename = "purple.h")]
 
3185
        public static unowned string date_format_long (void* tm);
 
3186
        [CCode (cheader_filename = "purple.h")]
 
3187
        public static unowned string date_format_short (void* tm);
 
3188
        [CCode (cheader_filename = "purple.h")]
 
3189
        public static void debug (Purple.DebugLevel level, string category, string format);
 
3190
        [CCode (cheader_filename = "purple.h")]
 
3191
        public static void debug_error (string category, string format);
 
3192
        [CCode (cheader_filename = "purple.h")]
 
3193
        public static void debug_fatal (string category, string format);
 
3194
        [CCode (cheader_filename = "purple.h")]
 
3195
        public static unowned Purple.DebugUiOps debug_get_ui_ops ();
 
3196
        [CCode (cheader_filename = "purple.h")]
 
3197
        public static void debug_info (string category, string format);
 
3198
        [CCode (cheader_filename = "purple.h")]
 
3199
        public static void debug_init ();
 
3200
        [CCode (cheader_filename = "purple.h")]
 
3201
        public static bool debug_is_enabled ();
 
3202
        [CCode (cheader_filename = "purple.h")]
 
3203
        public static bool debug_is_unsafe ();
 
3204
        [CCode (cheader_filename = "purple.h")]
 
3205
        public static bool debug_is_verbose ();
 
3206
        [CCode (cheader_filename = "purple.h")]
 
3207
        public static void debug_misc (string category, string format);
 
3208
        [CCode (cheader_filename = "purple.h")]
 
3209
        public static void debug_set_enabled (bool enabled);
 
3210
        [CCode (cheader_filename = "purple.h")]
 
3211
        public static void debug_set_ui_ops (Purple.DebugUiOps ops);
 
3212
        [CCode (cheader_filename = "purple.h")]
 
3213
        public static void debug_set_unsafe (bool unsafe);
 
3214
        [CCode (cheader_filename = "purple.h")]
 
3215
        public static void debug_set_verbose (bool verbose);
 
3216
        [CCode (cheader_filename = "purple.h")]
 
3217
        public static void debug_warning (string category, string format);
 
3218
        [CCode (cheader_filename = "purple.h")]
 
3219
        public static unowned Purple.DnsQueryData dnsquery_a (string hostname, int port, Purple.DnsQueryConnectFunction callback, void* data);
 
3220
        [CCode (cheader_filename = "purple.h")]
 
3221
        public static void dnsquery_destroy (Purple.DnsQueryData query_data);
 
3222
        [CCode (cheader_filename = "purple.h")]
 
3223
        public static unowned string dnsquery_get_host (Purple.DnsQueryData query_data);
 
3224
        [CCode (cheader_filename = "purple.h")]
 
3225
        public static uint dnsquery_get_port (Purple.DnsQueryData query_data);
 
3226
        [CCode (cheader_filename = "purple.h")]
 
3227
        public static unowned Purple.DnsQueryUiOps dnsquery_get_ui_ops ();
 
3228
        [CCode (cheader_filename = "purple.h")]
 
3229
        public static void dnsquery_init ();
 
3230
        [CCode (cheader_filename = "purple.h")]
 
3231
        public static void dnsquery_set_ui_ops (Purple.DnsQueryUiOps ops);
 
3232
        [CCode (cheader_filename = "purple.h")]
 
3233
        public static void dnsquery_uninit ();
 
3234
        [CCode (cheader_filename = "purple.h")]
 
3235
        public static bool email_is_valid (string address);
 
3236
        [CCode (cheader_filename = "purple.h")]
 
3237
        public static unowned string escape_filename (string str);
 
3238
        [CCode (cheader_filename = "purple.h")]
 
3239
        public static unowned Purple.EventLoopUiOps eventloop_get_ui_ops ();
 
3240
        [CCode (cheader_filename = "purple.h")]
 
3241
        public static void eventloop_set_ui_ops (Purple.EventLoopUiOps ops);
 
3242
        [CCode (cheader_filename = "purple.h")]
 
3243
        public static unowned string fd_get_ip (int fd);
 
3244
        [CCode (cheader_filename = "purple.h")]
 
3245
        public static unowned GLib.SList find_buddies (Purple.Account account, string name);
 
3246
        [CCode (cheader_filename = "purple.h")]
 
3247
        public static unowned Purple.Buddy find_buddy (Purple.Account account, string name);
 
3248
        [CCode (cheader_filename = "purple.h")]
 
3249
        public static unowned Purple.Buddy find_buddy_in_group (Purple.Account account, string name, Purple.Group group);
 
3250
        [CCode (cheader_filename = "purple.h")]
 
3251
        public static unowned Purple.Conversation find_chat (Purple.Connection gc, int id);
 
3252
        [CCode (cheader_filename = "purple.h")]
 
3253
        public static unowned Purple.Conversation find_conversation_with_account (Purple.ConversationType type, string name, Purple.Account account);
 
3254
        [CCode (cheader_filename = "purple.h")]
 
3255
        public static unowned Purple.Group find_group (string name);
 
3256
        [CCode (cheader_filename = "purple.h")]
 
3257
        public static unowned Purple.Pounce find_pounce (Purple.Account pouncer, string pouncee, Purple.PounceEvent events);
 
3258
        [CCode (cheader_filename = "purple.h")]
 
3259
        public static unowned Purple.Plugin find_prpl (string id);
 
3260
        [CCode (cheader_filename = "purple.h")]
 
3261
        public static unowned string gai_strerror (int errnum);
 
3262
        [CCode (cheader_filename = "purple.h")]
 
3263
        public static unowned Purple.AttentionType get_attention_type_from_code (Purple.Account account, uint type_code);
 
3264
        [CCode (cheader_filename = "purple.h")]
 
3265
        public static unowned Purple.BuddyList get_blist ();
 
3266
        [CCode (cheader_filename = "purple.h")]
 
3267
        public static unowned GLib.List get_chats ();
 
3268
        [CCode (cheader_filename = "purple.h")]
 
3269
        public static unowned GLib.List get_conversations ();
 
3270
        [CCode (cheader_filename = "purple.h")]
 
3271
        public static unowned Purple.Core get_core ();
 
3272
        [CCode (cheader_filename = "purple.h")]
 
3273
        public static unowned string get_host_name ();
 
3274
        [CCode (cheader_filename = "purple.h")]
 
3275
        public static unowned GLib.List get_ims ();
 
3276
        [CCode (cheader_filename = "purple.h")]
 
3277
        public static unowned string get_tzoff_str (void* tm, bool iso);
 
3278
        [CCode (cheader_filename = "purple.h")]
 
3279
        public static unowned Purple.ProxyInfo global_proxy_get_info ();
 
3280
        [CCode (cheader_filename = "purple.h")]
 
3281
        public static void global_proxy_set_info (Purple.ProxyInfo info);
 
3282
        [CCode (cheader_filename = "purple.h")]
 
3283
        public static void got_protocol_handler_uri (string uri);
 
3284
        [CCode (cheader_filename = "purple.h")]
 
3285
        public static unowned string home_dir ();
 
3286
        [CCode (cheader_filename = "purple.h")]
 
3287
        public static unowned Purple.IdleUiOps idle_get_ui_ops ();
 
3288
        [CCode (cheader_filename = "purple.h")]
 
3289
        public static void idle_init ();
 
3290
        [CCode (cheader_filename = "purple.h")]
 
3291
        public static void idle_set (ulong time);
 
3292
        [CCode (cheader_filename = "purple.h")]
 
3293
        public static void idle_set_ui_ops (Purple.IdleUiOps ops);
 
3294
        [CCode (cheader_filename = "purple.h")]
 
3295
        public static void idle_touch ();
 
3296
        [CCode (cheader_filename = "purple.h")]
 
3297
        public static void idle_uninit ();
 
3298
        [CCode (cheader_filename = "purple.h")]
 
3299
        public static unowned Purple.StoredImage imgstore_add (void* data, size_t size, string filename);
 
3300
        [CCode (cheader_filename = "purple.h")]
 
3301
        public static int imgstore_add_with_id (void* data, size_t size, string filename);
 
3302
        [CCode (cheader_filename = "purple.h")]
 
3303
        public static unowned Purple.StoredImage imgstore_find_by_id (int id);
 
3304
        [CCode (cheader_filename = "purple.h")]
 
3305
        public static void* imgstore_get_data (Purple.StoredImage img);
 
3306
        [CCode (cheader_filename = "purple.h")]
 
3307
        public static unowned string imgstore_get_extension (Purple.StoredImage img);
 
3308
        [CCode (cheader_filename = "purple.h")]
 
3309
        public static unowned string imgstore_get_filename (Purple.StoredImage img);
 
3310
        [CCode (cheader_filename = "purple.h")]
 
3311
        public static void* imgstore_get_handle ();
 
3312
        [CCode (cheader_filename = "purple.h")]
 
3313
        public static size_t imgstore_get_size (Purple.StoredImage img);
 
3314
        [CCode (cheader_filename = "purple.h")]
 
3315
        public static void imgstore_init ();
 
3316
        [CCode (cheader_filename = "purple.h")]
 
3317
        public static unowned Purple.StoredImage imgstore_new_from_file (string path);
 
3318
        [CCode (cheader_filename = "purple.h")]
 
3319
        public static unowned Purple.StoredImage imgstore_ref (Purple.StoredImage img);
 
3320
        [CCode (cheader_filename = "purple.h")]
 
3321
        public static void imgstore_ref_by_id (int id);
 
3322
        [CCode (cheader_filename = "purple.h")]
 
3323
        public static void imgstore_uninit ();
 
3324
        [CCode (cheader_filename = "purple.h")]
 
3325
        public static unowned Purple.StoredImage imgstore_unref (Purple.StoredImage img);
 
3326
        [CCode (cheader_filename = "purple.h")]
 
3327
        public static void imgstore_unref_by_id (int id);
 
3328
        [CCode (cheader_filename = "purple.h")]
 
3329
        public static uint input_add (int fd, Purple.InputCondition cond, Purple.InputFunction func);
 
3330
        [CCode (cheader_filename = "purple.h")]
 
3331
        public static int input_get_error (int fd, int error);
 
3332
        [CCode (cheader_filename = "purple.h")]
 
3333
        public static bool input_remove (uint handle);
 
3334
        [CCode (cheader_filename = "purple.h")]
 
3335
        public static bool ip_address_is_valid (string ip);
 
3336
        [CCode (cheader_filename = "purple.h")]
 
3337
        public static bool ipv4_address_is_valid (string ip);
 
3338
        [CCode (cheader_filename = "purple.h")]
 
3339
        public static bool ipv6_address_is_valid (string ip);
 
3340
        [CCode (cheader_filename = "purple.h")]
 
3341
        public static unowned string markup_escape_text (string text, ssize_t length);
 
3342
        [CCode (cheader_filename = "purple.h")]
 
3343
        public static bool markup_extract_info_field (string str, int len, Purple.NotifyUserInfo user_info, string start_token, int skip, string end_token, DBus.ObjectPath check_value, string no_value_token, string display_name, bool is_link, string link_prefix, Purple.InfoFieldFormatCallback format_cb);
 
3344
        [CCode (cheader_filename = "purple.h")]
 
3345
        public static bool markup_find_tag (string needle, string haystack, out string start, out string end, out GLib.Datalist attributes);
 
3346
        [CCode (cheader_filename = "purple.h")]
 
3347
        public static unowned string markup_get_css_property (string style, string opt);
 
3348
        [CCode (cheader_filename = "purple.h")]
 
3349
        public static unowned string markup_get_tag_name (string tag);
 
3350
        [CCode (cheader_filename = "purple.h")]
 
3351
        public static void markup_html_to_xhtml (string html, out unowned string dest_xhtml, out unowned string dest_plain);
 
3352
        [CCode (cheader_filename = "purple.h")]
 
3353
        public static bool markup_is_rtl (string html);
 
3354
        [CCode (cheader_filename = "purple.h")]
 
3355
        public static unowned string markup_linkify (string str);
 
3356
        [CCode (cheader_filename = "purple.h")]
 
3357
        public static unowned string markup_slice (string str, uint x, uint y);
 
3358
        [CCode (cheader_filename = "purple.h")]
 
3359
        public static unowned string markup_strip_html (string str);
 
3360
        [CCode (cheader_filename = "purple.h")]
 
3361
        public static unowned string markup_unescape_entity (string text, int length);
 
3362
        [CCode (cheader_filename = "purple.h")]
 
3363
        public static void marshal_BOOLEAN__INT_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3364
        [CCode (cheader_filename = "purple.h")]
 
3365
        public static void marshal_BOOLEAN__POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3366
        [CCode (cheader_filename = "purple.h")]
 
3367
        public static void marshal_BOOLEAN__POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3368
        [CCode (cheader_filename = "purple.h")]
 
3369
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3370
        [CCode (cheader_filename = "purple.h")]
 
3371
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3372
        [CCode (cheader_filename = "purple.h")]
 
3373
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3374
        [CCode (cheader_filename = "purple.h")]
 
3375
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3376
        [CCode (cheader_filename = "purple.h")]
 
3377
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3378
        [CCode (cheader_filename = "purple.h")]
 
3379
        public static void marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3380
        [CCode (cheader_filename = "purple.h")]
 
3381
        public static void marshal_BOOLEAN__POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3382
        [CCode (cheader_filename = "purple.h")]
 
3383
        public static void marshal_INT__INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3384
        [CCode (cheader_filename = "purple.h")]
 
3385
        public static void marshal_INT__INT_INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3386
        [CCode (cheader_filename = "purple.h")]
 
3387
        public static void marshal_INT__POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3388
        [CCode (cheader_filename = "purple.h")]
 
3389
        public static void marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3390
        [CCode (cheader_filename = "purple.h")]
 
3391
        public static void marshal_POINTER__POINTER_INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3392
        [CCode (cheader_filename = "purple.h")]
 
3393
        public static void marshal_POINTER__POINTER_INT64 (Purple.Callback cb, void* args, void* data, void* return_val);
 
3394
        [CCode (cheader_filename = "purple.h")]
 
3395
        public static void marshal_POINTER__POINTER_INT64_BOOLEAN (Purple.Callback cb, void* args, void* data, void* return_val);
 
3396
        [CCode (cheader_filename = "purple.h")]
 
3397
        public static void marshal_POINTER__POINTER_INT_BOOLEAN (Purple.Callback cb, void* args, void* data, void* return_val);
 
3398
        [CCode (cheader_filename = "purple.h")]
 
3399
        public static void marshal_POINTER__POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3400
        [CCode (cheader_filename = "purple.h")]
 
3401
        public static void marshal_VOID (Purple.Callback cb, void* args, void* data, void* return_val);
 
3402
        [CCode (cheader_filename = "purple.h")]
 
3403
        public static void marshal_VOID__INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3404
        [CCode (cheader_filename = "purple.h")]
 
3405
        public static void marshal_VOID__INT_INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3406
        [CCode (cheader_filename = "purple.h")]
 
3407
        public static void marshal_VOID__POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3408
        [CCode (cheader_filename = "purple.h")]
 
3409
        public static void marshal_VOID__POINTER_INT_INT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3410
        [CCode (cheader_filename = "purple.h")]
 
3411
        public static void marshal_VOID__POINTER_INT_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3412
        [CCode (cheader_filename = "purple.h")]
 
3413
        public static void marshal_VOID__POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3414
        [CCode (cheader_filename = "purple.h")]
 
3415
        public static void marshal_VOID__POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3416
        [CCode (cheader_filename = "purple.h")]
 
3417
        public static void marshal_VOID__POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3418
        [CCode (cheader_filename = "purple.h")]
 
3419
        public static void marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER (Purple.Callback cb, void* args, void* data, void* return_val);
 
3420
        [CCode (cheader_filename = "purple.h")]
 
3421
        public static void marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3422
        [CCode (cheader_filename = "purple.h")]
 
3423
        public static void marshal_VOID__POINTER_POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3424
        [CCode (cheader_filename = "purple.h")]
 
3425
        public static void marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3426
        [CCode (cheader_filename = "purple.h")]
 
3427
        public static void marshal_VOID__POINTER_POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3428
        [CCode (cheader_filename = "purple.h")]
 
3429
        public static void marshal_VOID__POINTER_POINTER_UINT_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3430
        [CCode (cheader_filename = "purple.h")]
 
3431
        public static void marshal_VOID__POINTER_UINT (Purple.Callback cb, void* args, void* data, void* return_val);
 
3432
        [CCode (cheader_filename = "purple.h")]
 
3433
        public static bool message_meify (string message, ssize_t len);
 
3434
        [CCode (cheader_filename = "purple.h")]
 
3435
        public static unowned string mime_decode_field (string str);
 
3436
        [CCode (cheader_filename = "purple.h")]
 
3437
        public static unowned GLib.FileStream mkstemp (out unowned string path, bool binary);
 
3438
        [CCode (cheader_filename = "purple.h")]
 
3439
        public static int network_convert_idn_to_ascii (string @in, string @out);
 
3440
        [CCode (cheader_filename = "purple.h")]
 
3441
        public static void network_force_online ();
 
3442
        [CCode (cheader_filename = "purple.h")]
 
3443
        public static void* network_get_handle ();
 
3444
        [CCode (cheader_filename = "purple.h")]
 
3445
        public static unowned string network_get_local_system_ip (int fd);
 
3446
        [CCode (cheader_filename = "purple.h")]
 
3447
        public static unowned string network_get_my_ip (int fd);
 
3448
        [CCode (cheader_filename = "purple.h")]
 
3449
        public static uint network_get_port_from_fd (int fd);
 
3450
        [CCode (cheader_filename = "purple.h")]
 
3451
        public static unowned string network_get_public_ip ();
 
3452
        [CCode (cheader_filename = "purple.h")]
 
3453
        public static unowned string network_get_stun_ip ();
 
3454
        [CCode (cheader_filename = "purple.h")]
 
3455
        public static unowned string network_get_turn_ip ();
 
3456
        [CCode (cheader_filename = "purple.h")]
 
3457
        public static void network_init ();
 
3458
        [CCode (cheader_filename = "purple.h")]
 
3459
        public static uint network_ip_atoi (string ip);
 
3460
        [CCode (cheader_filename = "purple.h")]
 
3461
        public static bool network_is_available ();
 
3462
        [CCode (cheader_filename = "purple.h")]
 
3463
        public static unowned Purple.NetworkListenData network_listen (uint port, int socket_type, Purple.NetworkListenCallback cb, void* cb_data);
 
3464
        [CCode (cheader_filename = "purple.h")]
 
3465
        public static void network_listen_cancel (Purple.NetworkListenData listen_data);
 
3466
        [CCode (cheader_filename = "purple.h")]
 
3467
        public static void network_listen_map_external (bool map_external);
 
3468
        [CCode (cheader_filename = "purple.h")]
 
3469
        public static unowned Purple.NetworkListenData network_listen_range (uint start, uint end, int socket_type, Purple.NetworkListenCallback cb, void* cb_data);
 
3470
        [CCode (cheader_filename = "purple.h")]
 
3471
        public static void network_remove_port_mapping (int fd);
 
3472
        [CCode (cheader_filename = "purple.h")]
 
3473
        public static void network_set_public_ip (string ip);
 
3474
        [CCode (cheader_filename = "purple.h")]
 
3475
        public static void network_set_stun_server (string stun_server);
 
3476
        [CCode (cheader_filename = "purple.h")]
 
3477
        public static void network_set_turn_server (string turn_server);
 
3478
        [CCode (cheader_filename = "purple.h")]
 
3479
        public static void network_uninit ();
 
3480
        [CCode (cheader_filename = "purple.h")]
 
3481
        public static unowned string normalize (Purple.Account account, string str);
 
3482
        [CCode (cheader_filename = "purple.h")]
 
3483
        public static unowned string normalize_nocase (Purple.Account account, string str);
 
3484
        [CCode (cheader_filename = "purple.h")]
 
3485
        public static void notify_close (Purple.NotifyType type, void* ui_handle);
 
3486
        [CCode (cheader_filename = "purple.h")]
 
3487
        public static void notify_close_with_handle (void* handle);
 
3488
        [CCode (cheader_filename = "purple.h")]
 
3489
        public static void* notify_email (void* handle, string subject, string from, string to, string url, Purple.NotifyCloseCallback cb);
 
3490
        [CCode (cheader_filename = "purple.h")]
 
3491
        public static void* notify_emails (void* handle, size_t count, bool detailed, out unowned string subjects, out unowned string froms, out unowned string tos, out unowned string urls, Purple.NotifyCloseCallback cb);
 
3492
        [CCode (cheader_filename = "purple.h")]
 
3493
        public static void* notify_formatted (void* handle, string title, string primary, string secondary, string text, Purple.NotifyCloseCallback cb);
 
3494
        [CCode (cheader_filename = "purple.h")]
 
3495
        public static void* notify_get_handle ();
 
3496
        [CCode (cheader_filename = "purple.h")]
 
3497
        public static unowned Purple.NotifyUiOps notify_get_ui_ops ();
 
3498
        [CCode (cheader_filename = "purple.h")]
 
3499
        public static void notify_init ();
 
3500
        [CCode (cheader_filename = "purple.h")]
 
3501
        public static void* notify_message (void* handle, Purple.NotifyMsgType type, string title, string primary, string secondary, Purple.NotifyCloseCallback cb);
 
3502
        [CCode (cheader_filename = "purple.h")]
 
3503
        public static void* notify_searchresults (Purple.Connection gc, string title, string primary, string secondary, Purple.NotifySearchResults results, Purple.NotifyCloseCallback cb);
 
3504
        [CCode (cheader_filename = "purple.h")]
 
3505
        public static void notify_set_ui_ops (Purple.NotifyUiOps ops);
 
3506
        [CCode (cheader_filename = "purple.h")]
 
3507
        public static void notify_uninit ();
 
3508
        [CCode (cheader_filename = "purple.h")]
 
3509
        public static void* notify_uri (void* handle, string uri);
 
3510
        [CCode (cheader_filename = "purple.h")]
 
3511
        public static void* notify_userinfo (Purple.Connection gc, string who, Purple.NotifyUserInfo user_info, Purple.NotifyCloseCallback cb);
 
3512
        [CCode (cheader_filename = "purple.h")]
 
3513
        public static unowned string ntlm_gen_type1 (string hostname, string domain);
 
3514
        [CCode (cheader_filename = "purple.h")]
 
3515
        public static unowned string ntlm_gen_type3 (string username, string passw, string hostname, string domain, uchar nonce, uint32 flags);
 
3516
        [CCode (cheader_filename = "purple.h")]
 
3517
        public static uchar ntlm_parse_type2 (string type2, uint32 flags);
 
3518
        [CCode (cheader_filename = "purple.h")]
 
3519
        public static void plugins_add_search_path (string path);
 
3520
        [CCode (cheader_filename = "purple.h")]
 
3521
        public static void plugins_destroy_all ();
 
3522
        [CCode (cheader_filename = "purple.h")]
 
3523
        public static bool plugins_enabled ();
 
3524
        [CCode (cheader_filename = "purple.h")]
 
3525
        public static unowned Purple.Plugin plugins_find_with_basename (string basename);
 
3526
        [CCode (cheader_filename = "purple.h")]
 
3527
        public static unowned Purple.Plugin plugins_find_with_filename (string filename);
 
3528
        [CCode (cheader_filename = "purple.h")]
 
3529
        public static unowned Purple.Plugin plugins_find_with_id (string id);
 
3530
        [CCode (cheader_filename = "purple.h")]
 
3531
        public static unowned Purple.Plugin plugins_find_with_name (string name);
 
3532
        [CCode (cheader_filename = "purple.h")]
 
3533
        public static unowned GLib.List plugins_get_all ();
 
3534
        [CCode (cheader_filename = "purple.h")]
 
3535
        public static void* plugins_get_handle ();
 
3536
        [CCode (cheader_filename = "purple.h")]
 
3537
        public static unowned GLib.List plugins_get_loaded ();
 
3538
        [CCode (cheader_filename = "purple.h")]
 
3539
        public static unowned GLib.List plugins_get_protocols ();
 
3540
        [CCode (cheader_filename = "purple.h")]
 
3541
        public static unowned GLib.List plugins_get_search_paths ();
 
3542
        [CCode (cheader_filename = "purple.h")]
 
3543
        public static void plugins_init ();
 
3544
        [CCode (cheader_filename = "purple.h")]
 
3545
        public static void plugins_load_saved (string key);
 
3546
        [CCode (cheader_filename = "purple.h")]
 
3547
        public static void plugins_probe (string ext);
 
3548
        [CCode (cheader_filename = "purple.h")]
 
3549
        public static void plugins_register_load_notify_cb (GLib.Callback func, void* data);
 
3550
        [CCode (cheader_filename = "purple.h")]
 
3551
        public static void plugins_register_probe_notify_cb (GLib.Callback func, void* data);
 
3552
        [CCode (cheader_filename = "purple.h")]
 
3553
        public static void plugins_register_unload_notify_cb (GLib.Callback func, void* data);
 
3554
        [CCode (cheader_filename = "purple.h")]
 
3555
        public static void plugins_save_loaded (string key);
 
3556
        [CCode (cheader_filename = "purple.h")]
 
3557
        public static void plugins_uninit ();
 
3558
        [CCode (cheader_filename = "purple.h")]
 
3559
        public static void plugins_unload (Purple.PluginType type);
 
3560
        [CCode (cheader_filename = "purple.h")]
 
3561
        public static void plugins_unload_all ();
 
3562
        [CCode (cheader_filename = "purple.h")]
 
3563
        public static void plugins_unregister_load_notify_cb (GLib.Callback func);
 
3564
        [CCode (cheader_filename = "purple.h")]
 
3565
        public static void plugins_unregister_probe_notify_cb (GLib.Callback func);
 
3566
        [CCode (cheader_filename = "purple.h")]
 
3567
        public static void plugins_unregister_unload_notify_cb (GLib.Callback func);
 
3568
        [CCode (cheader_filename = "purple.h")]
 
3569
        public static bool pmp_create_map (Purple.PmpType type, uint privateport, uint publicport, int lifetime);
 
3570
        [CCode (cheader_filename = "purple.h")]
 
3571
        public static bool pmp_destroy_map (Purple.PmpType type, uint privateport);
 
3572
        [CCode (cheader_filename = "purple.h")]
 
3573
        public static unowned string pmp_get_public_ip ();
 
3574
        [CCode (cheader_filename = "purple.h")]
 
3575
        public static void pmp_init ();
 
3576
        [CCode (cheader_filename = "purple.h")]
 
3577
        public static unowned GLib.List pounces_get_all ();
 
3578
        [CCode (cheader_filename = "purple.h")]
 
3579
        public static unowned GLib.List pounces_get_all_for_ui (string ui);
 
3580
        [CCode (cheader_filename = "purple.h")]
 
3581
        public static void* pounces_get_handle ();
 
3582
        [CCode (cheader_filename = "purple.h")]
 
3583
        public static void pounces_init ();
 
3584
        [CCode (cheader_filename = "purple.h")]
 
3585
        public static bool pounces_load ();
 
3586
        [CCode (cheader_filename = "purple.h")]
 
3587
        public static void pounces_register_handler (string ui, Purple.PounceCb cb, GLib.Callback new_pounce, GLib.Callback free_pounce);
 
3588
        [CCode (cheader_filename = "purple.h")]
 
3589
        public static void pounces_uninit ();
 
3590
        [CCode (cheader_filename = "purple.h")]
 
3591
        public static void pounces_unregister_handler (string ui);
 
3592
        [CCode (cheader_filename = "purple.h")]
 
3593
        public static void prefs_add_bool (string name, bool value);
 
3594
        [CCode (cheader_filename = "purple.h")]
 
3595
        public static void prefs_add_int (string name, int value);
 
3596
        [CCode (cheader_filename = "purple.h")]
 
3597
        public static void prefs_add_none (string name);
 
3598
        [CCode (cheader_filename = "purple.h")]
 
3599
        public static void prefs_add_path (string name, string value);
 
3600
        [CCode (cheader_filename = "purple.h")]
 
3601
        public static void prefs_add_path_list (string name, GLib.List value);
 
3602
        [CCode (cheader_filename = "purple.h")]
 
3603
        public static void prefs_add_string (string name, string value);
 
3604
        [CCode (cheader_filename = "purple.h")]
 
3605
        public static void prefs_add_string_list (string name, GLib.List value);
 
3606
        [CCode (cheader_filename = "purple.h")]
 
3607
        public static uint prefs_connect_callback (void* handle, string name, Purple.PrefCallback cb, void* data);
 
3608
        [CCode (cheader_filename = "purple.h")]
 
3609
        public static void prefs_destroy ();
 
3610
        [CCode (cheader_filename = "purple.h")]
 
3611
        public static void prefs_disconnect_by_handle (void* handle);
 
3612
        [CCode (cheader_filename = "purple.h")]
 
3613
        public static void prefs_disconnect_callback (uint callback_id);
 
3614
        [CCode (cheader_filename = "purple.h")]
 
3615
        public static bool prefs_exists (string name);
 
3616
        [CCode (cheader_filename = "purple.h")]
 
3617
        public static bool prefs_get_bool (string name);
 
3618
        [CCode (cheader_filename = "purple.h")]
 
3619
        public static unowned GLib.List prefs_get_children_names (string name);
 
3620
        [CCode (cheader_filename = "purple.h")]
 
3621
        public static void* prefs_get_handle ();
 
3622
        [CCode (cheader_filename = "purple.h")]
 
3623
        public static int prefs_get_int (string name);
 
3624
        [CCode (cheader_filename = "purple.h")]
 
3625
        public static unowned string prefs_get_path (string name);
 
3626
        [CCode (cheader_filename = "purple.h")]
 
3627
        public static unowned GLib.List prefs_get_path_list (string name);
 
3628
        [CCode (cheader_filename = "purple.h")]
 
3629
        public static unowned string prefs_get_string (string name);
 
3630
        [CCode (cheader_filename = "purple.h")]
 
3631
        public static unowned GLib.List prefs_get_string_list (string name);
 
3632
        [CCode (cheader_filename = "purple.h")]
 
3633
        public static Purple.PrefType prefs_get_type (string name);
 
3634
        [CCode (cheader_filename = "purple.h")]
 
3635
        public static void prefs_init ();
 
3636
        [CCode (cheader_filename = "purple.h")]
 
3637
        public static bool prefs_load ();
 
3638
        [CCode (cheader_filename = "purple.h")]
 
3639
        public static void prefs_remove (string name);
 
3640
        [CCode (cheader_filename = "purple.h")]
 
3641
        public static void prefs_rename (string oldname, string newname);
 
3642
        [CCode (cheader_filename = "purple.h")]
 
3643
        public static void prefs_rename_boolean_toggle (string oldname, string newname);
 
3644
        [CCode (cheader_filename = "purple.h")]
 
3645
        public static void prefs_set_bool (string name, bool value);
 
3646
        [CCode (cheader_filename = "purple.h")]
 
3647
        public static void prefs_set_generic (string name, void* value);
 
3648
        [CCode (cheader_filename = "purple.h")]
 
3649
        public static void prefs_set_int (string name, int value);
 
3650
        [CCode (cheader_filename = "purple.h")]
 
3651
        public static void prefs_set_path (string name, string value);
 
3652
        [CCode (cheader_filename = "purple.h")]
 
3653
        public static void prefs_set_path_list (string name, GLib.List value);
 
3654
        [CCode (cheader_filename = "purple.h")]
 
3655
        public static void prefs_set_string (string name, string value);
 
3656
        [CCode (cheader_filename = "purple.h")]
 
3657
        public static void prefs_set_string_list (string name, GLib.List value);
 
3658
        [CCode (cheader_filename = "purple.h")]
 
3659
        public static void prefs_trigger_callback (string name);
 
3660
        [CCode (cheader_filename = "purple.h")]
 
3661
        public static void prefs_uninit ();
 
3662
        [CCode (cheader_filename = "purple.h")]
 
3663
        public static void prefs_update_old ();
 
3664
        [CCode (cheader_filename = "purple.h")]
 
3665
        public static unowned string primitive_get_id_from_type (Purple.StatusPrimitive type);
 
3666
        [CCode (cheader_filename = "purple.h")]
 
3667
        public static unowned string primitive_get_name_from_type (Purple.StatusPrimitive type);
 
3668
        [CCode (cheader_filename = "purple.h")]
 
3669
        public static Purple.StatusPrimitive primitive_get_type_from_id (string id);
 
3670
        [CCode (cheader_filename = "purple.h")]
 
3671
        public static void print_utf8_to_console (GLib.FileStream filestream, string message);
 
3672
        [CCode (cheader_filename = "purple.h")]
 
3673
        public static void privacy_allow (Purple.Account account, string who, bool local, bool restore);
 
3674
        [CCode (cheader_filename = "purple.h")]
 
3675
        public static bool privacy_check (Purple.Account account, string who);
 
3676
        [CCode (cheader_filename = "purple.h")]
 
3677
        public static void privacy_deny (Purple.Account account, string who, bool local, bool restore);
 
3678
        [CCode (cheader_filename = "purple.h")]
 
3679
        public static bool privacy_deny_add (Purple.Account account, string name, bool local_only);
 
3680
        [CCode (cheader_filename = "purple.h")]
 
3681
        public static bool privacy_deny_remove (Purple.Account account, string name, bool local_only);
 
3682
        [CCode (cheader_filename = "purple.h")]
 
3683
        public static unowned Purple.PrivacyUiOps privacy_get_ui_ops ();
 
3684
        [CCode (cheader_filename = "purple.h")]
 
3685
        public static void privacy_init ();
 
3686
        [CCode (cheader_filename = "purple.h")]
 
3687
        public static bool privacy_permit_add (Purple.Account account, string name, bool local_only);
 
3688
        [CCode (cheader_filename = "purple.h")]
 
3689
        public static bool privacy_permit_remove (Purple.Account account, string name, bool local_only);
 
3690
        [CCode (cheader_filename = "purple.h")]
 
3691
        public static void privacy_set_ui_ops (Purple.PrivacyUiOps ops);
 
3692
        [CCode (cheader_filename = "purple.h")]
 
3693
        public static bool program_is_valid (string program);
 
3694
        [CCode (cheader_filename = "purple.h")]
 
3695
        public static unowned Purple.ProxyConnectData proxy_connect (void* handle, Purple.Account account, string host, int port, Purple.ProxyConnectFunction connect_cb, void* data);
 
3696
        [CCode (cheader_filename = "purple.h")]
 
3697
        public static void proxy_connect_cancel (Purple.ProxyConnectData connect_data);
 
3698
        [CCode (cheader_filename = "purple.h")]
 
3699
        public static void proxy_connect_cancel_with_handle (void* handle);
 
3700
        [CCode (cheader_filename = "purple.h")]
 
3701
        public static unowned Purple.ProxyConnectData proxy_connect_socks5 (void* handle, Purple.ProxyInfo gpi, string host, int port, Purple.ProxyConnectFunction connect_cb, void* data);
 
3702
        [CCode (cheader_filename = "purple.h")]
 
3703
        public static unowned Purple.ProxyConnectData proxy_connect_udp (void* handle, Purple.Account account, string host, int port, Purple.ProxyConnectFunction connect_cb, void* data);
 
3704
        [CCode (cheader_filename = "purple.h")]
 
3705
        public static void* proxy_get_handle ();
 
3706
        [CCode (cheader_filename = "purple.h")]
 
3707
        public static unowned Purple.ProxyInfo proxy_get_setup (Purple.Account account);
 
3708
        [CCode (cheader_filename = "purple.h")]
 
3709
        public static void proxy_init ();
 
3710
        [CCode (cheader_filename = "purple.h")]
 
3711
        public static void proxy_uninit ();
 
3712
        [CCode (cheader_filename = "purple.h")]
 
3713
        public static void prpl_change_account_status (Purple.Account account, Purple.Status old_status, Purple.Status new_status);
 
3714
        [CCode (cheader_filename = "purple.h")]
 
3715
        public static Purple.MediaCaps prpl_get_media_caps (Purple.Account account, string who);
 
3716
        [CCode (cheader_filename = "purple.h")]
 
3717
        public static unowned GLib.List prpl_get_statuses (Purple.Account account, Purple.Presence presence);
 
3718
        [CCode (cheader_filename = "purple.h")]
 
3719
        public static void prpl_got_account_actions (Purple.Account account);
 
3720
        [CCode (cheader_filename = "purple.h")]
 
3721
        public static void prpl_got_account_idle (Purple.Account account, bool idle, ulong idle_time);
 
3722
        [CCode (cheader_filename = "purple.h")]
 
3723
        public static void prpl_got_account_login_time (Purple.Account account, ulong login_time);
 
3724
        [CCode (cheader_filename = "purple.h")]
 
3725
        public static void prpl_got_account_status (Purple.Account account, string status_id);
 
3726
        [CCode (cheader_filename = "purple.h")]
 
3727
        public static void prpl_got_attention (Purple.Connection gc, string who, uint type_code);
 
3728
        [CCode (cheader_filename = "purple.h")]
 
3729
        public static void prpl_got_attention_in_chat (Purple.Connection gc, int id, string who, uint type_code);
 
3730
        [CCode (cheader_filename = "purple.h")]
 
3731
        public static void prpl_got_user_idle (Purple.Account account, string name, bool idle, ulong idle_time);
 
3732
        [CCode (cheader_filename = "purple.h")]
 
3733
        public static void prpl_got_user_login_time (Purple.Account account, string name, ulong login_time);
 
3734
        [CCode (cheader_filename = "purple.h")]
 
3735
        public static void prpl_got_user_status (Purple.Account account, string name, string status_id);
 
3736
        [CCode (cheader_filename = "purple.h")]
 
3737
        public static void prpl_got_user_status_deactive (Purple.Account account, string name, string status_id);
 
3738
        [CCode (cheader_filename = "purple.h")]
 
3739
        public static bool prpl_initiate_media (Purple.Account account, string who, Purple.MediaSessionType type);
 
3740
        [CCode (cheader_filename = "purple.h")]
 
3741
        public static void prpl_send_attention (Purple.Connection gc, string who, uint type_code);
 
3742
        [CCode (cheader_filename = "purple.h")]
 
3743
        public static unowned uchar[] quotedp_decode (string str, size_t ret_len);
 
3744
        [CCode (cheader_filename = "purple.h")]
 
3745
        public static void* request_action (void* handle, string title, string primary, string secondary, int default_action, Purple.Account account, string who, Purple.Conversation conv, size_t action_count);
 
3746
        [CCode (cheader_filename = "purple.h")]
 
3747
        public static void* request_action_varg (void* handle, string title, string primary, string secondary, int default_action, Purple.Account account, string who, Purple.Conversation conv, size_t action_count, void* actions);
 
3748
        [CCode (cheader_filename = "purple.h")]
 
3749
        public static void* request_choice (void* handle, string title, string primary, string secondary, int default_value, string ok_text, GLib.Callback ok_cb, string cancel_text, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv);
 
3750
        [CCode (cheader_filename = "purple.h")]
 
3751
        public static void* request_choice_varg (void* handle, string title, string primary, string secondary, int default_value, string ok_text, GLib.Callback ok_cb, string cancel_text, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv, void* choices);
 
3752
        [CCode (cheader_filename = "purple.h")]
 
3753
        public static void request_close (Purple.RequestType type, void* uihandle);
 
3754
        [CCode (cheader_filename = "purple.h")]
 
3755
        public static void request_close_with_handle (void* handle);
 
3756
        [CCode (cheader_filename = "purple.h")]
 
3757
        public static void* request_fields (void* handle, string title, string primary, string secondary, Purple.RequestFields fields, string ok_text, GLib.Callback ok_cb, string cancel_text, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv);
 
3758
        [CCode (cheader_filename = "purple.h")]
 
3759
        public static void* request_file (void* handle, string title, string filename, bool savedialog, GLib.Callback ok_cb, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv);
 
3760
        [CCode (cheader_filename = "purple.h")]
 
3761
        public static void* request_folder (void* handle, string title, string dirname, GLib.Callback ok_cb, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv);
 
3762
        [CCode (cheader_filename = "purple.h")]
 
3763
        public static unowned Purple.RequestUiOps request_get_ui_ops ();
 
3764
        [CCode (cheader_filename = "purple.h")]
 
3765
        public static void* request_input (void* handle, string title, string primary, string secondary, string default_value, bool multiline, bool masked, string hint, string ok_text, GLib.Callback ok_cb, string cancel_text, GLib.Callback cancel_cb, Purple.Account account, string who, Purple.Conversation conv);
 
3766
        [CCode (cheader_filename = "purple.h")]
 
3767
        public static void request_set_ui_ops (Purple.RequestUiOps ops);
 
3768
        [CCode (cheader_filename = "purple.h")]
 
3769
        public static void restore_default_signal_handlers ();
 
3770
        [CCode (cheader_filename = "purple.h")]
 
3771
        public static bool running_gnome ();
 
3772
        [CCode (cheader_filename = "purple.h")]
 
3773
        public static bool running_kde ();
 
3774
        [CCode (cheader_filename = "purple.h")]
 
3775
        public static bool running_osx ();
 
3776
        [CCode (cheader_filename = "purple.h")]
 
3777
        public static unowned GLib.List savedstatuses_get_all ();
 
3778
        [CCode (cheader_filename = "purple.h")]
 
3779
        public static void* savedstatuses_get_handle ();
 
3780
        [CCode (cheader_filename = "purple.h")]
 
3781
        public static unowned GLib.List savedstatuses_get_popular (uint how_many);
 
3782
        [CCode (cheader_filename = "purple.h")]
 
3783
        public static void savedstatuses_init ();
 
3784
        [CCode (cheader_filename = "purple.h")]
 
3785
        public static void savedstatuses_uninit ();
 
3786
        [CCode (cname = "serv_add_deny", cheader_filename = "purple.h")]
 
3787
        public static void serv_add_deny (Purple.Connection p1, string p2);
 
3788
        [CCode (cname = "serv_add_permit", cheader_filename = "purple.h")]
 
3789
        public static void serv_add_permit (Purple.Connection p1, string p2);
 
3790
        [CCode (cname = "serv_alias_buddy", cheader_filename = "purple.h")]
 
3791
        public static void serv_alias_buddy (Purple.Buddy p1);
 
3792
        [CCode (cname = "serv_chat_invite", cheader_filename = "purple.h")]
 
3793
        public static void serv_chat_invite (Purple.Connection p1, int p2, string p3, string p4);
 
3794
        [CCode (cname = "serv_chat_leave", cheader_filename = "purple.h")]
 
3795
        public static void serv_chat_leave (Purple.Connection p1, int p2);
 
3796
        [CCode (cname = "serv_chat_send", cheader_filename = "purple.h")]
 
3797
        public static int serv_chat_send (Purple.Connection p1, int p2, string p3, Purple.MessageFlags flags);
 
3798
        [CCode (cname = "serv_chat_whisper", cheader_filename = "purple.h")]
 
3799
        public static void serv_chat_whisper (Purple.Connection p1, int p2, string p3, string p4);
 
3800
        [CCode (cname = "serv_get_info", cheader_filename = "purple.h")]
 
3801
        public static void serv_get_info (Purple.Connection p1, string p2);
 
3802
        [CCode (cname = "serv_got_alias", cheader_filename = "purple.h")]
 
3803
        public static void serv_got_alias (Purple.Connection gc, string who, string alias);
 
3804
        [CCode (cname = "serv_got_attention", cheader_filename = "purple.h")]
 
3805
        public static void serv_got_attention (Purple.Connection gc, string who, uint type_code);
 
3806
        [CCode (cname = "serv_got_chat_in", cheader_filename = "purple.h")]
 
3807
        public static void serv_got_chat_in (Purple.Connection g, int id, string who, Purple.MessageFlags flags, string message, ulong mtime);
 
3808
        [CCode (cname = "serv_got_chat_invite", cheader_filename = "purple.h")]
 
3809
        public static void serv_got_chat_invite (Purple.Connection gc, string name, string who, string message, GLib.HashTable data);
 
3810
        [CCode (cname = "serv_got_chat_left", cheader_filename = "purple.h")]
 
3811
        public static void serv_got_chat_left (Purple.Connection g, int id);
 
3812
        [CCode (cname = "serv_got_im", cheader_filename = "purple.h")]
 
3813
        public static void serv_got_im (Purple.Connection gc, string who, string msg, Purple.MessageFlags flags, ulong mtime);
 
3814
        [CCode (cheader_filename = "purple.h")]
 
3815
        public static void serv_got_join_chat_failed (Purple.Connection gc, GLib.HashTable data);
 
3816
        [CCode (cname = "serv_got_joined_chat", cheader_filename = "purple.h")]
 
3817
        public static unowned Purple.Conversation serv_got_joined_chat (Purple.Connection gc, int id, string name);
 
3818
        [CCode (cheader_filename = "purple.h")]
 
3819
        public static void serv_got_private_alias (Purple.Connection gc, string who, string alias);
 
3820
        [CCode (cname = "serv_got_typing", cheader_filename = "purple.h")]
 
3821
        public static void serv_got_typing (Purple.Connection gc, string name, int timeout, Purple.TypingState state);
 
3822
        [CCode (cname = "serv_got_typing_stopped", cheader_filename = "purple.h")]
 
3823
        public static void serv_got_typing_stopped (Purple.Connection gc, string name);
 
3824
        [CCode (cname = "serv_join_chat", cheader_filename = "purple.h")]
 
3825
        public static void serv_join_chat (Purple.Connection p1, GLib.HashTable data);
 
3826
        [CCode (cname = "serv_move_buddy", cheader_filename = "purple.h")]
 
3827
        public static void serv_move_buddy (Purple.Buddy p1, Purple.Group p2, Purple.Group p3);
 
3828
        [CCode (cname = "serv_reject_chat", cheader_filename = "purple.h")]
 
3829
        public static void serv_reject_chat (Purple.Connection p1, GLib.HashTable data);
 
3830
        [CCode (cname = "serv_rem_deny", cheader_filename = "purple.h")]
 
3831
        public static void serv_rem_deny (Purple.Connection p1, string p2);
 
3832
        [CCode (cname = "serv_rem_permit", cheader_filename = "purple.h")]
 
3833
        public static void serv_rem_permit (Purple.Connection p1, string p2);
 
3834
        [CCode (cname = "serv_send_attention", cheader_filename = "purple.h")]
 
3835
        public static void serv_send_attention (Purple.Connection gc, string who, uint type_code);
 
3836
        [CCode (cname = "serv_send_file", cheader_filename = "purple.h")]
 
3837
        public static void serv_send_file (Purple.Connection gc, string who, string file);
 
3838
        [CCode (cname = "serv_send_im", cheader_filename = "purple.h")]
 
3839
        public static int serv_send_im (Purple.Connection p1, string p2, string p3, Purple.MessageFlags flags);
 
3840
        [CCode (cname = "serv_send_typing", cheader_filename = "purple.h")]
 
3841
        public static uint serv_send_typing (Purple.Connection gc, string name, Purple.TypingState state);
 
3842
        [CCode (cname = "serv_set_info", cheader_filename = "purple.h")]
 
3843
        public static void serv_set_info (Purple.Connection p1, string p2);
 
3844
        [CCode (cname = "serv_set_permit_deny", cheader_filename = "purple.h")]
 
3845
        public static void serv_set_permit_deny (Purple.Connection p1);
 
3846
        [CCode (cheader_filename = "purple.h")]
 
3847
        public static void set_blist (Purple.BuddyList blist);
 
3848
        [CCode (cheader_filename = "purple.h")]
 
3849
        public static ulong signal_connect (void* instance, string @signal, void* handle, Purple.Callback func, void* data);
 
3850
        [CCode (cheader_filename = "purple.h")]
 
3851
        public static ulong signal_connect_priority (void* instance, string @signal, void* handle, Purple.Callback func, void* data, int priority);
 
3852
        [CCode (cheader_filename = "purple.h")]
 
3853
        public static ulong signal_connect_priority_vargs (void* instance, string @signal, void* handle, Purple.Callback func, void* data, int priority);
 
3854
        [CCode (cheader_filename = "purple.h")]
 
3855
        public static ulong signal_connect_vargs (void* instance, string @signal, void* handle, Purple.Callback func, void* data);
 
3856
        [CCode (cheader_filename = "purple.h")]
 
3857
        public static void signal_disconnect (void* instance, string @signal, void* handle, Purple.Callback func);
 
3858
        [CCode (cheader_filename = "purple.h")]
 
3859
        public static void signal_emit (void* instance, string @signal);
 
3860
        [CCode (cheader_filename = "purple.h")]
 
3861
        public static void* signal_emit_return_1 (void* instance, string @signal);
 
3862
        [CCode (cheader_filename = "purple.h")]
 
3863
        public static void signal_emit_vargs (void* instance, string @signal, void* args);
 
3864
        [CCode (cheader_filename = "purple.h")]
 
3865
        public static void* signal_emit_vargs_return_1 (void* instance, string @signal, void* args);
 
3866
        [CCode (cheader_filename = "purple.h")]
 
3867
        public static void signal_get_values (void* instance, string @signal, out unowned Purple.Value ret_value, int num_values, out unowned Purple.Value values);
 
3868
        [CCode (cheader_filename = "purple.h")]
 
3869
        public static ulong signal_register (void* instance, string @signal, Purple.SignalMarshalFunc marshal, Purple.Value ret_value, int num_values);
 
3870
        [CCode (cheader_filename = "purple.h")]
 
3871
        public static void signal_unregister (void* instance, string @signal);
 
3872
        [CCode (cheader_filename = "purple.h")]
 
3873
        public static void signals_disconnect_by_handle (void* handle);
 
3874
        [CCode (cheader_filename = "purple.h")]
 
3875
        public static void signals_init ();
 
3876
        [CCode (cheader_filename = "purple.h")]
 
3877
        public static void signals_uninit ();
 
3878
        [CCode (cheader_filename = "purple.h")]
 
3879
        public static void signals_unregister_by_instance (void* instance);
 
3880
        [CCode (cheader_filename = "purple.h")]
 
3881
        public static void smarshal_BOOLEAN__OBJECT_POINTER_STRING (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3882
        [CCode (cheader_filename = "purple.h")]
 
3883
        public static void smarshal_VOID__ENUM_STRING_STRING (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3884
        [CCode (cheader_filename = "purple.h")]
 
3885
        public static void smarshal_VOID__ENUM_STRING_STRING_BOOLEAN (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3886
        [CCode (cheader_filename = "purple.h")]
 
3887
        public static void smarshal_VOID__POINTER_POINTER_OBJECT (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3888
        [CCode (cheader_filename = "purple.h")]
 
3889
        public static void smarshal_VOID__STRING_STRING (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3890
        [CCode (cheader_filename = "purple.h")]
 
3891
        public static void smarshal_VOID__STRING_STRING_DOUBLE (GLib.Closure closure, Gst.Value return_value, uint n_param_values, Gst.Value param_values, void* invocation_hint, void* marshal_data);
 
3892
        [CCode (cheader_filename = "purple.h")]
 
3893
        public static unowned Purple.Smiley smileys_find_by_checksum (string checksum);
 
3894
        [CCode (cheader_filename = "purple.h")]
 
3895
        public static unowned Purple.Smiley smileys_find_by_shortcut (string shortcut);
 
3896
        [CCode (cheader_filename = "purple.h")]
 
3897
        public static unowned GLib.List smileys_get_all ();
 
3898
        [CCode (cheader_filename = "purple.h")]
 
3899
        public static unowned string smileys_get_storing_dir ();
 
3900
        [CCode (cheader_filename = "purple.h")]
 
3901
        public static void smileys_init ();
 
3902
        [CCode (cheader_filename = "purple.h")]
 
3903
        public static void smileys_uninit ();
 
3904
        [CCode (cheader_filename = "purple.h")]
 
3905
        public static unowned Purple.SoundUiOps sound_get_ui_ops ();
 
3906
        [CCode (cheader_filename = "purple.h")]
 
3907
        public static void sound_init ();
 
3908
        [CCode (cheader_filename = "purple.h")]
 
3909
        public static void sound_play_event (Purple.SoundEventID event, Purple.Account account);
 
3910
        [CCode (cheader_filename = "purple.h")]
 
3911
        public static void sound_play_file (string filename, Purple.Account account);
 
3912
        [CCode (cheader_filename = "purple.h")]
 
3913
        public static void sound_set_ui_ops (Purple.SoundUiOps ops);
 
3914
        [CCode (cheader_filename = "purple.h")]
 
3915
        public static void sound_uninit ();
 
3916
        [CCode (cheader_filename = "purple.h")]
 
3917
        public static void* sounds_get_handle ();
 
3918
        [CCode (cheader_filename = "purple.h")]
 
3919
        public static void srv_cancel (Purple.SrvQueryData query_data);
 
3920
        [CCode (cheader_filename = "purple.h")]
 
3921
        public static unowned Purple.SrvQueryData srv_resolve (string protocol, string transport, string domain, Purple.SrvCallback cb, void* extradata);
 
3922
        [CCode (cheader_filename = "purple.h")]
 
3923
        public static void ssl_close (Purple.SslConnection gsc);
 
3924
        [CCode (cheader_filename = "purple.h")]
 
3925
        public static unowned Purple.SslConnection ssl_connect (Purple.Account account, string host, int port, Purple.SslInputFunction func, Purple.SslErrorFunction error_func, void* data);
 
3926
        [CCode (cheader_filename = "purple.h")]
 
3927
        public static unowned Purple.SslConnection ssl_connect_fd (Purple.Account account, int fd, Purple.SslInputFunction func, Purple.SslErrorFunction error_func, void* data);
 
3928
        [CCode (cheader_filename = "purple.h")]
 
3929
        public static unowned Purple.SslConnection ssl_connect_with_host_fd (Purple.Account account, int fd, Purple.SslInputFunction func, Purple.SslErrorFunction error_func, string host, void* data);
 
3930
        [CCode (cheader_filename = "purple.h")]
 
3931
        public static unowned Purple.SslConnection ssl_connect_with_ssl_cn (Purple.Account account, string host, int port, Purple.SslInputFunction func, Purple.SslErrorFunction error_func, string ssl_host, void* data);
 
3932
        [CCode (cheader_filename = "purple.h")]
 
3933
        public static unowned Purple.SslOps ssl_get_ops ();
 
3934
        [CCode (cheader_filename = "purple.h")]
 
3935
        public static unowned GLib.List ssl_get_peer_certificates (Purple.SslConnection gsc);
 
3936
        [CCode (cheader_filename = "purple.h")]
 
3937
        public static void ssl_init ();
 
3938
        [CCode (cheader_filename = "purple.h")]
 
3939
        public static void ssl_input_add (Purple.SslConnection gsc, Purple.SslInputFunction func, void* data);
 
3940
        [CCode (cheader_filename = "purple.h")]
 
3941
        public static bool ssl_is_supported ();
 
3942
        [CCode (cheader_filename = "purple.h")]
 
3943
        public static size_t ssl_read (Purple.SslConnection gsc, void* buffer, size_t len);
 
3944
        [CCode (cheader_filename = "purple.h")]
 
3945
        public static void ssl_set_ops (Purple.SslOps ops);
 
3946
        [CCode (cheader_filename = "purple.h")]
 
3947
        public static unowned string ssl_strerror (Purple.SslErrorType error);
 
3948
        [CCode (cheader_filename = "purple.h")]
 
3949
        public static void ssl_uninit ();
 
3950
        [CCode (cheader_filename = "purple.h")]
 
3951
        public static size_t ssl_write (Purple.SslConnection gsc, void* buffer, size_t len);
 
3952
        [CCode (cheader_filename = "purple.h")]
 
3953
        public static unowned string str_add_cr (string str);
 
3954
        [CCode (cheader_filename = "purple.h")]
 
3955
        public static unowned string str_binary_to_ascii (uint binary, uint len);
 
3956
        [CCode (cheader_filename = "purple.h")]
 
3957
        public static bool str_has_prefix (string s, string p);
 
3958
        [CCode (cheader_filename = "purple.h")]
 
3959
        public static bool str_has_suffix (string s, string x);
 
3960
        [CCode (cheader_filename = "purple.h")]
 
3961
        public static unowned string str_seconds_to_string (uint sec);
 
3962
        [CCode (cheader_filename = "purple.h")]
 
3963
        public static unowned string str_size_to_units (size_t size);
 
3964
        [CCode (cheader_filename = "purple.h")]
 
3965
        public static void str_strip_char (string str, DBus.ObjectPath thechar);
 
3966
        [CCode (cheader_filename = "purple.h")]
 
3967
        public static ulong str_to_time (string timestamp, bool utc, void* tm, long tz_off, out unowned string rest);
 
3968
        [CCode (cheader_filename = "purple.h")]
 
3969
        public static unowned string strcasereplace (string str, string delimiter, string replacement);
 
3970
        [CCode (cheader_filename = "purple.h")]
 
3971
        public static unowned string strcasestr (string haystack, string needle);
 
3972
        [CCode (cheader_filename = "purple.h")]
 
3973
        public static unowned string strdup_withhtml (string src);
 
3974
        [CCode (cheader_filename = "purple.h")]
 
3975
        public static bool strequal (string left, string right);
 
3976
        [CCode (cheader_filename = "purple.h")]
 
3977
        public static unowned string strreplace (string str, string delimiter, string replacement);
 
3978
        [CCode (cheader_filename = "purple.h")]
 
3979
        public static unowned Purple.StunNatDiscovery stun_discover (Purple.StunCallback cb);
 
3980
        [CCode (cheader_filename = "purple.h")]
 
3981
        public static void stun_init ();
 
3982
        [CCode (cheader_filename = "purple.h")]
 
3983
        public static unowned string text_strip_mnemonic (string @in);
 
3984
        [CCode (cheader_filename = "purple.h")]
 
3985
        public static ulong time_build (int year, int month, int day, int hour, int min, int sec);
 
3986
        [CCode (cheader_filename = "purple.h")]
 
3987
        public static unowned string time_format (void* tm);
 
3988
        [CCode (cheader_filename = "purple.h")]
 
3989
        public static uint timeout_add (uint interval, GLib.SourceFunc function, void* data);
 
3990
        [CCode (cheader_filename = "purple.h")]
 
3991
        public static uint timeout_add_seconds (uint interval, GLib.SourceFunc function, void* data);
 
3992
        [CCode (cheader_filename = "purple.h")]
 
3993
        public static bool timeout_remove (uint handle);
 
3994
        [CCode (cheader_filename = "purple.h")]
 
3995
        public static void txt_cancel (Purple.SrvQueryData query_data);
 
3996
        [CCode (cheader_filename = "purple.h")]
 
3997
        public static unowned Purple.SrvQueryData txt_resolve (string owner, string domain, Purple.TxtCallback cb, void* extradata);
 
3998
        [CCode (cheader_filename = "purple.h")]
 
3999
        public static unowned string unescape_filename (string str);
 
4000
        [CCode (cheader_filename = "purple.h")]
 
4001
        public static unowned string unescape_html (string html);
 
4002
        [CCode (cheader_filename = "purple.h")]
 
4003
        public static void upnp_cancel_port_mapping (Purple.UPnPMappingAddRemove mapping_data);
 
4004
        [CCode (cheader_filename = "purple.h")]
 
4005
        public static void upnp_discover (Purple.UPnPCallback cb, void* cb_data);
 
4006
        [CCode (cheader_filename = "purple.h")]
 
4007
        public static unowned string upnp_get_public_ip ();
 
4008
        [CCode (cheader_filename = "purple.h")]
 
4009
        public static void upnp_init ();
 
4010
        [CCode (cheader_filename = "purple.h")]
 
4011
        public static unowned Purple.UPnPMappingAddRemove upnp_remove_port_mapping (uint portmap, string protocol, Purple.UPnPCallback cb, void* cb_data);
 
4012
        [CCode (cheader_filename = "purple.h")]
 
4013
        public static unowned Purple.UPnPMappingAddRemove upnp_set_port_mapping (uint portmap, string protocol, Purple.UPnPCallback cb, void* cb_data);
 
4014
        [CCode (cheader_filename = "purple.h")]
 
4015
        public static unowned GLib.List uri_list_extract_filenames (string uri_list);
 
4016
        [CCode (cheader_filename = "purple.h")]
 
4017
        public static unowned GLib.List uri_list_extract_uris (string uri_list);
 
4018
        [CCode (cheader_filename = "purple.h")]
 
4019
        public static unowned string url_decode (string str);
 
4020
        [CCode (cheader_filename = "purple.h")]
 
4021
        public static unowned string url_encode (string str);
 
4022
        [CCode (cheader_filename = "purple.h")]
 
4023
        public static bool url_parse (string url, out unowned string ret_host, int ret_port, out unowned string ret_path, out unowned string ret_user, out unowned string ret_passwd);
 
4024
        [CCode (cheader_filename = "purple.h")]
 
4025
        public static unowned string user_dir ();
 
4026
        [CCode (cheader_filename = "purple.h")]
 
4027
        public static bool utf8_has_word (string haystack, string needle);
 
4028
        [CCode (cheader_filename = "purple.h")]
 
4029
        public static unowned string utf8_ncr_decode (string @in);
 
4030
        [CCode (cheader_filename = "purple.h")]
 
4031
        public static unowned string utf8_ncr_encode (string @in);
 
4032
        [CCode (cheader_filename = "purple.h")]
 
4033
        public static unowned string utf8_salvage (string str);
 
4034
        [CCode (cheader_filename = "purple.h")]
 
4035
        public static int utf8_strcasecmp (string a, string b);
 
4036
        [CCode (cheader_filename = "purple.h")]
 
4037
        public static unowned string utf8_strftime (string format, void* tm);
 
4038
        [CCode (cheader_filename = "purple.h")]
 
4039
        public static unowned string utf8_strip_unprintables (string str);
 
4040
        [CCode (cheader_filename = "purple.h")]
 
4041
        public static unowned string utf8_try_convert (string str);
 
4042
        [CCode (cheader_filename = "purple.h")]
 
4043
        public static void util_chrreplace (string str, DBus.ObjectPath delimiter, DBus.ObjectPath replacement);
 
4044
        [CCode (cheader_filename = "purple.h")]
 
4045
        public static void util_fetch_url_cancel (Purple.UtilFetchUrlData url_data);
 
4046
        [CCode (cheader_filename = "purple.h")]
 
4047
        public static unowned Purple.UtilFetchUrlData util_fetch_url_request (string url, bool full, string user_agent, bool http11, string request, bool include_headers, Purple.UtilFetchUrlCallback callback, void* data);
 
4048
        [CCode (cheader_filename = "purple.h")]
 
4049
        public static unowned Purple.UtilFetchUrlData util_fetch_url_request_len (string url, bool full, string user_agent, bool http11, string request, bool include_headers, ssize_t max_len, Purple.UtilFetchUrlCallback callback, void* data);
 
4050
        [CCode (cheader_filename = "purple.h")]
 
4051
        public static unowned Purple.UtilFetchUrlData util_fetch_url_request_len_with_account (Purple.Account account, string url, bool full, string user_agent, bool http11, string request, bool include_headers, ssize_t max_len, Purple.UtilFetchUrlCallback callback, void* data);
 
4052
        [CCode (cheader_filename = "purple.h")]
 
4053
        public static unowned string util_format_song_info (string title, string artist, string album, void* unused);
 
4054
        [CCode (cheader_filename = "purple.h")]
 
4055
        public static unowned string util_get_image_checksum (void* image_data, size_t image_len);
 
4056
        [CCode (cheader_filename = "purple.h")]
 
4057
        public static unowned string util_get_image_extension (void* data, size_t len);
 
4058
        [CCode (cheader_filename = "purple.h")]
 
4059
        public static unowned string util_get_image_filename (void* image_data, size_t image_len);
 
4060
        [CCode (cheader_filename = "purple.h")]
 
4061
        public static void util_init ();
 
4062
        [CCode (cheader_filename = "purple.h")]
 
4063
        public static unowned Purple.xmlnode util_read_xml_from_file (string filename, string description);
 
4064
        [CCode (cheader_filename = "purple.h")]
 
4065
        public static void util_set_current_song (string title, string artist, string album);
 
4066
        [CCode (cheader_filename = "purple.h")]
 
4067
        public static void util_set_user_dir (string dir);
 
4068
        [CCode (cheader_filename = "purple.h")]
 
4069
        public static void util_uninit ();
 
4070
        [CCode (cheader_filename = "purple.h")]
 
4071
        public static bool util_write_data_to_file (string filename, string data, ssize_t size);
 
4072
        [CCode (cheader_filename = "purple.h")]
 
4073
        public static bool util_write_data_to_file_absolute (string filename_full, string data, ssize_t size);
 
4074
        [CCode (cheader_filename = "purple.h")]
 
4075
        public static unowned string version_check (uint required_major, uint required_minor, uint required_micro);
 
4076
        [CCode (cheader_filename = "purple.h")]
 
4077
        public static unowned GLib.List xfers_get_all ();
 
4078
        [CCode (cheader_filename = "purple.h")]
 
4079
        public static void* xfers_get_handle ();
 
4080
        [CCode (cheader_filename = "purple.h")]
 
4081
        public static unowned Purple.XferUiOps xfers_get_ui_ops ();
 
4082
        [CCode (cheader_filename = "purple.h")]
 
4083
        public static void xfers_init ();
 
4084
        [CCode (cheader_filename = "purple.h")]
 
4085
        public static void xfers_set_ui_ops (Purple.XferUiOps ops);
 
4086
        [CCode (cheader_filename = "purple.h")]
 
4087
        public static void xfers_uninit ();
 
4088
}