libpurple/signals.h

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21
  22 #ifndef _PURPLE_SIGNALS_H_
  23 #define _PURPLE_SIGNALS_H_
  24 /**
  25  * SECTION:signals
  26  * @section_id: libpurple-signals
  27  * @short_description: <filename>signals.h</filename>
  28  * @title: Purple-signals API
  29  * @see_also: <link linkend="chapter-tut-signals">Signals tutorial</link>
  30  */
  31
  32 #include <glib.h>
  33 #include <glib-object.h>
  34
  35 #define PURPLE_CALLBACK(func) ((PurpleCallback)func)
  36
  37 typedef void (*PurpleCallback)(void);
  38 typedef void (*PurpleSignalMarshalFunc)(PurpleCallback cb, va_list args,
  39                                                                           void *data, void **return_val);
  40
  41 G_BEGIN_DECLS
  42
  43 /******************************************************************************
  44  * Signal API
  45  *****************************************************************************/
  46
  47 /**
  48  * PURPLE_SIGNAL_PRIORITY_DEFAULT:
  49  *
  50  * The priority of a signal connected using purple_signal_connect().
  51  *
  52  * See purple_signal_connect_priority()
  53  */
  54 #define PURPLE_SIGNAL_PRIORITY_DEFAULT     0
  55
  56 /**
  57  * PURPLE_SIGNAL_PRIORITY_HIGHEST:
  58  *
  59  * The largest signal priority; signals with this priority will be called
  60  * <emphasis>last</emphasis>.  (This is highest as in numerical value, not as in
  61  * order of importance.)
  62  *
  63  * See purple_signal_connect_priority().
  64  */
  65 #define PURPLE_SIGNAL_PRIORITY_HIGHEST  9999
  66
  67 /**
  68  * PURPLE_SIGNAL_PRIORITY_LOWEST:
  69  *
  70  * The smallest signal priority; signals with this priority will be called
  71  * <emphasis>first</emphasis>.  (This is lowest as in numerical value, not as in
  72  * order of importance.)
  73  *
  74  * See purple_signal_connect_priority().
  75  */
  76 #define PURPLE_SIGNAL_PRIORITY_LOWEST  -9999
  77
  78 /**
  79  * purple_signal_register:
  80  * @instance:   The instance to register the signal for.
  81  * @signal:     The signal name.
  82  * @marshal:    The marshal function.
  83  * @ret_type:   The return type, or G_TYPE_NONE for no return type.
  84  * @num_values: The number of values to be passed to the callbacks.
  85  * @...:        The types of the parameters for the callbacks.
  86  *
  87  * Registers a signal in an instance.
  88  *
  89  * Returns: The signal ID local to that instance, or 0 if the signal
  90  *          couldn't be registered.
  91  */
  92 gulong purple_signal_register(void *instance, const char *signal,
  93                                                         PurpleSignalMarshalFunc marshal,
  94                                                         GType ret_type, int num_values, ...);
  95
  96 /**
  97  * purple_signal_unregister:
  98  * @instance: The instance to unregister the signal for.
  99  * @signal:   The signal name.
 100  *
 101  * Unregisters a signal in an instance.
 102  */
 103 void purple_signal_unregister(void *instance, const char *signal);
 104
 105 /**
 106  * purple_signals_unregister_by_instance:
 107  * @instance: The instance to unregister the signal for.
 108  *
 109  * Unregisters all signals in an instance.
 110  */
 111 void purple_signals_unregister_by_instance(void *instance);
 112
 113 /**
 114  * purple_signal_get_types:
 115  * @instance:           The instance the signal is registered to.
 116  * @signal:             The signal.
 117  * @ret_type: (out):    The return type.
 118  * @num_values: (out):  The returned number of parameters.
 119  * @param_types: (out): The returned list of parameter types.
 120  *
 121  * Outputs a list of value types used for a signal through the @ret_type,
 122  * @num_values and @param_types out parameters.
 123  */
 124 void purple_signal_get_types(void *instance, const char *signal,
 125                                                         GType *ret_type, int *num_values,
 126                                                         GType **param_types);
 127
 128 /**
 129  * purple_signal_connect_priority:
 130  * @instance: The instance to connect to.
 131  * @signal:   The name of the signal to connect.
 132  * @handle:   The handle of the receiver.
 133  * @func:     The callback function.
 134  * @data:     The data to pass to the callback function.
 135  * @priority: The priority with which the handler should be called. Signal
 136  *                 handlers are called in ascending numerical order of
 137  *                 @priority from #PURPLE_SIGNAL_PRIORITY_LOWEST to
 138  *                 #PURPLE_SIGNAL_PRIORITY_HIGHEST.
 139  *
 140  * Connects a signal handler to a signal for a particular object.
 141  *
 142  * Take care not to register a handler function twice. Purple will
 143  * not correct any mistakes for you in this area.
 144  *
 145  * See purple_signal_disconnect()
 146  *
 147  * Returns: The signal handler ID.
 148  */
 149 gulong purple_signal_connect_priority(void *instance, const char *signal,
 150         void *handle, PurpleCallback func, void *data, int priority);
 151
 152 /**
 153  * purple_signal_connect:
 154  * @instance: The instance to connect to.
 155  * @signal:   The name of the signal to connect.
 156  * @handle:   The handle of the receiver.
 157  * @func:     The callback function.
 158  * @data:     The data to pass to the callback function.
 159  *
 160  * Connects a signal handler to a signal for a particular object.
 161  * (Its priority defaults to 0, aka #PURPLE_SIGNAL_PRIORITY_DEFAULT.)
 162  *
 163  * Take care not to register a handler function twice. Purple will
 164  * not correct any mistakes for you in this area.
 165  *
 166  * See purple_signal_disconnect()
 167  *
 168  * Returns: The signal handler ID.
 169  */
 170 gulong purple_signal_connect(void *instance, const char *signal,
 171         void *handle, PurpleCallback func, void *data);
 172
 173 /**
 174  * purple_signal_connect_priority_vargs:
 175  * @instance: The instance to connect to.
 176  * @signal:   The name of the signal to connect.
 177  * @handle:   The handle of the receiver.
 178  * @func:     The callback function.
 179  * @data:     The data to pass to the callback function.
 180  * @priority: The priority with which the handler should be called. Signal
 181  *                 handlers are called in ascending numerical order of
 182  *                 @priority from #PURPLE_SIGNAL_PRIORITY_LOWEST to
 183  *                 #PURPLE_SIGNAL_PRIORITY_HIGHEST.
 184  *
 185  * Connects a signal handler to a signal for a particular object.
 186  *
 187  * The signal handler will take a va_args of arguments, instead of
 188  * individual arguments.
 189  *
 190  * Take care not to register a handler function twice. Purple will
 191  * not correct any mistakes for you in this area.
 192  *
 193  * See purple_signal_disconnect()
 194  *
 195  * Returns: The signal handler ID.
 196  */
 197 gulong purple_signal_connect_priority_vargs(void *instance, const char *signal,
 198         void *handle, PurpleCallback func, void *data, int priority);
 199
 200 /**
 201  * purple_signal_connect_vargs:
 202  * @instance: The instance to connect to.
 203  * @signal:   The name of the signal to connect.
 204  * @handle:   The handle of the receiver.
 205  * @func:     The callback function.
 206  * @data:     The data to pass to the callback function.
 207  *
 208  * Connects a signal handler to a signal for a particular object.
 209  * (Its priority defaults to 0, aka #PURPLE_SIGNAL_PRIORITY_DEFAULT.)
 210  *
 211  * The signal handler will take a va_args of arguments, instead of
 212  * individual arguments.
 213  *
 214  * Take care not to register a handler function twice. Purple will
 215  * not correct any mistakes for you in this area.
 216  *
 217  * See purple_signal_disconnect()
 218  *
 219  * Returns: The signal handler ID.
 220  */
 221 gulong purple_signal_connect_vargs(void *instance, const char *signal,
 222         void *handle, PurpleCallback func, void *data);
 223
 224 /**
 225  * purple_signal_disconnect:
 226  * @instance: The instance to disconnect from.
 227  * @signal:   The name of the signal to disconnect.
 228  * @handle:   The handle of the receiver.
 229  * @func:     The registered function to disconnect.
 230  *
 231  * Disconnects a signal handler from a signal on an object.
 232  *
 233  * See purple_signal_connect()
 234  */
 235 void purple_signal_disconnect(void *instance, const char *signal,
 236                                                         void *handle, PurpleCallback func);
 237
 238 /**
 239  * purple_signals_disconnect_by_handle:
 240  * @handle: The receiver handle.
 241  *
 242  * Removes all callbacks associated with a receiver handle.
 243  */
 244 void purple_signals_disconnect_by_handle(void *handle);
 245
 246 /**
 247  * purple_signal_emit:
 248  * @instance: The instance emitting the signal.
 249  * @signal:   The signal being emitted.
 250  * @...:      The arguments to pass to the callbacks.
 251  *
 252  * Emits a signal.
 253  *
 254  * See purple_signal_connect(), purple_signal_disconnect()
 255  */
 256 void purple_signal_emit(void *instance, const char *signal, ...);
 257
 258 /**
 259  * purple_signal_emit_vargs:
 260  * @instance: The instance emitting the signal.
 261  * @signal:   The signal being emitted.
 262  * @args:     The arguments list.
 263  *
 264  * Emits a signal, using a va_list of arguments.
 265  *
 266  * See purple_signal_connect(), purple_signal_disconnect()
 267  */
 268 void purple_signal_emit_vargs(void *instance, const char *signal, va_list args);
 269
 270 /**
 271  * purple_signal_emit_return_1:
 272  * @instance: The instance emitting the signal.
 273  * @signal:   The signal being emitted.
 274  * @...:      The arguments to pass to the callbacks.
 275  *
 276  * Emits a signal and returns the first non-NULL return value.
 277  *
 278  * Further signal handlers are NOT called after a handler returns
 279  * something other than NULL.
 280  *
 281  * Returns: The first non-NULL return value
 282  */
 283 void *purple_signal_emit_return_1(void *instance, const char *signal, ...);
 284
 285 /**
 286  * purple_signal_emit_vargs_return_1:
 287  * @instance: The instance emitting the signal.
 288  * @signal:   The signal being emitted.
 289  * @args:     The arguments list.
 290  *
 291  * Emits a signal and returns the first non-NULL return value.
 292  *
 293  * Further signal handlers are NOT called after a handler returns
 294  * something other than NULL.
 295  *
 296  * Returns: The first non-NULL return value
 297  */
 298 void *purple_signal_emit_vargs_return_1(void *instance, const char *signal,
 299                                                                           va_list args);
 300
 301 /**
 302  * purple_signals_init:
 303  *
 304  * Initializes the signals subsystem.
 305  */
 306 void purple_signals_init(void);
 307
 308 /**
 309  * purple_signals_uninit:
 310  *
 311  * Uninitializes the signals subsystem.
 312  */
 313 void purple_signals_uninit(void);
 314
 315 /**************************************************************************/
 316 /* Marshal Functions                                                      */
 317 /**************************************************************************/
 318
 319 /**
 320  * purple_marshal_VOID:
 321  * @cb: (scope call): Callback this marshaller is designed to invoke
 322  * @args: va_list of arguments to be passed to the closure
 323  * @data: (nullable): Data to be passed to the callback
 324  * @return_val: (nullable): Value to store the callback's return value
 325  *
 326  * A purple marshaller function for use with signals with no arguments.
 327  */
 328 void purple_marshal_VOID(
 329                 PurpleCallback cb, va_list args, void *data, void **return_val);
 330
 331 /**
 332  * purple_marshal_VOID__INT:
 333  * @cb: (scope call): Callback this marshaller is designed to invoke
 334  * @args: va_list of arguments to be passed to the closure
 335  * @data: (nullable): Data to be passed to the callback
 336  * @return_val: (nullable): Value to store the callback's return value
 337  *
 338  * A purple marshaller function for use with signals with a single integer
 339  * argument.
 340  */
 341 void purple_marshal_VOID__INT(
 342                 PurpleCallback cb, va_list args, void *data, void **return_val);
 343
 344 /**
 345  * purple_marshal_VOID__INT_INT:
 346  * @cb: (scope call): Callback this marshaller is designed to invoke
 347  * @args: va_list of arguments to be passed to the closure
 348  * @data: (nullable): Data to be passed to the callback
 349  * @return_val: (nullable): Value to store the callback's return value
 350  *
 351  * A purple marshaller function for use with signals with two integer
 352  * arguments.
 353  */
 354 void purple_marshal_VOID__INT_INT(
 355                 PurpleCallback cb, va_list args, void *data, void **return_val);
 356
 357 /**
 358  * purple_marshal_VOID__POINTER:
 359  * @cb: (scope call): Callback this marshaller is designed to invoke
 360  * @args: va_list of arguments to be passed to the closure
 361  * @data: (nullable): Data to be passed to the callback
 362  * @return_val: (nullable): Value to store the callback's return value
 363  *
 364  * A purple marshaller function for use with signals with a single pointer
 365  * argument.
 366  */
 367 void purple_marshal_VOID__POINTER(
 368                 PurpleCallback cb, va_list args, void *data, void **return_val);
 369
 370 /**
 371  * purple_marshal_VOID__POINTER_UINT:
 372  * @cb: (scope call): Callback this marshaller is designed to invoke
 373  * @args: va_list of arguments to be passed to the closure
 374  * @data: (nullable): Data to be passed to the callback
 375  * @return_val: (nullable): Value to store the callback's return value
 376  *
 377  * A purple marshaller function for use with signals with a pointer and
 378  * an unsigned integer argument.
 379  */
 380 void purple_marshal_VOID__POINTER_UINT(
 381                 PurpleCallback cb, va_list args, void *data, void **return_val);
 382
 383 /**
 384  * purple_marshal_VOID__POINTER_INT_INT:
 385  * @cb: (scope call): Callback this marshaller is designed to invoke
 386  * @args: va_list of arguments to be passed to the closure
 387  * @data: (nullable): Data to be passed to the callback
 388  * @return_val: (nullable): Value to store the callback's return value
 389  *
 390  * A purple marshaller function for use with signals with a pointer and
 391  * two integer arguments.
 392  */
 393 void purple_marshal_VOID__POINTER_INT_INT(
 394                 PurpleCallback cb, va_list args, void *data, void **return_val);
 395
 396 /**
 397  * purple_marshal_VOID__POINTER_INT_POINTER:
 398  * @cb: (scope call): Callback this marshaller is designed to invoke
 399  * @args: va_list of arguments to be passed to the closure
 400  * @data: (nullable): Data to be passed to the callback
 401  * @return_val: (nullable): Value to store the callback's return value
 402  *
 403  * A purple marshaller function for use with signals with a pointer, an
 404  * integer, and then another pointer argument.
 405  */
 406 void purple_marshal_VOID__POINTER_INT_POINTER(
 407                 PurpleCallback cb, va_list args, void *data, void **return_val);
 408
 409 /**
 410  * purple_marshal_VOID__POINTER_POINTER:
 411  * @cb: (scope call): Callback this marshaller is designed to invoke
 412  * @args: va_list of arguments to be passed to the closure
 413  * @data: (nullable): Data to be passed to the callback
 414  * @return_val: (nullable): Value to store the callback's return value
 415  *
 416  * A purple marshaller function for use with signals with two pointer
 417  * arguments.
 418  */
 419 void purple_marshal_VOID__POINTER_POINTER(
 420                 PurpleCallback cb, va_list args, void *data, void **return_val);
 421
 422 /**
 423  * purple_marshal_VOID__POINTER_POINTER_UINT:
 424  * @cb: (scope call): Callback this marshaller is designed to invoke
 425  * @args: va_list of arguments to be passed to the closure
 426  * @data: (nullable): Data to be passed to the callback
 427  * @return_val: (nullable): Value to store the callback's return value
 428  *
 429  * A purple marshaller function for use with signals with two pointers
 430  * and an unsigned integer argument.
 431  */
 432 void purple_marshal_VOID__POINTER_POINTER_UINT(
 433                 PurpleCallback cb, va_list args, void *data, void **return_val);
 434
 435 /**
 436  * purple_marshal_VOID__POINTER_POINTER_UINT_UINT:
 437  * @cb: (scope call): Callback this marshaller is designed to invoke
 438  * @args: va_list of arguments to be passed to the closure
 439  * @data: (nullable): Data to be passed to the callback
 440  * @return_val: (nullable): Value to store the callback's return value
 441  *
 442  * A purple marshaller function for use with signals with two pointers
 443  * and two unsigned integer arguments.
 444  */
 445 void purple_marshal_VOID__POINTER_POINTER_UINT_UINT(
 446                 PurpleCallback cb, va_list args, void *data, void **return_val);
 447
 448 /**
 449  * purple_marshal_VOID__POINTER_UINT_UINT:
 450  * @cb: (scope call): Callback this marshaller is designed to invoke
 451  * @args: va_list of arguments to be passed to the closure
 452  * @data: (nullable): Data to be passed to the callback
 453  * @return_val: (nullable): Value to store the callback's return value
 454  *
 455  * A purple marshaller function for use with signals with a pointer and
 456  * two unsigned integer arguments.
 457  */
 458 void purple_marshal_VOID__POINTER_UINT_UINT(
 459                 PurpleCallback cb, va_list args, void *data, void **return_val);
 460
 461 /**
 462  * purple_marshal_VOID__POINTER_POINTER_POINTER:
 463  * @cb: (scope call): Callback this marshaller is designed to invoke
 464  * @args: va_list of arguments to be passed to the closure
 465  * @data: (nullable): Data to be passed to the callback
 466  * @return_val: (nullable): Value to store the callback's return value
 467  *
 468  * A purple marshaller function for use with signals with three pointer
 469  * arguments.
 470  */
 471 void purple_marshal_VOID__POINTER_POINTER_POINTER(
 472                 PurpleCallback cb, va_list args, void *data, void **return_val);
 473
 474 /**
 475  * purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER:
 476  * @cb: (scope call): Callback this marshaller is designed to invoke
 477  * @args: va_list of arguments to be passed to the closure
 478  * @data: (nullable): Data to be passed to the callback
 479  * @return_val: (nullable): Value to store the callback's return value
 480  *
 481  * A purple marshaller function for use with signals with four pointer
 482  * arguments.
 483  */
 484 void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER(
 485                 PurpleCallback cb, va_list args, void *data, void **return_val);
 486
 487 /**
 488  * purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER:
 489  * @cb: (scope call): Callback this marshaller is designed to invoke
 490  * @args: va_list of arguments to be passed to the closure
 491  * @data: (nullable): Data to be passed to the callback
 492  * @return_val: (nullable): Value to store the callback's return value
 493  *
 494  * A purple marshaller function for use with signals with five pointer
 495  * arguments.
 496  */
 497 void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_POINTER(
 498                 PurpleCallback cb, va_list args, void *data, void **return_val);
 499
 500 /**
 501  * purple_marshal_VOID__POINTER_POINTER_POINTER_UINT:
 502  * @cb: (scope call): Callback this marshaller is designed to invoke
 503  * @args: va_list of arguments to be passed to the closure
 504  * @data: (nullable): Data to be passed to the callback
 505  * @return_val: (nullable): Value to store the callback's return value
 506  *
 507  * A purple marshaller function for use with signals with three pointer
 508  * and one unsigned integer arguments.
 509  */
 510 void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT(
 511                 PurpleCallback cb, va_list args, void *data, void **return_val);
 512
 513 /**
 514  * purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT:
 515  * @cb: (scope call): Callback this marshaller is designed to invoke
 516  * @args: va_list of arguments to be passed to the closure
 517  * @data: (nullable): Data to be passed to the callback
 518  * @return_val: (nullable): Value to store the callback's return value
 519  *
 520  * A purple marshaller function for use with signals with four pointer and
 521  * one unsigned integer arguments.
 522  */
 523 void purple_marshal_VOID__POINTER_POINTER_POINTER_POINTER_UINT(
 524                 PurpleCallback cb, va_list args, void *data, void **return_val);
 525
 526 /**
 527  * purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT:
 528  * @cb: (scope call): Callback this marshaller is designed to invoke
 529  * @args: va_list of arguments to be passed to the closure
 530  * @data: (nullable): Data to be passed to the callback
 531  * @return_val: (nullable): Value to store the callback's return value
 532  *
 533  * A purple marshaller function for use with signals with three pointer
 534  * and two unsigned integer arguments.
 535  */
 536 void purple_marshal_VOID__POINTER_POINTER_POINTER_UINT_UINT(
 537                 PurpleCallback cb, va_list args, void *data, void **return_val);
 538
 539 /**
 540  * purple_marshal_INT__INT:
 541  * @cb: (scope call): Callback this marshaller is designed to invoke
 542  * @args: va_list of arguments to be passed to the closure
 543  * @data: (nullable): Data to be passed to the callback
 544  * @return_val: (nullable): Value to store the callback's return value
 545  *
 546  * A purple marshaller function for use with signals with an integer argument
 547  * and returns an integer.
 548  */
 549 void purple_marshal_INT__INT(
 550                 PurpleCallback cb, va_list args, void *data, void **return_val);
 551
 552 /**
 553  * purple_marshal_INT__INT_INT:
 554  * @cb: (scope call): Callback this marshaller is designed to invoke
 555  * @args: va_list of arguments to be passed to the closure
 556  * @data: (nullable): Data to be passed to the callback
 557  * @return_val: (nullable): Value to store the callback's return value
 558  *
 559  * A purple marshaller function for use with signals with two integer
 560  * arguments and returns an integer.
 561  */
 562 void purple_marshal_INT__INT_INT(
 563                 PurpleCallback cb, va_list args, void *data, void **return_val);
 564
 565 /**
 566  * purple_marshal_INT__POINTER_POINTER:
 567  * @cb: (scope call): Callback this marshaller is designed to invoke
 568  * @args: va_list of arguments to be passed to the closure
 569  * @data: (nullable): Data to be passed to the callback
 570  * @return_val: (nullable): Value to store the callback's return value
 571  *
 572  * A purple marshaller function for use with signals with two pointer
 573  * arguments and returns an integer.
 574  */
 575 void purple_marshal_INT__POINTER_POINTER(
 576                 PurpleCallback cb, va_list args, void *data, void **return_val);
 577
 578 /**
 579  * purple_marshal_INT__POINTER_POINTER_POINTER:
 580  * @cb: (scope call): Callback this marshaller is designed to invoke
 581  * @args: va_list of arguments to be passed to the closure
 582  * @data: (nullable): Data to be passed to the callback
 583  * @return_val: (nullable): Value to store the callback's return value
 584  *
 585  * A purple marshaller function for use with signals with three pointer
 586  * arguments and returns an integer.
 587  */
 588 void purple_marshal_INT__POINTER_POINTER_POINTER(
 589                 PurpleCallback cb, va_list args, void *data, void **return_val);
 590
 591 /**
 592  * purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER:
 593  * @cb: (scope call): Callback this marshaller is designed to invoke
 594  * @args: va_list of arguments to be passed to the closure
 595  * @data: (nullable): Data to be passed to the callback
 596  * @return_val: (nullable): Value to store the callback's return value
 597  *
 598  * A purple marshaller function for use with signals with five pointer
 599  * arguments and returns an integer.
 600  */
 601 void purple_marshal_INT__POINTER_POINTER_POINTER_POINTER_POINTER(
 602                 PurpleCallback cb, va_list args, void *data, void **return_val);
 603
 604 /**
 605  * purple_marshal_BOOLEAN__POINTER:
 606  * @cb: (scope call): Callback this marshaller is designed to invoke
 607  * @args: va_list of arguments to be passed to the closure
 608  * @data: (nullable): Data to be passed to the callback
 609  * @return_val: (nullable): Value to store the callback's return value
 610  *
 611  * A purple marshaller function for use with signals with a single pointer
 612  * argument and returns a boolean.
 613  */
 614 void purple_marshal_BOOLEAN__POINTER(
 615                 PurpleCallback cb, va_list args, void *data, void **return_val);
 616
 617 /**
 618  * purple_marshal_BOOLEAN__POINTER_POINTER:
 619  * @cb: (scope call): Callback this marshaller is designed to invoke
 620  * @args: va_list of arguments to be passed to the closure
 621  * @data: (nullable): Data to be passed to the callback
 622  * @return_val: (nullable): Value to store the callback's return value
 623  *
 624  * A purple marshaller function for use with signals with two pointer
 625  * arguments and returns a boolean.
 626  */
 627 void purple_marshal_BOOLEAN__POINTER_POINTER(
 628                 PurpleCallback cb, va_list args, void *data, void **return_val);
 629
 630 /**
 631  * purple_marshal_BOOLEAN__POINTER_BOOLEAN:
 632  * @cb: (scope call): Callback this marshaller is designed to invoke
 633  * @args: va_list of arguments to be passed to the closure
 634  * @data: (nullable): Data to be passed to the callback
 635  * @return_val: (nullable): Value to store the callback's return value
 636  *
 637  * A purple marshaller function for use with signals with a pointer and
 638  * boolean argument and returns a boolean.
 639  */
 640 void purple_marshal_BOOLEAN__POINTER_BOOLEAN(
 641                 PurpleCallback cb, va_list args, void *data, void **return_val);
 642
 643 /**
 644  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER:
 645  * @cb: (scope call): Callback this marshaller is designed to invoke
 646  * @args: va_list of arguments to be passed to the closure
 647  * @data: (nullable): Data to be passed to the callback
 648  * @return_val: (nullable): Value to store the callback's return value
 649  *
 650  * A purple marshaller function for use with signals with three pointer
 651  * arguments and returns a boolean.
 652  */
 653 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER(
 654                 PurpleCallback cb, va_list args, void *data, void **return_val);
 655
 656 /**
 657  * purple_marshal_BOOLEAN__POINTER_POINTER_UINT:
 658  * @cb: (scope call): Callback this marshaller is designed to invoke
 659  * @args: va_list of arguments to be passed to the closure
 660  * @data: (nullable): Data to be passed to the callback
 661  * @return_val: (nullable): Value to store the callback's return value
 662  *
 663  * A purple marshaller function for use with signals with two pointer and
 664  * one unsigned integer arguments and returns a boolean.
 665  */
 666 void purple_marshal_BOOLEAN__POINTER_POINTER_UINT(
 667                 PurpleCallback cb, va_list args, void *data, void **return_val);
 668
 669 /**
 670  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT:
 671  * @cb: (scope call): Callback this marshaller is designed to invoke
 672  * @args: va_list of arguments to be passed to the closure
 673  * @data: (nullable): Data to be passed to the callback
 674  * @return_val: (nullable): Value to store the callback's return value
 675  *
 676  * A purple marshaller function for use with signals with three pointer
 677  * and one unsigned integer arguments and returns a boolean.
 678  */
 679 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_UINT(
 680                 PurpleCallback cb, va_list args, void *data, void **return_val);
 681
 682 /**
 683  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER:
 684  * @cb: (scope call): Callback this marshaller is designed to invoke
 685  * @args: va_list of arguments to be passed to the closure
 686  * @data: (nullable): Data to be passed to the callback
 687  * @return_val: (nullable): Value to store the callback's return value
 688  *
 689  * A purple marshaller function for use with signals with four pointer
 690  * arguments and returns a boolean.
 691  */
 692 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER(
 693                 PurpleCallback cb, va_list args, void *data, void **return_val);
 694
 695 /**
 696  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER:
 697  * @cb: (scope call): Callback this marshaller is designed to invoke
 698  * @args: va_list of arguments to be passed to the closure
 699  * @data: (nullable): Data to be passed to the callback
 700  * @return_val: (nullable): Value to store the callback's return value
 701  *
 702  * A purple marshaller function for use with signals with five pointer
 703  * arguments and returns a boolean.
 704  */
 705 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER(
 706                 PurpleCallback cb, va_list args, void *data, void **return_val);
 707
 708 /**
 709  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT:
 710  * @cb: (scope call): Callback this marshaller is designed to invoke
 711  * @args: va_list of arguments to be passed to the closure
 712  * @data: (nullable): Data to be passed to the callback
 713  * @return_val: (nullable): Value to store the callback's return value
 714  *
 715  * A purple marshaller function for use with signals with four pointer
 716  * and one unsigned integer arguments and returns a boolean.
 717  */
 718 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_UINT(
 719                 PurpleCallback cb, va_list args, void *data, void **return_val);
 720
 721 /**
 722  * purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER:
 723  * @cb: (scope call): Callback this marshaller is designed to invoke
 724  * @args: va_list of arguments to be passed to the closure
 725  * @data: (nullable): Data to be passed to the callback
 726  * @return_val: (nullable): Value to store the callback's return value
 727  *
 728  * A purple marshaller function for use with signals with six pointer
 729  * arguments and returns a boolean.
 730  */
 731 void purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER(
 732                 PurpleCallback cb, va_list args, void *data, void **return_val);
 733
 734 /**
 735  * purple_marshal_BOOLEAN__INT_POINTER:
 736  * @cb: (scope call): Callback this marshaller is designed to invoke
 737  * @args: va_list of arguments to be passed to the closure
 738  * @data: (nullable): Data to be passed to the callback
 739  * @return_val: (nullable): Value to store the callback's return value
 740  *
 741  * A purple marshaller function for use with signals with an integer
 742  * and a pointer argument and returns a boolean.
 743  */
 744 void purple_marshal_BOOLEAN__INT_POINTER(
 745                 PurpleCallback cb, va_list args, void *data, void **return_val);
 746
 747 /**
 748  * purple_marshal_POINTER__POINTER:
 749  * @cb: (scope call): Callback this marshaller is designed to invoke
 750  * @args: va_list of arguments to be passed to the closure
 751  * @data: (nullable): Data to be passed to the callback
 752  * @return_val: (nullable): Value to store the callback's return value
 753  *
 754  * A purple marshaller function for use with signals with a pointer
 755  * argument and returns a pointer.
 756  */
 757 void purple_marshal_POINTER__POINTER(
 758                 PurpleCallback cb, va_list args, void *data, void **return_val);
 759
 760 /**
 761  * purple_marshal_POINTER__POINTER_INT:
 762  * @cb: (scope call): Callback this marshaller is designed to invoke
 763  * @args: va_list of arguments to be passed to the closure
 764  * @data: (nullable): Data to be passed to the callback
 765  * @return_val: (nullable): Value to store the callback's return value
 766  *
 767  * A purple marshaller function for use with signals with a pointer and
 768  * an integer argument and returns a pointer.
 769  */
 770 void purple_marshal_POINTER__POINTER_INT(
 771                 PurpleCallback cb, va_list args, void *data, void **return_val);
 772
 773 /**
 774  * purple_marshal_POINTER__POINTER_INT64:
 775  * @cb: (scope call): Callback this marshaller is designed to invoke
 776  * @args: va_list of arguments to be passed to the closure
 777  * @data: (nullable): Data to be passed to the callback
 778  * @return_val: (nullable): Value to store the callback's return value
 779  *
 780  * A purple marshaller function for use with signals with a pointer and
 781  * a 64-bit integer argument and returns a pointer.
 782  */
 783 void purple_marshal_POINTER__POINTER_INT64(
 784                 PurpleCallback cb, va_list args, void *data, void **return_val);
 785
 786 /**
 787  * purple_marshal_POINTER__POINTER_INT_BOOLEAN:
 788  * @cb: (scope call): Callback this marshaller is designed to invoke
 789  * @args: va_list of arguments to be passed to the closure
 790  * @data: (nullable): Data to be passed to the callback
 791  * @return_val: (nullable): Value to store the callback's return value
 792  *
 793  * A purple marshaller function for use with signals with a pointer,
 794  * integer, and boolean argument and returns a pointer.
 795  */
 796 void purple_marshal_POINTER__POINTER_INT_BOOLEAN(
 797                 PurpleCallback cb, va_list args, void *data, void **return_val);
 798
 799 /**
 800  * purple_marshal_POINTER__POINTER_INT64_BOOLEAN:
 801  * @cb: (scope call): Callback this marshaller is designed to invoke
 802  * @args: va_list of arguments to be passed to the closure
 803  * @data: (nullable): Data to be passed to the callback
 804  * @return_val: (nullable): Value to store the callback's return value
 805  *
 806  * A purple marshaller function for use with signals with a pointer,
 807  * 64-bit integer, and boolean argument and returns a pointer.
 808  */
 809 void purple_marshal_POINTER__POINTER_INT64_BOOLEAN(
 810                 PurpleCallback cb, va_list args, void *data, void **return_val);
 811
 812 /**
 813  * purple_marshal_POINTER__POINTER_POINTER_BOOLEAN:
 814  * @cb: (scope call): Callback this marshaller is designed to invoke
 815  * @args: va_list of arguments to be passed to the closure
 816  * @data: (nullable): Data to be passed to the callback
 817  * @return_val: (nullable): Value to store the callback's return value
 818  *
 819  * A purple marshaller function for use with signals with two pointer
 820  * and one boolean arguments and returns a pointer.
 821  */
 822 void purple_marshal_POINTER__POINTER_POINTER_BOOLEAN(
 823                 PurpleCallback cb, va_list args, void *data, void **return_val);
 824
 825 /**
 826  * purple_marshal_POINTER__POINTER_POINTER:
 827  * @cb: (scope call): Callback this marshaller is designed to invoke
 828  * @args: va_list of arguments to be passed to the closure
 829  * @data: (nullable): Data to be passed to the callback
 830  * @return_val: (nullable): Value to store the callback's return value
 831  *
 832  * A purple marshaller function for use with signals with two pointer
 833  * arguments and returns a pointer.
 834  */
 835 void purple_marshal_POINTER__POINTER_POINTER(
 836                 PurpleCallback cb, va_list args, void *data, void **return_val);
 837
 838 G_END_DECLS
 839
 840 #endif /* _PURPLE_SIGNALS_H_ */
 841