gobject/gmarshal.c

   1
   2 #include "config.h"
   3
   4 #include "gobject.h"
   5 #include "genums.h"
   6 #include "gboxed.h"
   7 #include "gvaluetypes.h"
   8
   9 #ifdef G_ENABLE_DEBUG
  10 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
  11 #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
  12 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  13 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  14 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  15 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  16 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  17 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  18 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  19 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  20 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  21 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  22 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  23 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  24 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  25 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  26 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  27 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  28 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
  29 #else /* !G_ENABLE_DEBUG */
  30 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  31  *          Do not access GValues directly in your code. Instead, use the
  32  *          g_value_get_*() functions
  33  */
  34 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  35 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  36 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  37 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  38 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  39 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  40 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  41 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  42 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  43 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
  44 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
  45 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  46 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  47 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  48 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  49 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  50 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  51 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  52 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
  53 #endif /* !G_ENABLE_DEBUG */
  54
  55
  56 /* VOID:VOID (./gmarshal.list:6) */
  57 void
  58 g_cclosure_marshal_VOID__VOID (GClosure     *closure,
  59                                GValue       *return_value G_GNUC_UNUSED,
  60                                guint         n_param_values,
  61                                const GValue *param_values,
  62                                gpointer      invocation_hint G_GNUC_UNUSED,
  63                                gpointer      marshal_data)
  64 {
  65   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     data1,
  66                                            gpointer     data2);
  67   register GMarshalFunc_VOID__VOID callback;
  68   register GCClosure *cc = (GCClosure*) closure;
  69   register gpointer data1, data2;
  70
  71   g_return_if_fail (n_param_values == 1);
  72
  73   if (G_CCLOSURE_SWAP_DATA (closure))
  74     {
  75       data1 = closure->data;
  76       data2 = g_value_peek_pointer (param_values + 0);
  77     }
  78   else
  79     {
  80       data1 = g_value_peek_pointer (param_values + 0);
  81       data2 = closure->data;
  82     }
  83   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
  84
  85   callback (data1,
  86             data2);
  87 }
  88 void
  89 g_cclosure_marshal_VOID__VOIDv (GClosure     *closure,
  90                                 GValue       *return_value,
  91                                 gpointer      instance,
  92                                 va_list       args,
  93                                 gpointer      marshal_data,
  94                                 int           n_params,
  95                                 GType        *param_types)
  96 {
  97   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     instance,
  98                                            gpointer     data);
  99   GCClosure *cc = (GCClosure*) closure;
 100   gpointer data1, data2;
 101   GMarshalFunc_VOID__VOID callback;
 102
 103   if (G_CCLOSURE_SWAP_DATA (closure))
 104     {
 105       data1 = closure->data;
 106       data2 = instance;
 107     }
 108   else
 109     {
 110       data1 = instance;
 111       data2 = closure->data;
 112     }
 113   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
 114
 115   callback (data1,
 116             data2);
 117 }
 118
 119
 120 /* VOID:BOOLEAN (./gmarshal.list:7) */
 121 void
 122 g_cclosure_marshal_VOID__BOOLEAN (GClosure     *closure,
 123                                   GValue       *return_value G_GNUC_UNUSED,
 124                                   guint         n_param_values,
 125                                   const GValue *param_values,
 126                                   gpointer      invocation_hint G_GNUC_UNUSED,
 127                                   gpointer      marshal_data)
 128 {
 129   typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer     data1,
 130                                               gboolean     arg_1,
 131                                               gpointer     data2);
 132   register GMarshalFunc_VOID__BOOLEAN callback;
 133   register GCClosure *cc = (GCClosure*) closure;
 134   register gpointer data1, data2;
 135
 136   g_return_if_fail (n_param_values == 2);
 137
 138   if (G_CCLOSURE_SWAP_DATA (closure))
 139     {
 140       data1 = closure->data;
 141       data2 = g_value_peek_pointer (param_values + 0);
 142     }
 143   else
 144     {
 145       data1 = g_value_peek_pointer (param_values + 0);
 146       data2 = closure->data;
 147     }
 148   callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 149
 150   callback (data1,
 151             g_marshal_value_peek_boolean (param_values + 1),
 152             data2);
 153 }
 154 void
 155 g_cclosure_marshal_VOID__BOOLEANv (GClosure     *closure,
 156                                    GValue       *return_value,
 157                                    gpointer      instance,
 158                                    va_list       args,
 159                                    gpointer      marshal_data,
 160                                    int           n_params,
 161                                    GType        *param_types)
 162 {
 163   typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer     instance,
 164                                               gboolean     arg_0,
 165                                               gpointer     data);
 166   GCClosure *cc = (GCClosure*) closure;
 167   gpointer data1, data2;
 168   GMarshalFunc_VOID__BOOLEAN callback;
 169   gboolean arg0;
 170   va_list args_copy;
 171
 172   va_copy (args_copy, args);
 173   arg0 = (gboolean) va_arg (args_copy, gboolean);
 174   va_end (args_copy);
 175
 176   if (G_CCLOSURE_SWAP_DATA (closure))
 177     {
 178       data1 = closure->data;
 179       data2 = instance;
 180     }
 181   else
 182     {
 183       data1 = instance;
 184       data2 = closure->data;
 185     }
 186   callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
 187
 188   callback (data1,
 189             arg0,
 190             data2);
 191 }
 192
 193
 194 /* VOID:CHAR (./gmarshal.list:8) */
 195 void
 196 g_cclosure_marshal_VOID__CHAR (GClosure     *closure,
 197                                GValue       *return_value G_GNUC_UNUSED,
 198                                guint         n_param_values,
 199                                const GValue *param_values,
 200                                gpointer      invocation_hint G_GNUC_UNUSED,
 201                                gpointer      marshal_data)
 202 {
 203   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     data1,
 204                                            gchar        arg_1,
 205                                            gpointer     data2);
 206   register GMarshalFunc_VOID__CHAR callback;
 207   register GCClosure *cc = (GCClosure*) closure;
 208   register gpointer data1, data2;
 209
 210   g_return_if_fail (n_param_values == 2);
 211
 212   if (G_CCLOSURE_SWAP_DATA (closure))
 213     {
 214       data1 = closure->data;
 215       data2 = g_value_peek_pointer (param_values + 0);
 216     }
 217   else
 218     {
 219       data1 = g_value_peek_pointer (param_values + 0);
 220       data2 = closure->data;
 221     }
 222   callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
 223
 224   callback (data1,
 225             g_marshal_value_peek_char (param_values + 1),
 226             data2);
 227 }
 228 void
 229 g_cclosure_marshal_VOID__CHARv (GClosure     *closure,
 230                                 GValue       *return_value,
 231                                 gpointer      instance,
 232                                 va_list       args,
 233                                 gpointer      marshal_data,
 234                                 int           n_params,
 235                                 GType        *param_types)
 236 {
 237   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     instance,
 238                                            gchar        arg_0,
 239                                            gpointer     data);
 240   GCClosure *cc = (GCClosure*) closure;
 241   gpointer data1, data2;
 242   GMarshalFunc_VOID__CHAR callback;
 243   gchar arg0;
 244   va_list args_copy;
 245
 246   va_copy (args_copy, args);
 247   arg0 = (gchar) va_arg (args_copy, gint);
 248   va_end (args_copy);
 249
 250   if (G_CCLOSURE_SWAP_DATA (closure))
 251     {
 252       data1 = closure->data;
 253       data2 = instance;
 254     }
 255   else
 256     {
 257       data1 = instance;
 258       data2 = closure->data;
 259     }
 260   callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
 261
 262   callback (data1,
 263             arg0,
 264             data2);
 265 }
 266
 267
 268 /* VOID:UCHAR (./gmarshal.list:9) */
 269 void
 270 g_cclosure_marshal_VOID__UCHAR (GClosure     *closure,
 271                                 GValue       *return_value G_GNUC_UNUSED,
 272                                 guint         n_param_values,
 273                                 const GValue *param_values,
 274                                 gpointer      invocation_hint G_GNUC_UNUSED,
 275                                 gpointer      marshal_data)
 276 {
 277   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     data1,
 278                                             guchar       arg_1,
 279                                             gpointer     data2);
 280   register GMarshalFunc_VOID__UCHAR callback;
 281   register GCClosure *cc = (GCClosure*) closure;
 282   register gpointer data1, data2;
 283
 284   g_return_if_fail (n_param_values == 2);
 285
 286   if (G_CCLOSURE_SWAP_DATA (closure))
 287     {
 288       data1 = closure->data;
 289       data2 = g_value_peek_pointer (param_values + 0);
 290     }
 291   else
 292     {
 293       data1 = g_value_peek_pointer (param_values + 0);
 294       data2 = closure->data;
 295     }
 296   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
 297
 298   callback (data1,
 299             g_marshal_value_peek_uchar (param_values + 1),
 300             data2);
 301 }
 302 void
 303 g_cclosure_marshal_VOID__UCHARv (GClosure     *closure,
 304                                  GValue       *return_value,
 305                                  gpointer      instance,
 306                                  va_list       args,
 307                                  gpointer      marshal_data,
 308                                  int           n_params,
 309                                  GType        *param_types)
 310 {
 311   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     instance,
 312                                             guchar       arg_0,
 313                                             gpointer     data);
 314   GCClosure *cc = (GCClosure*) closure;
 315   gpointer data1, data2;
 316   GMarshalFunc_VOID__UCHAR callback;
 317   guchar arg0;
 318   va_list args_copy;
 319
 320   va_copy (args_copy, args);
 321   arg0 = (guchar) va_arg (args_copy, guint);
 322   va_end (args_copy);
 323
 324   if (G_CCLOSURE_SWAP_DATA (closure))
 325     {
 326       data1 = closure->data;
 327       data2 = instance;
 328     }
 329   else
 330     {
 331       data1 = instance;
 332       data2 = closure->data;
 333     }
 334   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
 335
 336   callback (data1,
 337             arg0,
 338             data2);
 339 }
 340
 341
 342 /* VOID:INT (./gmarshal.list:10) */
 343 void
 344 g_cclosure_marshal_VOID__INT (GClosure     *closure,
 345                               GValue       *return_value G_GNUC_UNUSED,
 346                               guint         n_param_values,
 347                               const GValue *param_values,
 348                               gpointer      invocation_hint G_GNUC_UNUSED,
 349                               gpointer      marshal_data)
 350 {
 351   typedef void (*GMarshalFunc_VOID__INT) (gpointer     data1,
 352                                           gint         arg_1,
 353                                           gpointer     data2);
 354   register GMarshalFunc_VOID__INT callback;
 355   register GCClosure *cc = (GCClosure*) closure;
 356   register gpointer data1, data2;
 357
 358   g_return_if_fail (n_param_values == 2);
 359
 360   if (G_CCLOSURE_SWAP_DATA (closure))
 361     {
 362       data1 = closure->data;
 363       data2 = g_value_peek_pointer (param_values + 0);
 364     }
 365   else
 366     {
 367       data1 = g_value_peek_pointer (param_values + 0);
 368       data2 = closure->data;
 369     }
 370   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
 371
 372   callback (data1,
 373             g_marshal_value_peek_int (param_values + 1),
 374             data2);
 375 }
 376 void
 377 g_cclosure_marshal_VOID__INTv (GClosure     *closure,
 378                                GValue       *return_value,
 379                                gpointer      instance,
 380                                va_list       args,
 381                                gpointer      marshal_data,
 382                                int           n_params,
 383                                GType        *param_types)
 384 {
 385   typedef void (*GMarshalFunc_VOID__INT) (gpointer     instance,
 386                                           gint         arg_0,
 387                                           gpointer     data);
 388   GCClosure *cc = (GCClosure*) closure;
 389   gpointer data1, data2;
 390   GMarshalFunc_VOID__INT callback;
 391   gint arg0;
 392   va_list args_copy;
 393
 394   va_copy (args_copy, args);
 395   arg0 = (gint) va_arg (args_copy, gint);
 396   va_end (args_copy);
 397
 398   if (G_CCLOSURE_SWAP_DATA (closure))
 399     {
 400       data1 = closure->data;
 401       data2 = instance;
 402     }
 403   else
 404     {
 405       data1 = instance;
 406       data2 = closure->data;
 407     }
 408   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
 409
 410   callback (data1,
 411             arg0,
 412             data2);
 413 }
 414
 415
 416 /* VOID:UINT (./gmarshal.list:11) */
 417 void
 418 g_cclosure_marshal_VOID__UINT (GClosure     *closure,
 419                                GValue       *return_value G_GNUC_UNUSED,
 420                                guint         n_param_values,
 421                                const GValue *param_values,
 422                                gpointer      invocation_hint G_GNUC_UNUSED,
 423                                gpointer      marshal_data)
 424 {
 425   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     data1,
 426                                            guint        arg_1,
 427                                            gpointer     data2);
 428   register GMarshalFunc_VOID__UINT callback;
 429   register GCClosure *cc = (GCClosure*) closure;
 430   register gpointer data1, data2;
 431
 432   g_return_if_fail (n_param_values == 2);
 433
 434   if (G_CCLOSURE_SWAP_DATA (closure))
 435     {
 436       data1 = closure->data;
 437       data2 = g_value_peek_pointer (param_values + 0);
 438     }
 439   else
 440     {
 441       data1 = g_value_peek_pointer (param_values + 0);
 442       data2 = closure->data;
 443     }
 444   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
 445
 446   callback (data1,
 447             g_marshal_value_peek_uint (param_values + 1),
 448             data2);
 449 }
 450 void
 451 g_cclosure_marshal_VOID__UINTv (GClosure     *closure,
 452                                 GValue       *return_value,
 453                                 gpointer      instance,
 454                                 va_list       args,
 455                                 gpointer      marshal_data,
 456                                 int           n_params,
 457                                 GType        *param_types)
 458 {
 459   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     instance,
 460                                            guint        arg_0,
 461                                            gpointer     data);
 462   GCClosure *cc = (GCClosure*) closure;
 463   gpointer data1, data2;
 464   GMarshalFunc_VOID__UINT callback;
 465   guint arg0;
 466   va_list args_copy;
 467
 468   va_copy (args_copy, args);
 469   arg0 = (guint) va_arg (args_copy, guint);
 470   va_end (args_copy);
 471
 472   if (G_CCLOSURE_SWAP_DATA (closure))
 473     {
 474       data1 = closure->data;
 475       data2 = instance;
 476     }
 477   else
 478     {
 479       data1 = instance;
 480       data2 = closure->data;
 481     }
 482   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
 483
 484   callback (data1,
 485             arg0,
 486             data2);
 487 }
 488
 489
 490 /* VOID:LONG (./gmarshal.list:12) */
 491 void
 492 g_cclosure_marshal_VOID__LONG (GClosure     *closure,
 493                                GValue       *return_value G_GNUC_UNUSED,
 494                                guint         n_param_values,
 495                                const GValue *param_values,
 496                                gpointer      invocation_hint G_GNUC_UNUSED,
 497                                gpointer      marshal_data)
 498 {
 499   typedef void (*GMarshalFunc_VOID__LONG) (gpointer     data1,
 500                                            glong        arg_1,
 501                                            gpointer     data2);
 502   register GMarshalFunc_VOID__LONG callback;
 503   register GCClosure *cc = (GCClosure*) closure;
 504   register gpointer data1, data2;
 505
 506   g_return_if_fail (n_param_values == 2);
 507
 508   if (G_CCLOSURE_SWAP_DATA (closure))
 509     {
 510       data1 = closure->data;
 511       data2 = g_value_peek_pointer (param_values + 0);
 512     }
 513   else
 514     {
 515       data1 = g_value_peek_pointer (param_values + 0);
 516       data2 = closure->data;
 517     }
 518   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
 519
 520   callback (data1,
 521             g_marshal_value_peek_long (param_values + 1),
 522             data2);
 523 }
 524 void
 525 g_cclosure_marshal_VOID__LONGv (GClosure     *closure,
 526                                 GValue       *return_value,
 527                                 gpointer      instance,
 528                                 va_list       args,
 529                                 gpointer      marshal_data,
 530                                 int           n_params,
 531                                 GType        *param_types)
 532 {
 533   typedef void (*GMarshalFunc_VOID__LONG) (gpointer     instance,
 534                                            glong        arg_0,
 535                                            gpointer     data);
 536   GCClosure *cc = (GCClosure*) closure;
 537   gpointer data1, data2;
 538   GMarshalFunc_VOID__LONG callback;
 539   glong arg0;
 540   va_list args_copy;
 541
 542   va_copy (args_copy, args);
 543   arg0 = (glong) va_arg (args_copy, glong);
 544   va_end (args_copy);
 545
 546   if (G_CCLOSURE_SWAP_DATA (closure))
 547     {
 548       data1 = closure->data;
 549       data2 = instance;
 550     }
 551   else
 552     {
 553       data1 = instance;
 554       data2 = closure->data;
 555     }
 556   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
 557
 558   callback (data1,
 559             arg0,
 560             data2);
 561 }
 562
 563
 564 /* VOID:ULONG (./gmarshal.list:13) */
 565 void
 566 g_cclosure_marshal_VOID__ULONG (GClosure     *closure,
 567                                 GValue       *return_value G_GNUC_UNUSED,
 568                                 guint         n_param_values,
 569                                 const GValue *param_values,
 570                                 gpointer      invocation_hint G_GNUC_UNUSED,
 571                                 gpointer      marshal_data)
 572 {
 573   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     data1,
 574                                             gulong       arg_1,
 575                                             gpointer     data2);
 576   register GMarshalFunc_VOID__ULONG callback;
 577   register GCClosure *cc = (GCClosure*) closure;
 578   register gpointer data1, data2;
 579
 580   g_return_if_fail (n_param_values == 2);
 581
 582   if (G_CCLOSURE_SWAP_DATA (closure))
 583     {
 584       data1 = closure->data;
 585       data2 = g_value_peek_pointer (param_values + 0);
 586     }
 587   else
 588     {
 589       data1 = g_value_peek_pointer (param_values + 0);
 590       data2 = closure->data;
 591     }
 592   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
 593
 594   callback (data1,
 595             g_marshal_value_peek_ulong (param_values + 1),
 596             data2);
 597 }
 598 void
 599 g_cclosure_marshal_VOID__ULONGv (GClosure     *closure,
 600                                  GValue       *return_value,
 601                                  gpointer      instance,
 602                                  va_list       args,
 603                                  gpointer      marshal_data,
 604                                  int           n_params,
 605                                  GType        *param_types)
 606 {
 607   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     instance,
 608                                             gulong       arg_0,
 609                                             gpointer     data);
 610   GCClosure *cc = (GCClosure*) closure;
 611   gpointer data1, data2;
 612   GMarshalFunc_VOID__ULONG callback;
 613   gulong arg0;
 614   va_list args_copy;
 615
 616   va_copy (args_copy, args);
 617   arg0 = (gulong) va_arg (args_copy, gulong);
 618   va_end (args_copy);
 619
 620   if (G_CCLOSURE_SWAP_DATA (closure))
 621     {
 622       data1 = closure->data;
 623       data2 = instance;
 624     }
 625   else
 626     {
 627       data1 = instance;
 628       data2 = closure->data;
 629     }
 630   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
 631
 632   callback (data1,
 633             arg0,
 634             data2);
 635 }
 636
 637
 638 /* VOID:ENUM (./gmarshal.list:14) */
 639 void
 640 g_cclosure_marshal_VOID__ENUM (GClosure     *closure,
 641                                GValue       *return_value G_GNUC_UNUSED,
 642                                guint         n_param_values,
 643                                const GValue *param_values,
 644                                gpointer      invocation_hint G_GNUC_UNUSED,
 645                                gpointer      marshal_data)
 646 {
 647   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     data1,
 648                                            gint         arg_1,
 649                                            gpointer     data2);
 650   register GMarshalFunc_VOID__ENUM callback;
 651   register GCClosure *cc = (GCClosure*) closure;
 652   register gpointer data1, data2;
 653
 654   g_return_if_fail (n_param_values == 2);
 655
 656   if (G_CCLOSURE_SWAP_DATA (closure))
 657     {
 658       data1 = closure->data;
 659       data2 = g_value_peek_pointer (param_values + 0);
 660     }
 661   else
 662     {
 663       data1 = g_value_peek_pointer (param_values + 0);
 664       data2 = closure->data;
 665     }
 666   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
 667
 668   callback (data1,
 669             g_marshal_value_peek_enum (param_values + 1),
 670             data2);
 671 }
 672 void
 673 g_cclosure_marshal_VOID__ENUMv (GClosure     *closure,
 674                                 GValue       *return_value,
 675                                 gpointer      instance,
 676                                 va_list       args,
 677                                 gpointer      marshal_data,
 678                                 int           n_params,
 679                                 GType        *param_types)
 680 {
 681   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     instance,
 682                                            gint         arg_0,
 683                                            gpointer     data);
 684   GCClosure *cc = (GCClosure*) closure;
 685   gpointer data1, data2;
 686   GMarshalFunc_VOID__ENUM callback;
 687   gint arg0;
 688   va_list args_copy;
 689
 690   va_copy (args_copy, args);
 691   arg0 = (gint) va_arg (args_copy, gint);
 692   va_end (args_copy);
 693
 694   if (G_CCLOSURE_SWAP_DATA (closure))
 695     {
 696       data1 = closure->data;
 697       data2 = instance;
 698     }
 699   else
 700     {
 701       data1 = instance;
 702       data2 = closure->data;
 703     }
 704   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
 705
 706   callback (data1,
 707             arg0,
 708             data2);
 709 }
 710
 711
 712 /* VOID:FLAGS (./gmarshal.list:15) */
 713 void
 714 g_cclosure_marshal_VOID__FLAGS (GClosure     *closure,
 715                                 GValue       *return_value G_GNUC_UNUSED,
 716                                 guint         n_param_values,
 717                                 const GValue *param_values,
 718                                 gpointer      invocation_hint G_GNUC_UNUSED,
 719                                 gpointer      marshal_data)
 720 {
 721   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     data1,
 722                                             guint        arg_1,
 723                                             gpointer     data2);
 724   register GMarshalFunc_VOID__FLAGS callback;
 725   register GCClosure *cc = (GCClosure*) closure;
 726   register gpointer data1, data2;
 727
 728   g_return_if_fail (n_param_values == 2);
 729
 730   if (G_CCLOSURE_SWAP_DATA (closure))
 731     {
 732       data1 = closure->data;
 733       data2 = g_value_peek_pointer (param_values + 0);
 734     }
 735   else
 736     {
 737       data1 = g_value_peek_pointer (param_values + 0);
 738       data2 = closure->data;
 739     }
 740   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
 741
 742   callback (data1,
 743             g_marshal_value_peek_flags (param_values + 1),
 744             data2);
 745 }
 746 void
 747 g_cclosure_marshal_VOID__FLAGSv (GClosure     *closure,
 748                                  GValue       *return_value,
 749                                  gpointer      instance,
 750                                  va_list       args,
 751                                  gpointer      marshal_data,
 752                                  int           n_params,
 753                                  GType        *param_types)
 754 {
 755   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     instance,
 756                                             guint        arg_0,
 757                                             gpointer     data);
 758   GCClosure *cc = (GCClosure*) closure;
 759   gpointer data1, data2;
 760   GMarshalFunc_VOID__FLAGS callback;
 761   guint arg0;
 762   va_list args_copy;
 763
 764   va_copy (args_copy, args);
 765   arg0 = (guint) va_arg (args_copy, guint);
 766   va_end (args_copy);
 767
 768   if (G_CCLOSURE_SWAP_DATA (closure))
 769     {
 770       data1 = closure->data;
 771       data2 = instance;
 772     }
 773   else
 774     {
 775       data1 = instance;
 776       data2 = closure->data;
 777     }
 778   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
 779
 780   callback (data1,
 781             arg0,
 782             data2);
 783 }
 784
 785
 786 /* VOID:FLOAT (./gmarshal.list:16) */
 787 void
 788 g_cclosure_marshal_VOID__FLOAT (GClosure     *closure,
 789                                 GValue       *return_value G_GNUC_UNUSED,
 790                                 guint         n_param_values,
 791                                 const GValue *param_values,
 792                                 gpointer      invocation_hint G_GNUC_UNUSED,
 793                                 gpointer      marshal_data)
 794 {
 795   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     data1,
 796                                             gfloat       arg_1,
 797                                             gpointer     data2);
 798   register GMarshalFunc_VOID__FLOAT callback;
 799   register GCClosure *cc = (GCClosure*) closure;
 800   register gpointer data1, data2;
 801
 802   g_return_if_fail (n_param_values == 2);
 803
 804   if (G_CCLOSURE_SWAP_DATA (closure))
 805     {
 806       data1 = closure->data;
 807       data2 = g_value_peek_pointer (param_values + 0);
 808     }
 809   else
 810     {
 811       data1 = g_value_peek_pointer (param_values + 0);
 812       data2 = closure->data;
 813     }
 814   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
 815
 816   callback (data1,
 817             g_marshal_value_peek_float (param_values + 1),
 818             data2);
 819 }
 820 void
 821 g_cclosure_marshal_VOID__FLOATv (GClosure     *closure,
 822                                  GValue       *return_value,
 823                                  gpointer      instance,
 824                                  va_list       args,
 825                                  gpointer      marshal_data,
 826                                  int           n_params,
 827                                  GType        *param_types)
 828 {
 829   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     instance,
 830                                             gfloat       arg_0,
 831                                             gpointer     data);
 832   GCClosure *cc = (GCClosure*) closure;
 833   gpointer data1, data2;
 834   GMarshalFunc_VOID__FLOAT callback;
 835   gfloat arg0;
 836   va_list args_copy;
 837
 838   va_copy (args_copy, args);
 839   arg0 = (gfloat) va_arg (args_copy, gdouble);
 840   va_end (args_copy);
 841
 842   if (G_CCLOSURE_SWAP_DATA (closure))
 843     {
 844       data1 = closure->data;
 845       data2 = instance;
 846     }
 847   else
 848     {
 849       data1 = instance;
 850       data2 = closure->data;
 851     }
 852   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
 853
 854   callback (data1,
 855             arg0,
 856             data2);
 857 }
 858
 859
 860 /* VOID:DOUBLE (./gmarshal.list:17) */
 861 void
 862 g_cclosure_marshal_VOID__DOUBLE (GClosure     *closure,
 863                                  GValue       *return_value G_GNUC_UNUSED,
 864                                  guint         n_param_values,
 865                                  const GValue *param_values,
 866                                  gpointer      invocation_hint G_GNUC_UNUSED,
 867                                  gpointer      marshal_data)
 868 {
 869   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     data1,
 870                                              gdouble      arg_1,
 871                                              gpointer     data2);
 872   register GMarshalFunc_VOID__DOUBLE callback;
 873   register GCClosure *cc = (GCClosure*) closure;
 874   register gpointer data1, data2;
 875
 876   g_return_if_fail (n_param_values == 2);
 877
 878   if (G_CCLOSURE_SWAP_DATA (closure))
 879     {
 880       data1 = closure->data;
 881       data2 = g_value_peek_pointer (param_values + 0);
 882     }
 883   else
 884     {
 885       data1 = g_value_peek_pointer (param_values + 0);
 886       data2 = closure->data;
 887     }
 888   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
 889
 890   callback (data1,
 891             g_marshal_value_peek_double (param_values + 1),
 892             data2);
 893 }
 894 void
 895 g_cclosure_marshal_VOID__DOUBLEv (GClosure     *closure,
 896                                   GValue       *return_value,
 897                                   gpointer      instance,
 898                                   va_list       args,
 899                                   gpointer      marshal_data,
 900                                   int           n_params,
 901                                   GType        *param_types)
 902 {
 903   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     instance,
 904                                              gdouble      arg_0,
 905                                              gpointer     data);
 906   GCClosure *cc = (GCClosure*) closure;
 907   gpointer data1, data2;
 908   GMarshalFunc_VOID__DOUBLE callback;
 909   gdouble arg0;
 910   va_list args_copy;
 911
 912   va_copy (args_copy, args);
 913   arg0 = (gdouble) va_arg (args_copy, gdouble);
 914   va_end (args_copy);
 915
 916   if (G_CCLOSURE_SWAP_DATA (closure))
 917     {
 918       data1 = closure->data;
 919       data2 = instance;
 920     }
 921   else
 922     {
 923       data1 = instance;
 924       data2 = closure->data;
 925     }
 926   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
 927
 928   callback (data1,
 929             arg0,
 930             data2);
 931 }
 932
 933
 934 /* VOID:STRING (./gmarshal.list:18) */
 935 void
 936 g_cclosure_marshal_VOID__STRING (GClosure     *closure,
 937                                  GValue       *return_value G_GNUC_UNUSED,
 938                                  guint         n_param_values,
 939                                  const GValue *param_values,
 940                                  gpointer      invocation_hint G_GNUC_UNUSED,
 941                                  gpointer      marshal_data)
 942 {
 943   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     data1,
 944                                              gpointer     arg_1,
 945                                              gpointer     data2);
 946   register GMarshalFunc_VOID__STRING callback;
 947   register GCClosure *cc = (GCClosure*) closure;
 948   register gpointer data1, data2;
 949
 950   g_return_if_fail (n_param_values == 2);
 951
 952   if (G_CCLOSURE_SWAP_DATA (closure))
 953     {
 954       data1 = closure->data;
 955       data2 = g_value_peek_pointer (param_values + 0);
 956     }
 957   else
 958     {
 959       data1 = g_value_peek_pointer (param_values + 0);
 960       data2 = closure->data;
 961     }
 962   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
 963
 964   callback (data1,
 965             g_marshal_value_peek_string (param_values + 1),
 966             data2);
 967 }
 968 void
 969 g_cclosure_marshal_VOID__STRINGv (GClosure     *closure,
 970                                   GValue       *return_value,
 971                                   gpointer      instance,
 972                                   va_list       args,
 973                                   gpointer      marshal_data,
 974                                   int           n_params,
 975                                   GType        *param_types)
 976 {
 977   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     instance,
 978                                              gpointer     arg_0,
 979                                              gpointer     data);
 980   GCClosure *cc = (GCClosure*) closure;
 981   gpointer data1, data2;
 982   GMarshalFunc_VOID__STRING callback;
 983   gpointer arg0;
 984   va_list args_copy;
 985
 986   va_copy (args_copy, args);
 987   arg0 = (gpointer) va_arg (args_copy, gpointer);
 988   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
 989     arg0 = g_strdup (arg0);
 990   va_end (args_copy);
 991
 992   if (G_CCLOSURE_SWAP_DATA (closure))
 993     {
 994       data1 = closure->data;
 995       data2 = instance;
 996     }
 997   else
 998     {
 999       data1 = instance;
1000       data2 = closure->data;
1001     }
1002   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
1003
1004   callback (data1,
1005             arg0,
1006             data2);
1007   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1008     g_free (arg0);
1009 }
1010
1011
1012 /* VOID:PARAM (./gmarshal.list:19) */
1013 void
1014 g_cclosure_marshal_VOID__PARAM (GClosure     *closure,
1015                                 GValue       *return_value G_GNUC_UNUSED,
1016                                 guint         n_param_values,
1017                                 const GValue *param_values,
1018                                 gpointer      invocation_hint G_GNUC_UNUSED,
1019                                 gpointer      marshal_data)
1020 {
1021   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     data1,
1022                                             gpointer     arg_1,
1023                                             gpointer     data2);
1024   register GMarshalFunc_VOID__PARAM callback;
1025   register GCClosure *cc = (GCClosure*) closure;
1026   register gpointer data1, data2;
1027
1028   g_return_if_fail (n_param_values == 2);
1029
1030   if (G_CCLOSURE_SWAP_DATA (closure))
1031     {
1032       data1 = closure->data;
1033       data2 = g_value_peek_pointer (param_values + 0);
1034     }
1035   else
1036     {
1037       data1 = g_value_peek_pointer (param_values + 0);
1038       data2 = closure->data;
1039     }
1040   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
1041
1042   callback (data1,
1043             g_marshal_value_peek_param (param_values + 1),
1044             data2);
1045 }
1046 void
1047 g_cclosure_marshal_VOID__PARAMv (GClosure     *closure,
1048                                  GValue       *return_value,
1049                                  gpointer      instance,
1050                                  va_list       args,
1051                                  gpointer      marshal_data,
1052                                  int           n_params,
1053                                  GType        *param_types)
1054 {
1055   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     instance,
1056                                             gpointer     arg_0,
1057                                             gpointer     data);
1058   GCClosure *cc = (GCClosure*) closure;
1059   gpointer data1, data2;
1060   GMarshalFunc_VOID__PARAM callback;
1061   gpointer arg0;
1062   va_list args_copy;
1063
1064   va_copy (args_copy, args);
1065   arg0 = (gpointer) va_arg (args_copy, gpointer);
1066   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1067     arg0 = g_param_spec_ref (arg0);
1068   va_end (args_copy);
1069
1070   if (G_CCLOSURE_SWAP_DATA (closure))
1071     {
1072       data1 = closure->data;
1073       data2 = instance;
1074     }
1075   else
1076     {
1077       data1 = instance;
1078       data2 = closure->data;
1079     }
1080   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
1081
1082   callback (data1,
1083             arg0,
1084             data2);
1085   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1086     g_param_spec_unref (arg0);
1087 }
1088
1089
1090 /* VOID:BOXED (./gmarshal.list:20) */
1091 void
1092 g_cclosure_marshal_VOID__BOXED (GClosure     *closure,
1093                                 GValue       *return_value G_GNUC_UNUSED,
1094                                 guint         n_param_values,
1095                                 const GValue *param_values,
1096                                 gpointer      invocation_hint G_GNUC_UNUSED,
1097                                 gpointer      marshal_data)
1098 {
1099   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     data1,
1100                                             gpointer     arg_1,
1101                                             gpointer     data2);
1102   register GMarshalFunc_VOID__BOXED callback;
1103   register GCClosure *cc = (GCClosure*) closure;
1104   register gpointer data1, data2;
1105
1106   g_return_if_fail (n_param_values == 2);
1107
1108   if (G_CCLOSURE_SWAP_DATA (closure))
1109     {
1110       data1 = closure->data;
1111       data2 = g_value_peek_pointer (param_values + 0);
1112     }
1113   else
1114     {
1115       data1 = g_value_peek_pointer (param_values + 0);
1116       data2 = closure->data;
1117     }
1118   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
1119
1120   callback (data1,
1121             g_marshal_value_peek_boxed (param_values + 1),
1122             data2);
1123 }
1124 void
1125 g_cclosure_marshal_VOID__BOXEDv (GClosure     *closure,
1126                                  GValue       *return_value,
1127                                  gpointer      instance,
1128                                  va_list       args,
1129                                  gpointer      marshal_data,
1130                                  int           n_params,
1131                                  GType        *param_types)
1132 {
1133   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     instance,
1134                                             gpointer     arg_0,
1135                                             gpointer     data);
1136   GCClosure *cc = (GCClosure*) closure;
1137   gpointer data1, data2;
1138   GMarshalFunc_VOID__BOXED callback;
1139   gpointer arg0;
1140   va_list args_copy;
1141
1142   va_copy (args_copy, args);
1143   arg0 = (gpointer) va_arg (args_copy, gpointer);
1144   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1145     arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1146   va_end (args_copy);
1147
1148   if (G_CCLOSURE_SWAP_DATA (closure))
1149     {
1150       data1 = closure->data;
1151       data2 = instance;
1152     }
1153   else
1154     {
1155       data1 = instance;
1156       data2 = closure->data;
1157     }
1158   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
1159
1160   callback (data1,
1161             arg0,
1162             data2);
1163   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1164     g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1165 }
1166
1167
1168 /* VOID:POINTER (./gmarshal.list:21) */
1169 void
1170 g_cclosure_marshal_VOID__POINTER (GClosure     *closure,
1171                                   GValue       *return_value G_GNUC_UNUSED,
1172                                   guint         n_param_values,
1173                                   const GValue *param_values,
1174                                   gpointer      invocation_hint G_GNUC_UNUSED,
1175                                   gpointer      marshal_data)
1176 {
1177   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     data1,
1178                                               gpointer     arg_1,
1179                                               gpointer     data2);
1180   register GMarshalFunc_VOID__POINTER callback;
1181   register GCClosure *cc = (GCClosure*) closure;
1182   register gpointer data1, data2;
1183
1184   g_return_if_fail (n_param_values == 2);
1185
1186   if (G_CCLOSURE_SWAP_DATA (closure))
1187     {
1188       data1 = closure->data;
1189       data2 = g_value_peek_pointer (param_values + 0);
1190     }
1191   else
1192     {
1193       data1 = g_value_peek_pointer (param_values + 0);
1194       data2 = closure->data;
1195     }
1196   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
1197
1198   callback (data1,
1199             g_marshal_value_peek_pointer (param_values + 1),
1200             data2);
1201 }
1202 void
1203 g_cclosure_marshal_VOID__POINTERv (GClosure     *closure,
1204                                    GValue       *return_value,
1205                                    gpointer      instance,
1206                                    va_list       args,
1207                                    gpointer      marshal_data,
1208                                    int           n_params,
1209                                    GType        *param_types)
1210 {
1211   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     instance,
1212                                               gpointer     arg_0,
1213                                               gpointer     data);
1214   GCClosure *cc = (GCClosure*) closure;
1215   gpointer data1, data2;
1216   GMarshalFunc_VOID__POINTER callback;
1217   gpointer arg0;
1218   va_list args_copy;
1219
1220   va_copy (args_copy, args);
1221   arg0 = (gpointer) va_arg (args_copy, gpointer);
1222   va_end (args_copy);
1223
1224   if (G_CCLOSURE_SWAP_DATA (closure))
1225     {
1226       data1 = closure->data;
1227       data2 = instance;
1228     }
1229   else
1230     {
1231       data1 = instance;
1232       data2 = closure->data;
1233     }
1234   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
1235
1236   callback (data1,
1237             arg0,
1238             data2);
1239 }
1240
1241
1242 /* VOID:OBJECT (./gmarshal.list:22) */
1243 void
1244 g_cclosure_marshal_VOID__OBJECT (GClosure     *closure,
1245                                  GValue       *return_value G_GNUC_UNUSED,
1246                                  guint         n_param_values,
1247                                  const GValue *param_values,
1248                                  gpointer      invocation_hint G_GNUC_UNUSED,
1249                                  gpointer      marshal_data)
1250 {
1251   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     data1,
1252                                              gpointer     arg_1,
1253                                              gpointer     data2);
1254   register GMarshalFunc_VOID__OBJECT callback;
1255   register GCClosure *cc = (GCClosure*) closure;
1256   register gpointer data1, data2;
1257
1258   g_return_if_fail (n_param_values == 2);
1259
1260   if (G_CCLOSURE_SWAP_DATA (closure))
1261     {
1262       data1 = closure->data;
1263       data2 = g_value_peek_pointer (param_values + 0);
1264     }
1265   else
1266     {
1267       data1 = g_value_peek_pointer (param_values + 0);
1268       data2 = closure->data;
1269     }
1270   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
1271
1272   callback (data1,
1273             g_marshal_value_peek_object (param_values + 1),
1274             data2);
1275 }
1276 void
1277 g_cclosure_marshal_VOID__OBJECTv (GClosure     *closure,
1278                                   GValue       *return_value,
1279                                   gpointer      instance,
1280                                   va_list       args,
1281                                   gpointer      marshal_data,
1282                                   int           n_params,
1283                                   GType        *param_types)
1284 {
1285   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     instance,
1286                                              gpointer     arg_0,
1287                                              gpointer     data);
1288   GCClosure *cc = (GCClosure*) closure;
1289   gpointer data1, data2;
1290   GMarshalFunc_VOID__OBJECT callback;
1291   gpointer arg0;
1292   va_list args_copy;
1293
1294   va_copy (args_copy, args);
1295   arg0 = (gpointer) va_arg (args_copy, gpointer);
1296   if (arg0 != NULL)
1297     arg0 = g_object_ref (arg0);
1298   va_end (args_copy);
1299
1300   if (G_CCLOSURE_SWAP_DATA (closure))
1301     {
1302       data1 = closure->data;
1303       data2 = instance;
1304     }
1305   else
1306     {
1307       data1 = instance;
1308       data2 = closure->data;
1309     }
1310   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
1311
1312   callback (data1,
1313             arg0,
1314             data2);
1315   if (arg0 != NULL)
1316     g_object_unref (arg0);
1317 }
1318
1319
1320 /* VOID:VARIANT (./gmarshal.list:23) */
1321 void
1322 g_cclosure_marshal_VOID__VARIANT (GClosure     *closure,
1323                                   GValue       *return_value G_GNUC_UNUSED,
1324                                   guint         n_param_values,
1325                                   const GValue *param_values,
1326                                   gpointer      invocation_hint G_GNUC_UNUSED,
1327                                   gpointer      marshal_data)
1328 {
1329   typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer     data1,
1330                                               gpointer     arg_1,
1331                                               gpointer     data2);
1332   register GMarshalFunc_VOID__VARIANT callback;
1333   register GCClosure *cc = (GCClosure*) closure;
1334   register gpointer data1, data2;
1335
1336   g_return_if_fail (n_param_values == 2);
1337
1338   if (G_CCLOSURE_SWAP_DATA (closure))
1339     {
1340       data1 = closure->data;
1341       data2 = g_value_peek_pointer (param_values + 0);
1342     }
1343   else
1344     {
1345       data1 = g_value_peek_pointer (param_values + 0);
1346       data2 = closure->data;
1347     }
1348   callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
1349
1350   callback (data1,
1351             g_marshal_value_peek_variant (param_values + 1),
1352             data2);
1353 }
1354 void
1355 g_cclosure_marshal_VOID__VARIANTv (GClosure     *closure,
1356                                    GValue       *return_value,
1357                                    gpointer      instance,
1358                                    va_list       args,
1359                                    gpointer      marshal_data,
1360                                    int           n_params,
1361                                    GType        *param_types)
1362 {
1363   typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer     instance,
1364                                               gpointer     arg_0,
1365                                               gpointer     data);
1366   GCClosure *cc = (GCClosure*) closure;
1367   gpointer data1, data2;
1368   GMarshalFunc_VOID__VARIANT callback;
1369   gpointer arg0;
1370   va_list args_copy;
1371
1372   va_copy (args_copy, args);
1373   arg0 = (gpointer) va_arg (args_copy, gpointer);
1374   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1375     arg0 = g_variant_ref_sink (arg0);
1376   va_end (args_copy);
1377
1378   if (G_CCLOSURE_SWAP_DATA (closure))
1379     {
1380       data1 = closure->data;
1381       data2 = instance;
1382     }
1383   else
1384     {
1385       data1 = instance;
1386       data2 = closure->data;
1387     }
1388   callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
1389
1390   callback (data1,
1391             arg0,
1392             data2);
1393   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1394     g_variant_unref (arg0);
1395 }
1396
1397
1398 /* VOID:UINT,POINTER (./gmarshal.list:26) */
1399 void
1400 g_cclosure_marshal_VOID__UINT_POINTER (GClosure     *closure,
1401                                        GValue       *return_value G_GNUC_UNUSED,
1402                                        guint         n_param_values,
1403                                        const GValue *param_values,
1404                                        gpointer      invocation_hint G_GNUC_UNUSED,
1405                                        gpointer      marshal_data)
1406 {
1407   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     data1,
1408                                                    guint        arg_1,
1409                                                    gpointer     arg_2,
1410                                                    gpointer     data2);
1411   register GMarshalFunc_VOID__UINT_POINTER callback;
1412   register GCClosure *cc = (GCClosure*) closure;
1413   register gpointer data1, data2;
1414
1415   g_return_if_fail (n_param_values == 3);
1416
1417   if (G_CCLOSURE_SWAP_DATA (closure))
1418     {
1419       data1 = closure->data;
1420       data2 = g_value_peek_pointer (param_values + 0);
1421     }
1422   else
1423     {
1424       data1 = g_value_peek_pointer (param_values + 0);
1425       data2 = closure->data;
1426     }
1427   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
1428
1429   callback (data1,
1430             g_marshal_value_peek_uint (param_values + 1),
1431             g_marshal_value_peek_pointer (param_values + 2),
1432             data2);
1433 }
1434 void
1435 g_cclosure_marshal_VOID__UINT_POINTERv (GClosure     *closure,
1436                                         GValue       *return_value,
1437                                         gpointer      instance,
1438                                         va_list       args,
1439                                         gpointer      marshal_data,
1440                                         int           n_params,
1441                                         GType        *param_types)
1442 {
1443   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     instance,
1444                                                    guint        arg_0,
1445                                                    gpointer     arg_1,
1446                                                    gpointer     data);
1447   GCClosure *cc = (GCClosure*) closure;
1448   gpointer data1, data2;
1449   GMarshalFunc_VOID__UINT_POINTER callback;
1450   guint arg0;
1451   gpointer arg1;
1452   va_list args_copy;
1453
1454   va_copy (args_copy, args);
1455   arg0 = (guint) va_arg (args_copy, guint);
1456   arg1 = (gpointer) va_arg (args_copy, gpointer);
1457   va_end (args_copy);
1458
1459   if (G_CCLOSURE_SWAP_DATA (closure))
1460     {
1461       data1 = closure->data;
1462       data2 = instance;
1463     }
1464   else
1465     {
1466       data1 = instance;
1467       data2 = closure->data;
1468     }
1469   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
1470
1471   callback (data1,
1472             arg0,
1473             arg1,
1474             data2);
1475 }
1476
1477
1478 /* BOOL:FLAGS (./gmarshal.list:27) */
1479 void
1480 g_cclosure_marshal_BOOLEAN__FLAGS (GClosure     *closure,
1481                                    GValue       *return_value G_GNUC_UNUSED,
1482                                    guint         n_param_values,
1483                                    const GValue *param_values,
1484                                    gpointer      invocation_hint G_GNUC_UNUSED,
1485                                    gpointer      marshal_data)
1486 {
1487   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     data1,
1488                                                    guint        arg_1,
1489                                                    gpointer     data2);
1490   register GMarshalFunc_BOOLEAN__FLAGS callback;
1491   register GCClosure *cc = (GCClosure*) closure;
1492   register gpointer data1, data2;
1493   gboolean v_return;
1494
1495   g_return_if_fail (return_value != NULL);
1496   g_return_if_fail (n_param_values == 2);
1497
1498   if (G_CCLOSURE_SWAP_DATA (closure))
1499     {
1500       data1 = closure->data;
1501       data2 = g_value_peek_pointer (param_values + 0);
1502     }
1503   else
1504     {
1505       data1 = g_value_peek_pointer (param_values + 0);
1506       data2 = closure->data;
1507     }
1508   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
1509
1510   v_return = callback (data1,
1511                        g_marshal_value_peek_flags (param_values + 1),
1512                        data2);
1513
1514   g_value_set_boolean (return_value, v_return);
1515 }
1516 void
1517 g_cclosure_marshal_BOOLEAN__FLAGSv (GClosure     *closure,
1518                                     GValue       *return_value,
1519                                     gpointer      instance,
1520                                     va_list       args,
1521                                     gpointer      marshal_data,
1522                                     int           n_params,
1523                                     GType        *param_types)
1524 {
1525   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     instance,
1526                                                    guint        arg_0,
1527                                                    gpointer     data);
1528   GCClosure *cc = (GCClosure*) closure;
1529   gpointer data1, data2;
1530   GMarshalFunc_BOOLEAN__FLAGS callback;
1531   guint arg0;
1532   va_list args_copy;
1533   gboolean v_return;
1534
1535   g_return_if_fail (return_value != NULL);
1536
1537   va_copy (args_copy, args);
1538   arg0 = (guint) va_arg (args_copy, guint);
1539   va_end (args_copy);
1540
1541   if (G_CCLOSURE_SWAP_DATA (closure))
1542     {
1543       data1 = closure->data;
1544       data2 = instance;
1545     }
1546   else
1547     {
1548       data1 = instance;
1549       data2 = closure->data;
1550     }
1551   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
1552
1553   v_return = callback (data1,
1554                        arg0,
1555                        data2);
1556
1557   g_value_set_boolean (return_value, v_return);
1558 }
1559
1560
1561 /* STRING:OBJECT,POINTER (./gmarshal.list:28) */
1562 void
1563 g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure     *closure,
1564                                            GValue       *return_value G_GNUC_UNUSED,
1565                                            guint         n_param_values,
1566                                            const GValue *param_values,
1567                                            gpointer      invocation_hint G_GNUC_UNUSED,
1568                                            gpointer      marshal_data)
1569 {
1570   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     data1,
1571                                                          gpointer     arg_1,
1572                                                          gpointer     arg_2,
1573                                                          gpointer     data2);
1574   register GMarshalFunc_STRING__OBJECT_POINTER callback;
1575   register GCClosure *cc = (GCClosure*) closure;
1576   register gpointer data1, data2;
1577   gchar* v_return;
1578
1579   g_return_if_fail (return_value != NULL);
1580   g_return_if_fail (n_param_values == 3);
1581
1582   if (G_CCLOSURE_SWAP_DATA (closure))
1583     {
1584       data1 = closure->data;
1585       data2 = g_value_peek_pointer (param_values + 0);
1586     }
1587   else
1588     {
1589       data1 = g_value_peek_pointer (param_values + 0);
1590       data2 = closure->data;
1591     }
1592   callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
1593
1594   v_return = callback (data1,
1595                        g_marshal_value_peek_object (param_values + 1),
1596                        g_marshal_value_peek_pointer (param_values + 2),
1597                        data2);
1598
1599   g_value_take_string (return_value, v_return);
1600 }
1601 void
1602 g_cclosure_marshal_STRING__OBJECT_POINTERv (GClosure     *closure,
1603                                             GValue       *return_value,
1604                                             gpointer      instance,
1605                                             va_list       args,
1606                                             gpointer      marshal_data,
1607                                             int           n_params,
1608                                             GType        *param_types)
1609 {
1610   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     instance,
1611                                                          gpointer     arg_0,
1612                                                          gpointer     arg_1,
1613                                                          gpointer     data);
1614   GCClosure *cc = (GCClosure*) closure;
1615   gpointer data1, data2;
1616   GMarshalFunc_STRING__OBJECT_POINTER callback;
1617   gpointer arg0;
1618   gpointer arg1;
1619   va_list args_copy;
1620   gchar* v_return;
1621
1622   g_return_if_fail (return_value != NULL);
1623
1624   va_copy (args_copy, args);
1625   arg0 = (gpointer) va_arg (args_copy, gpointer);
1626   if (arg0 != NULL)
1627     arg0 = g_object_ref (arg0);
1628   arg1 = (gpointer) va_arg (args_copy, gpointer);
1629   va_end (args_copy);
1630
1631   if (G_CCLOSURE_SWAP_DATA (closure))
1632     {
1633       data1 = closure->data;
1634       data2 = instance;
1635     }
1636   else
1637     {
1638       data1 = instance;
1639       data2 = closure->data;
1640     }
1641   callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
1642
1643   v_return = callback (data1,
1644                        arg0,
1645                        arg1,
1646                        data2);
1647   if (arg0 != NULL)
1648     g_object_unref (arg0);
1649
1650   g_value_take_string (return_value, v_return);
1651 }
1652
1653
1654 /* BOOL:BOXED,BOXED (./gmarshal.list:29) */
1655 void
1656 g_cclosure_marshal_BOOLEAN__BOXED_BOXED (GClosure     *closure,
1657                                          GValue       *return_value G_GNUC_UNUSED,
1658                                          guint         n_param_values,
1659                                          const GValue *param_values,
1660                                          gpointer      invocation_hint G_GNUC_UNUSED,
1661                                          gpointer      marshal_data)
1662 {
1663   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     data1,
1664                                                          gpointer     arg_1,
1665                                                          gpointer     arg_2,
1666                                                          gpointer     data2);
1667   register GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
1668   register GCClosure *cc = (GCClosure*) closure;
1669   register gpointer data1, data2;
1670   gboolean v_return;
1671
1672   g_return_if_fail (return_value != NULL);
1673   g_return_if_fail (n_param_values == 3);
1674
1675   if (G_CCLOSURE_SWAP_DATA (closure))
1676     {
1677       data1 = closure->data;
1678       data2 = g_value_peek_pointer (param_values + 0);
1679     }
1680   else
1681     {
1682       data1 = g_value_peek_pointer (param_values + 0);
1683       data2 = closure->data;
1684     }
1685   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1686
1687   v_return = callback (data1,
1688                        g_marshal_value_peek_boxed (param_values + 1),
1689                        g_marshal_value_peek_boxed (param_values + 2),
1690                        data2);
1691
1692   g_value_set_boolean (return_value, v_return);
1693 }
1694 void
1695 g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv (GClosure     *closure,
1696                                           GValue       *return_value,
1697                                           gpointer      instance,
1698                                           va_list       args,
1699                                           gpointer      marshal_data,
1700                                           int           n_params,
1701                                           GType        *param_types)
1702 {
1703   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     instance,
1704                                                          gpointer     arg_0,
1705                                                          gpointer     arg_1,
1706                                                          gpointer     data);
1707   GCClosure *cc = (GCClosure*) closure;
1708   gpointer data1, data2;
1709   GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
1710   gpointer arg0;
1711   gpointer arg1;
1712   va_list args_copy;
1713   gboolean v_return;
1714
1715   g_return_if_fail (return_value != NULL);
1716
1717   va_copy (args_copy, args);
1718   arg0 = (gpointer) va_arg (args_copy, gpointer);
1719   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1720     arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1721   arg1 = (gpointer) va_arg (args_copy, gpointer);
1722   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1723     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1724   va_end (args_copy);
1725
1726   if (G_CCLOSURE_SWAP_DATA (closure))
1727     {
1728       data1 = closure->data;
1729       data2 = instance;
1730     }
1731   else
1732     {
1733       data1 = instance;
1734       data2 = closure->data;
1735     }
1736   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
1737
1738   v_return = callback (data1,
1739                        arg0,
1740                        arg1,
1741                        data2);
1742   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1743     g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
1744   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1745     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1746
1747   g_value_set_boolean (return_value, v_return);
1748 }
1749
1750