gio/gmarshal-internal.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  *
   3  * SPDX-License-Identifier: LGPL-2.1-or-later
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "config.h"
  20
  21 #include <glib-object.h>
  22 #include "gmarshal-internal.h"
  23
  24 #ifdef G_ENABLE_DEBUG
  25 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
  26 #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
  27 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  28 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  29 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  30 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  31 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  32 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  33 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  34 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  35 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  36 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  37 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  38 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  39 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  40 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  41 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  42 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  43 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
  44 #else /* !G_ENABLE_DEBUG */
  45 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  46  *          Do not access GValues directly in your code. Instead, use the
  47  *          g_value_get_*() functions
  48  */
  49 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  50 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  51 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  52 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  53 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  54 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  55 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  56 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  57 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  58 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
  59 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
  60 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  61 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  62 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  63 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  64 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  65 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  66 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  67 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
  68 #endif /* !G_ENABLE_DEBUG */
  69
  70 /* BOOLEAN:OBJECT */
  71 void
  72 _g_cclosure_marshal_BOOLEAN__OBJECT (GClosure     *closure,
  73                                      GValue       *return_value,
  74                                      guint         n_param_values,
  75                                      const GValue *param_values,
  76                                      gpointer      invocation_hint G_GNUC_UNUSED,
  77                                      gpointer      marshal_data)
  78 {
  79   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
  80                                                     gpointer arg1,
  81                                                     gpointer data2);
  82   GCClosure *cc = (GCClosure *) closure;
  83   gpointer data1, data2;
  84   GMarshalFunc_BOOLEAN__OBJECT callback;
  85   gboolean v_return;
  86
  87   g_return_if_fail (return_value != NULL);
  88   g_return_if_fail (n_param_values == 2);
  89
  90   if (G_CCLOSURE_SWAP_DATA (closure))
  91     {
  92       data1 = closure->data;
  93       data2 = g_value_peek_pointer (param_values + 0);
  94     }
  95   else
  96     {
  97       data1 = g_value_peek_pointer (param_values + 0);
  98       data2 = closure->data;
  99     }
 100   callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
 101
 102   v_return = callback (data1,
 103                        g_marshal_value_peek_object (param_values + 1),
 104                        data2);
 105
 106   g_value_set_boolean (return_value, v_return);
 107 }
 108
 109 void
 110 _g_cclosure_marshal_BOOLEAN__OBJECTv (GClosure *closure,
 111                                       GValue   *return_value,
 112                                       gpointer  instance,
 113                                       va_list   args,
 114                                       gpointer  marshal_data,
 115                                       int       n_params,
 116                                       GType    *param_types)
 117 {
 118   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer data1,
 119                                                     gpointer arg1,
 120                                                     gpointer data2);
 121   GCClosure *cc = (GCClosure *) closure;
 122   gpointer data1, data2;
 123   GMarshalFunc_BOOLEAN__OBJECT callback;
 124   gboolean v_return;
 125   gpointer arg0;
 126   va_list args_copy;
 127
 128   G_VA_COPY (args_copy, args);
 129   arg0 = (gpointer) va_arg (args_copy, gpointer);
 130   if (arg0 != NULL)
 131     arg0 = g_object_ref (arg0);
 132   va_end (args_copy);
 133
 134   g_return_if_fail (return_value != NULL);
 135
 136   if (G_CCLOSURE_SWAP_DATA (closure))
 137     {
 138       data1 = closure->data;
 139       data2 = instance;
 140     }
 141   else
 142     {
 143       data1 = instance;
 144       data2 = closure->data;
 145     }
 146   callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
 147
 148   v_return = callback (data1,
 149                        arg0,
 150                        data2);
 151   if (arg0 != NULL)
 152     g_object_unref (arg0);
 153
 154   g_value_set_boolean (return_value, v_return);
 155 }
 156
 157 /* BOOLEAN:OBJECT,FLAGS */
 158 void
 159 _g_cclosure_marshal_BOOLEAN__OBJECT_FLAGS (GClosure     *closure,
 160                                            GValue       *return_value,
 161                                            guint         n_param_values,
 162                                            const GValue *param_values,
 163                                            gpointer      invocation_hint G_GNUC_UNUSED,
 164                                            gpointer      marshal_data)
 165 {
 166   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (gpointer data1,
 167                                                           gpointer arg1,
 168                                                           guint arg2,
 169                                                           gpointer data2);
 170   GCClosure *cc = (GCClosure *) closure;
 171   gpointer data1, data2;
 172   GMarshalFunc_BOOLEAN__OBJECT_FLAGS callback;
 173   gboolean v_return;
 174
 175   g_return_if_fail (return_value != NULL);
 176   g_return_if_fail (n_param_values == 3);
 177
 178   if (G_CCLOSURE_SWAP_DATA (closure))
 179     {
 180       data1 = closure->data;
 181       data2 = g_value_peek_pointer (param_values + 0);
 182     }
 183   else
 184     {
 185       data1 = g_value_peek_pointer (param_values + 0);
 186       data2 = closure->data;
 187     }
 188   callback = (GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
 189
 190   v_return = callback (data1,
 191                        g_marshal_value_peek_object (param_values + 1),
 192                        g_marshal_value_peek_flags (param_values + 2),
 193                        data2);
 194
 195   g_value_set_boolean (return_value, v_return);
 196 }
 197
 198 void
 199 _g_cclosure_marshal_BOOLEAN__OBJECT_FLAGSv (GClosure *closure,
 200                                             GValue   *return_value,
 201                                             gpointer  instance,
 202                                             va_list   args,
 203                                             gpointer  marshal_data,
 204                                             int       n_params,
 205                                             GType    *param_types)
 206 {
 207   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (gpointer data1,
 208                                                           gpointer arg1,
 209                                                           guint arg2,
 210                                                           gpointer data2);
 211   GCClosure *cc = (GCClosure *) closure;
 212   gpointer data1, data2;
 213   GMarshalFunc_BOOLEAN__OBJECT_FLAGS callback;
 214   gboolean v_return;
 215   gpointer arg0;
 216   guint arg1;
 217   va_list args_copy;
 218
 219   G_VA_COPY (args_copy, args);
 220   arg0 = (gpointer) va_arg (args_copy, gpointer);
 221   if (arg0 != NULL)
 222     arg0 = g_object_ref (arg0);
 223   arg1 = (guint) va_arg (args_copy, guint);
 224   va_end (args_copy);
 225
 226   g_return_if_fail (return_value != NULL);
 227
 228   if (G_CCLOSURE_SWAP_DATA (closure))
 229     {
 230       data1 = closure->data;
 231       data2 = instance;
 232     }
 233   else
 234     {
 235       data1 = instance;
 236       data2 = closure->data;
 237     }
 238   callback = (GMarshalFunc_BOOLEAN__OBJECT_FLAGS) (marshal_data ? marshal_data : cc->callback);
 239
 240   v_return = callback (data1,
 241                        arg0,
 242                        arg1,
 243                        data2);
 244   if (arg0 != NULL)
 245     g_object_unref (arg0);
 246
 247   g_value_set_boolean (return_value, v_return);
 248 }
 249
 250 /* BOOLEAN:OBJECT,OBJECT */
 251 void
 252 _g_cclosure_marshal_BOOLEAN__OBJECT_OBJECT (GClosure     *closure,
 253                                             GValue       *return_value,
 254                                             guint         n_param_values,
 255                                             const GValue *param_values,
 256                                             gpointer      invocation_hint G_GNUC_UNUSED,
 257                                             gpointer      marshal_data)
 258 {
 259   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (gpointer data1,
 260                                                            gpointer arg1,
 261                                                            gpointer arg2,
 262                                                            gpointer data2);
 263   GCClosure *cc = (GCClosure *) closure;
 264   gpointer data1, data2;
 265   GMarshalFunc_BOOLEAN__OBJECT_OBJECT callback;
 266   gboolean v_return;
 267
 268   g_return_if_fail (return_value != NULL);
 269   g_return_if_fail (n_param_values == 3);
 270
 271   if (G_CCLOSURE_SWAP_DATA (closure))
 272     {
 273       data1 = closure->data;
 274       data2 = g_value_peek_pointer (param_values + 0);
 275     }
 276   else
 277     {
 278       data1 = g_value_peek_pointer (param_values + 0);
 279       data2 = closure->data;
 280     }
 281   callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 282
 283   v_return = callback (data1,
 284                        g_marshal_value_peek_object (param_values + 1),
 285                        g_marshal_value_peek_object (param_values + 2),
 286                        data2);
 287
 288   g_value_set_boolean (return_value, v_return);
 289 }
 290
 291 void
 292 _g_cclosure_marshal_BOOLEAN__OBJECT_OBJECTv (GClosure *closure,
 293                                              GValue   *return_value,
 294                                              gpointer  instance,
 295                                              va_list   args,
 296                                              gpointer  marshal_data,
 297                                              int       n_params,
 298                                              GType    *param_types)
 299 {
 300   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (gpointer data1,
 301                                                            gpointer arg1,
 302                                                            gpointer arg2,
 303                                                            gpointer data2);
 304   GCClosure *cc = (GCClosure *) closure;
 305   gpointer data1, data2;
 306   GMarshalFunc_BOOLEAN__OBJECT_OBJECT callback;
 307   gboolean v_return;
 308   gpointer arg0;
 309   gpointer arg1;
 310   va_list args_copy;
 311
 312   G_VA_COPY (args_copy, args);
 313   arg0 = (gpointer) va_arg (args_copy, gpointer);
 314   if (arg0 != NULL)
 315     arg0 = g_object_ref (arg0);
 316   arg1 = (gpointer) va_arg (args_copy, gpointer);
 317   if (arg1 != NULL)
 318     arg1 = g_object_ref (arg1);
 319   va_end (args_copy);
 320
 321   g_return_if_fail (return_value != NULL);
 322
 323   if (G_CCLOSURE_SWAP_DATA (closure))
 324     {
 325       data1 = closure->data;
 326       data2 = instance;
 327     }
 328   else
 329     {
 330       data1 = instance;
 331       data2 = closure->data;
 332     }
 333   callback = (GMarshalFunc_BOOLEAN__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 334
 335   v_return = callback (data1,
 336                        arg0,
 337                        arg1,
 338                        data2);
 339   if (arg0 != NULL)
 340     g_object_unref (arg0);
 341   if (arg1 != NULL)
 342     g_object_unref (arg1);
 343
 344   g_value_set_boolean (return_value, v_return);
 345 }
 346
 347 /* BOOLEAN:POINTER,INT */
 348 void
 349 _g_cclosure_marshal_BOOLEAN__POINTER_INT (GClosure     *closure,
 350                                           GValue       *return_value,
 351                                           guint         n_param_values,
 352                                           const GValue *param_values,
 353                                           gpointer      invocation_hint G_GNUC_UNUSED,
 354                                           gpointer      marshal_data)
 355 {
 356   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT) (gpointer data1,
 357                                                          gpointer arg1,
 358                                                          gint arg2,
 359                                                          gpointer data2);
 360   GCClosure *cc = (GCClosure *) closure;
 361   gpointer data1, data2;
 362   GMarshalFunc_BOOLEAN__POINTER_INT callback;
 363   gboolean v_return;
 364
 365   g_return_if_fail (return_value != NULL);
 366   g_return_if_fail (n_param_values == 3);
 367
 368   if (G_CCLOSURE_SWAP_DATA (closure))
 369     {
 370       data1 = closure->data;
 371       data2 = g_value_peek_pointer (param_values + 0);
 372     }
 373   else
 374     {
 375       data1 = g_value_peek_pointer (param_values + 0);
 376       data2 = closure->data;
 377     }
 378   callback = (GMarshalFunc_BOOLEAN__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
 379
 380   v_return = callback (data1,
 381                        g_marshal_value_peek_pointer (param_values + 1),
 382                        g_marshal_value_peek_int (param_values + 2),
 383                        data2);
 384
 385   g_value_set_boolean (return_value, v_return);
 386 }
 387
 388 void
 389 _g_cclosure_marshal_BOOLEAN__POINTER_INTv (GClosure *closure,
 390                                            GValue   *return_value,
 391                                            gpointer  instance,
 392                                            va_list   args,
 393                                            gpointer  marshal_data,
 394                                            int       n_params,
 395                                            GType    *param_types)
 396 {
 397   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT) (gpointer data1,
 398                                                          gpointer arg1,
 399                                                          gint arg2,
 400                                                          gpointer data2);
 401   GCClosure *cc = (GCClosure *) closure;
 402   gpointer data1, data2;
 403   GMarshalFunc_BOOLEAN__POINTER_INT callback;
 404   gboolean v_return;
 405   gpointer arg0;
 406   gint arg1;
 407   va_list args_copy;
 408
 409   G_VA_COPY (args_copy, args);
 410   arg0 = (gpointer) va_arg (args_copy, gpointer);
 411   arg1 = (gint) va_arg (args_copy, gint);
 412   va_end (args_copy);
 413
 414   g_return_if_fail (return_value != NULL);
 415
 416   if (G_CCLOSURE_SWAP_DATA (closure))
 417     {
 418       data1 = closure->data;
 419       data2 = instance;
 420     }
 421   else
 422     {
 423       data1 = instance;
 424       data2 = closure->data;
 425     }
 426   callback = (GMarshalFunc_BOOLEAN__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
 427
 428   v_return = callback (data1,
 429                        arg0,
 430                        arg1,
 431                        data2);
 432
 433
 434   g_value_set_boolean (return_value, v_return);
 435 }
 436
 437 /* BOOLEAN:STRING */
 438 void
 439 _g_cclosure_marshal_BOOLEAN__STRING (GClosure     *closure,
 440                                      GValue       *return_value,
 441                                      guint         n_param_values,
 442                                      const GValue *param_values,
 443                                      gpointer      invocation_hint G_GNUC_UNUSED,
 444                                      gpointer      marshal_data)
 445 {
 446   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
 447                                                     gpointer arg1,
 448                                                     gpointer data2);
 449   GCClosure *cc = (GCClosure *) closure;
 450   gpointer data1, data2;
 451   GMarshalFunc_BOOLEAN__STRING callback;
 452   gboolean v_return;
 453
 454   g_return_if_fail (return_value != NULL);
 455   g_return_if_fail (n_param_values == 2);
 456
 457   if (G_CCLOSURE_SWAP_DATA (closure))
 458     {
 459       data1 = closure->data;
 460       data2 = g_value_peek_pointer (param_values + 0);
 461     }
 462   else
 463     {
 464       data1 = g_value_peek_pointer (param_values + 0);
 465       data2 = closure->data;
 466     }
 467   callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
 468
 469   v_return = callback (data1,
 470                        g_marshal_value_peek_string (param_values + 1),
 471                        data2);
 472
 473   g_value_set_boolean (return_value, v_return);
 474 }
 475
 476 void
 477 _g_cclosure_marshal_BOOLEAN__STRINGv (GClosure *closure,
 478                                       GValue   *return_value,
 479                                       gpointer  instance,
 480                                       va_list   args,
 481                                       gpointer  marshal_data,
 482                                       int       n_params,
 483                                       GType    *param_types)
 484 {
 485   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
 486                                                     gpointer arg1,
 487                                                     gpointer data2);
 488   GCClosure *cc = (GCClosure *) closure;
 489   gpointer data1, data2;
 490   GMarshalFunc_BOOLEAN__STRING callback;
 491   gboolean v_return;
 492   gpointer arg0;
 493   va_list args_copy;
 494
 495   g_return_if_fail (return_value != NULL);
 496
 497   G_VA_COPY (args_copy, args);
 498   arg0 = (gpointer) va_arg (args_copy, gpointer);
 499   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
 500     arg0 = g_strdup (arg0);
 501   va_end (args_copy);
 502
 503   if (G_CCLOSURE_SWAP_DATA (closure))
 504     {
 505       data1 = closure->data;
 506       data2 = instance;
 507     }
 508   else
 509     {
 510       data1 = instance;
 511       data2 = closure->data;
 512     }
 513   callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
 514
 515   v_return = callback (data1,
 516                        arg0,
 517                        data2);
 518   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
 519     g_free (arg0);
 520
 521   g_value_set_boolean (return_value, v_return);
 522 }
 523
 524 /* BOOLEAN:UINT */
 525 void
 526 _g_cclosure_marshal_BOOLEAN__UINT (GClosure     *closure,
 527                                    GValue       *return_value,
 528                                    guint         n_param_values,
 529                                    const GValue *param_values,
 530                                    gpointer      invocation_hint G_GNUC_UNUSED,
 531                                    gpointer      marshal_data)
 532 {
 533   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
 534                                                   guint arg1,
 535                                                   gpointer data2);
 536   GCClosure *cc = (GCClosure *) closure;
 537   gpointer data1, data2;
 538   GMarshalFunc_BOOLEAN__UINT callback;
 539   gboolean v_return;
 540
 541   g_return_if_fail (return_value != NULL);
 542   g_return_if_fail (n_param_values == 2);
 543
 544   if (G_CCLOSURE_SWAP_DATA (closure))
 545     {
 546       data1 = closure->data;
 547       data2 = g_value_peek_pointer (param_values + 0);
 548     }
 549   else
 550     {
 551       data1 = g_value_peek_pointer (param_values + 0);
 552       data2 = closure->data;
 553     }
 554   callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
 555
 556   v_return = callback (data1,
 557                        g_marshal_value_peek_uint (param_values + 1),
 558                        data2);
 559
 560   g_value_set_boolean (return_value, v_return);
 561 }
 562
 563 void
 564 _g_cclosure_marshal_BOOLEAN__UINTv (GClosure *closure,
 565                                     GValue   *return_value,
 566                                     gpointer  instance,
 567                                     va_list   args,
 568                                     gpointer  marshal_data,
 569                                     int       n_params,
 570                                     GType    *param_types)
 571 {
 572   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer data1,
 573                                                   guint arg1,
 574                                                   gpointer data2);
 575   GCClosure *cc = (GCClosure *) closure;
 576   gpointer data1, data2;
 577   GMarshalFunc_BOOLEAN__UINT callback;
 578   gboolean v_return;
 579   guint arg0;
 580   va_list args_copy;
 581
 582   G_VA_COPY (args_copy, args);
 583   arg0 = (guint) va_arg (args_copy, guint);
 584   va_end (args_copy);
 585
 586   g_return_if_fail (return_value != NULL);
 587
 588   if (G_CCLOSURE_SWAP_DATA (closure))
 589     {
 590       data1 = closure->data;
 591       data2 = instance;
 592     }
 593   else
 594     {
 595       data1 = instance;
 596       data2 = closure->data;
 597     }
 598   callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
 599
 600   v_return = callback (data1,
 601                        arg0,
 602                        data2);
 603
 604
 605   g_value_set_boolean (return_value, v_return);
 606 }
 607
 608 /* BOOLEAN:VOID */
 609 void
 610 _g_cclosure_marshal_BOOLEAN__VOID (GClosure     *closure,
 611                                    GValue       *return_value,
 612                                    guint         n_param_values,
 613                                    const GValue *param_values,
 614                                    gpointer      invocation_hint G_GNUC_UNUSED,
 615                                    gpointer      marshal_data)
 616 {
 617   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
 618                                                   gpointer data2);
 619   GCClosure *cc = (GCClosure *) closure;
 620   gpointer data1, data2;
 621   GMarshalFunc_BOOLEAN__VOID callback;
 622   gboolean v_return;
 623
 624   g_return_if_fail (return_value != NULL);
 625   g_return_if_fail (n_param_values == 1);
 626
 627   if (G_CCLOSURE_SWAP_DATA (closure))
 628     {
 629       data1 = closure->data;
 630       data2 = g_value_peek_pointer (param_values + 0);
 631     }
 632   else
 633     {
 634       data1 = g_value_peek_pointer (param_values + 0);
 635       data2 = closure->data;
 636     }
 637   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 638
 639   v_return = callback (data1,
 640                        data2);
 641
 642   g_value_set_boolean (return_value, v_return);
 643 }
 644
 645 void
 646 _g_cclosure_marshal_BOOLEAN__VOIDv (GClosure *closure,
 647                                     GValue   *return_value,
 648                                     gpointer  instance,
 649                                     va_list   args,
 650                                     gpointer  marshal_data,
 651                                     int       n_params,
 652                                     GType    *param_types)
 653 {
 654   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
 655                                                   gpointer data2);
 656   GCClosure *cc = (GCClosure *) closure;
 657   gpointer data1, data2;
 658   GMarshalFunc_BOOLEAN__VOID callback;
 659   gboolean v_return;
 660
 661   g_return_if_fail (return_value != NULL);
 662
 663   if (G_CCLOSURE_SWAP_DATA (closure))
 664     {
 665       data1 = closure->data;
 666       data2 = instance;
 667     }
 668   else
 669     {
 670       data1 = instance;
 671       data2 = closure->data;
 672     }
 673   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 674
 675   v_return = callback (data1,
 676                        data2);
 677
 678
 679   g_value_set_boolean (return_value, v_return);
 680 }
 681
 682 /* INT:BOXED */
 683 void
 684 _g_cclosure_marshal_INT__BOXED (GClosure     *closure,
 685                                 GValue       *return_value,
 686                                 guint         n_param_values,
 687                                 const GValue *param_values,
 688                                 gpointer      invocation_hint G_GNUC_UNUSED,
 689                                 gpointer      marshal_data)
 690 {
 691   typedef gint (*GMarshalFunc_INT__BOXED) (gpointer data1,
 692                                            gpointer arg1,
 693                                            gpointer data2);
 694   GCClosure *cc = (GCClosure *) closure;
 695   gpointer data1, data2;
 696   GMarshalFunc_INT__BOXED callback;
 697   gint v_return;
 698
 699   g_return_if_fail (return_value != NULL);
 700   g_return_if_fail (n_param_values == 2);
 701
 702   if (G_CCLOSURE_SWAP_DATA (closure))
 703     {
 704       data1 = closure->data;
 705       data2 = g_value_peek_pointer (param_values + 0);
 706     }
 707   else
 708     {
 709       data1 = g_value_peek_pointer (param_values + 0);
 710       data2 = closure->data;
 711     }
 712   callback = (GMarshalFunc_INT__BOXED) (marshal_data ? marshal_data : cc->callback);
 713
 714   v_return = callback (data1,
 715                        g_marshal_value_peek_boxed (param_values + 1),
 716                        data2);
 717
 718   g_value_set_int (return_value, v_return);
 719 }
 720
 721 void
 722 _g_cclosure_marshal_INT__BOXEDv (GClosure *closure,
 723                                  GValue   *return_value,
 724                                  gpointer  instance,
 725                                  va_list   args,
 726                                  gpointer  marshal_data,
 727                                  int       n_params,
 728                                  GType    *param_types)
 729 {
 730   typedef gint (*GMarshalFunc_INT__BOXED) (gpointer data1,
 731                                            gpointer arg1,
 732                                            gpointer data2);
 733   GCClosure *cc = (GCClosure *) closure;
 734   gpointer data1, data2;
 735   GMarshalFunc_INT__BOXED callback;
 736   gint v_return;
 737   gpointer arg0;
 738   va_list args_copy;
 739
 740   G_VA_COPY (args_copy, args);
 741   arg0 = (gpointer) va_arg (args_copy, gpointer);
 742   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
 743     arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
 744   va_end (args_copy);
 745
 746   g_return_if_fail (return_value != NULL);
 747
 748   if (G_CCLOSURE_SWAP_DATA (closure))
 749     {
 750       data1 = closure->data;
 751       data2 = instance;
 752     }
 753   else
 754     {
 755       data1 = instance;
 756       data2 = closure->data;
 757     }
 758   callback = (GMarshalFunc_INT__BOXED) (marshal_data ? marshal_data : cc->callback);
 759
 760   v_return = callback (data1,
 761                        arg0,
 762                        data2);
 763   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
 764     g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
 765
 766   g_value_set_int (return_value, v_return);
 767 }
 768
 769 /* INT:OBJECT */
 770 void
 771 _g_cclosure_marshal_INT__OBJECT (GClosure     *closure,
 772                                  GValue       *return_value,
 773                                  guint         n_param_values,
 774                                  const GValue *param_values,
 775                                  gpointer      invocation_hint G_GNUC_UNUSED,
 776                                  gpointer      marshal_data)
 777 {
 778   typedef gint (*GMarshalFunc_INT__OBJECT) (gpointer data1,
 779                                             gpointer arg1,
 780                                             gpointer data2);
 781   GCClosure *cc = (GCClosure *) closure;
 782   gpointer data1, data2;
 783   GMarshalFunc_INT__OBJECT callback;
 784   gint v_return;
 785
 786   g_return_if_fail (return_value != NULL);
 787   g_return_if_fail (n_param_values == 2);
 788
 789   if (G_CCLOSURE_SWAP_DATA (closure))
 790     {
 791       data1 = closure->data;
 792       data2 = g_value_peek_pointer (param_values + 0);
 793     }
 794   else
 795     {
 796       data1 = g_value_peek_pointer (param_values + 0);
 797       data2 = closure->data;
 798     }
 799   callback = (GMarshalFunc_INT__OBJECT) (marshal_data ? marshal_data : cc->callback);
 800
 801   v_return = callback (data1,
 802                        g_marshal_value_peek_object (param_values + 1),
 803                        data2);
 804
 805   g_value_set_int (return_value, v_return);
 806 }
 807
 808 void
 809 _g_cclosure_marshal_INT__OBJECTv (GClosure *closure,
 810                                   GValue   *return_value,
 811                                   gpointer  instance,
 812                                   va_list   args,
 813                                   gpointer  marshal_data,
 814                                   int       n_params,
 815                                   GType    *param_types)
 816 {
 817   typedef gint (*GMarshalFunc_INT__OBJECT) (gpointer data1,
 818                                             gpointer arg1,
 819                                             gpointer data2);
 820   GCClosure *cc = (GCClosure *) closure;
 821   gpointer data1, data2;
 822   GMarshalFunc_INT__OBJECT callback;
 823   gint v_return;
 824   gpointer arg0;
 825   va_list args_copy;
 826
 827   G_VA_COPY (args_copy, args);
 828   arg0 = (gpointer) va_arg (args_copy, gpointer);
 829   if (arg0 != NULL)
 830     arg0 = g_object_ref (arg0);
 831   va_end (args_copy);
 832
 833   g_return_if_fail (return_value != NULL);
 834
 835   if (G_CCLOSURE_SWAP_DATA (closure))
 836     {
 837       data1 = closure->data;
 838       data2 = instance;
 839     }
 840   else
 841     {
 842       data1 = instance;
 843       data2 = closure->data;
 844     }
 845   callback = (GMarshalFunc_INT__OBJECT) (marshal_data ? marshal_data : cc->callback);
 846
 847   v_return = callback (data1,
 848                        arg0,
 849                        data2);
 850   if (arg0 != NULL)
 851     g_object_unref (arg0);
 852
 853   g_value_set_int (return_value, v_return);
 854 }
 855
 856 /* VOID:BOOLEAN,BOXED */
 857 void
 858 _g_cclosure_marshal_VOID__BOOLEAN_BOXED (GClosure     *closure,
 859                                          GValue       *return_value G_GNUC_UNUSED,
 860                                          guint         n_param_values,
 861                                          const GValue *param_values,
 862                                          gpointer      invocation_hint G_GNUC_UNUSED,
 863                                          gpointer      marshal_data)
 864 {
 865   typedef void (*GMarshalFunc_VOID__BOOLEAN_BOXED) (gpointer data1,
 866                                                     gboolean arg1,
 867                                                     gpointer arg2,
 868                                                     gpointer data2);
 869   GCClosure *cc = (GCClosure *) closure;
 870   gpointer data1, data2;
 871   GMarshalFunc_VOID__BOOLEAN_BOXED callback;
 872
 873   g_return_if_fail (n_param_values == 3);
 874
 875   if (G_CCLOSURE_SWAP_DATA (closure))
 876     {
 877       data1 = closure->data;
 878       data2 = g_value_peek_pointer (param_values + 0);
 879     }
 880   else
 881     {
 882       data1 = g_value_peek_pointer (param_values + 0);
 883       data2 = closure->data;
 884     }
 885   callback = (GMarshalFunc_VOID__BOOLEAN_BOXED) (marshal_data ? marshal_data : cc->callback);
 886
 887   callback (data1,
 888             g_marshal_value_peek_boolean (param_values + 1),
 889             g_marshal_value_peek_boxed (param_values + 2),
 890             data2);
 891 }
 892
 893 void
 894 _g_cclosure_marshal_VOID__BOOLEAN_BOXEDv (GClosure *closure,
 895                                           GValue   *return_value G_GNUC_UNUSED,
 896                                           gpointer  instance,
 897                                           va_list   args,
 898                                           gpointer  marshal_data,
 899                                           int       n_params,
 900                                           GType    *param_types)
 901 {
 902   typedef void (*GMarshalFunc_VOID__BOOLEAN_BOXED) (gpointer data1,
 903                                                     gboolean arg1,
 904                                                     gpointer arg2,
 905                                                     gpointer data2);
 906   GCClosure *cc = (GCClosure *) closure;
 907   gpointer data1, data2;
 908   GMarshalFunc_VOID__BOOLEAN_BOXED callback;
 909   gboolean arg0;
 910   gpointer arg1;
 911   va_list args_copy;
 912
 913   G_VA_COPY (args_copy, args);
 914   arg0 = (gboolean) va_arg (args_copy, gboolean);
 915   arg1 = (gpointer) va_arg (args_copy, gpointer);
 916   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
 917     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
 918   va_end (args_copy);
 919
 920
 921   if (G_CCLOSURE_SWAP_DATA (closure))
 922     {
 923       data1 = closure->data;
 924       data2 = instance;
 925     }
 926   else
 927     {
 928       data1 = instance;
 929       data2 = closure->data;
 930     }
 931   callback = (GMarshalFunc_VOID__BOOLEAN_BOXED) (marshal_data ? marshal_data : cc->callback);
 932
 933   callback (data1,
 934             arg0,
 935             arg1,
 936             data2);
 937   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
 938     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
 939 }
 940
 941 /* VOID:ENUM,OBJECT */
 942 void
 943 _g_cclosure_marshal_VOID__ENUM_OBJECT (GClosure     *closure,
 944                                        GValue       *return_value G_GNUC_UNUSED,
 945                                        guint         n_param_values,
 946                                        const GValue *param_values,
 947                                        gpointer      invocation_hint G_GNUC_UNUSED,
 948                                        gpointer      marshal_data)
 949 {
 950   typedef void (*GMarshalFunc_VOID__ENUM_OBJECT) (gpointer data1,
 951                                                   gint arg1,
 952                                                   gpointer arg2,
 953                                                   gpointer data2);
 954   GCClosure *cc = (GCClosure *) closure;
 955   gpointer data1, data2;
 956   GMarshalFunc_VOID__ENUM_OBJECT callback;
 957
 958   g_return_if_fail (n_param_values == 3);
 959
 960   if (G_CCLOSURE_SWAP_DATA (closure))
 961     {
 962       data1 = closure->data;
 963       data2 = g_value_peek_pointer (param_values + 0);
 964     }
 965   else
 966     {
 967       data1 = g_value_peek_pointer (param_values + 0);
 968       data2 = closure->data;
 969     }
 970   callback = (GMarshalFunc_VOID__ENUM_OBJECT) (marshal_data ? marshal_data : cc->callback);
 971
 972   callback (data1,
 973             g_marshal_value_peek_enum (param_values + 1),
 974             g_marshal_value_peek_object (param_values + 2),
 975             data2);
 976 }
 977
 978 void
 979 _g_cclosure_marshal_VOID__ENUM_OBJECTv (GClosure *closure,
 980                                         GValue   *return_value G_GNUC_UNUSED,
 981                                         gpointer  instance,
 982                                         va_list   args,
 983                                         gpointer  marshal_data,
 984                                         int       n_params,
 985                                         GType    *param_types)
 986 {
 987   typedef void (*GMarshalFunc_VOID__ENUM_OBJECT) (gpointer data1,
 988                                                   gint arg1,
 989                                                   gpointer arg2,
 990                                                   gpointer data2);
 991   GCClosure *cc = (GCClosure *) closure;
 992   gpointer data1, data2;
 993   GMarshalFunc_VOID__ENUM_OBJECT callback;
 994   gint arg0;
 995   gpointer arg1;
 996   va_list args_copy;
 997
 998   G_VA_COPY (args_copy, args);
 999   arg0 = (gint) va_arg (args_copy, gint);
1000   arg1 = (gpointer) va_arg (args_copy, gpointer);
1001   if (arg1 != NULL)
1002     arg1 = g_object_ref (arg1);
1003   va_end (args_copy);
1004
1005
1006   if (G_CCLOSURE_SWAP_DATA (closure))
1007     {
1008       data1 = closure->data;
1009       data2 = instance;
1010     }
1011   else
1012     {
1013       data1 = instance;
1014       data2 = closure->data;
1015     }
1016   callback = (GMarshalFunc_VOID__ENUM_OBJECT) (marshal_data ? marshal_data : cc->callback);
1017
1018   callback (data1,
1019             arg0,
1020             arg1,
1021             data2);
1022   if (arg1 != NULL)
1023     g_object_unref (arg1);
1024 }
1025
1026 /* VOID:ENUM,OBJECT,OBJECT */
1027 void
1028 _g_cclosure_marshal_VOID__ENUM_OBJECT_OBJECT (GClosure     *closure,
1029                                               GValue       *return_value G_GNUC_UNUSED,
1030                                               guint         n_param_values,
1031                                               const GValue *param_values,
1032                                               gpointer      invocation_hint G_GNUC_UNUSED,
1033                                               gpointer      marshal_data)
1034 {
1035   typedef void (*GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (gpointer data1,
1036                                                          gint arg1,
1037                                                          gpointer arg2,
1038                                                          gpointer arg3,
1039                                                          gpointer data2);
1040   GCClosure *cc = (GCClosure *) closure;
1041   gpointer data1, data2;
1042   GMarshalFunc_VOID__ENUM_OBJECT_OBJECT callback;
1043
1044   g_return_if_fail (n_param_values == 4);
1045
1046   if (G_CCLOSURE_SWAP_DATA (closure))
1047     {
1048       data1 = closure->data;
1049       data2 = g_value_peek_pointer (param_values + 0);
1050     }
1051   else
1052     {
1053       data1 = g_value_peek_pointer (param_values + 0);
1054       data2 = closure->data;
1055     }
1056   callback = (GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1057
1058   callback (data1,
1059             g_marshal_value_peek_enum (param_values + 1),
1060             g_marshal_value_peek_object (param_values + 2),
1061             g_marshal_value_peek_object (param_values + 3),
1062             data2);
1063 }
1064
1065 void
1066 _g_cclosure_marshal_VOID__ENUM_OBJECT_OBJECTv (GClosure *closure,
1067                                                GValue   *return_value G_GNUC_UNUSED,
1068                                                gpointer  instance,
1069                                                va_list   args,
1070                                                gpointer  marshal_data,
1071                                                int       n_params,
1072                                                GType    *param_types)
1073 {
1074   typedef void (*GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (gpointer data1,
1075                                                          gint arg1,
1076                                                          gpointer arg2,
1077                                                          gpointer arg3,
1078                                                          gpointer data2);
1079   GCClosure *cc = (GCClosure *) closure;
1080   gpointer data1, data2;
1081   GMarshalFunc_VOID__ENUM_OBJECT_OBJECT callback;
1082   gint arg0;
1083   gpointer arg1;
1084   gpointer arg2;
1085   va_list args_copy;
1086
1087   G_VA_COPY (args_copy, args);
1088   arg0 = (gint) va_arg (args_copy, gint);
1089   arg1 = (gpointer) va_arg (args_copy, gpointer);
1090   if (arg1 != NULL)
1091     arg1 = g_object_ref (arg1);
1092   arg2 = (gpointer) va_arg (args_copy, gpointer);
1093   if (arg2 != NULL)
1094     arg2 = g_object_ref (arg2);
1095   va_end (args_copy);
1096
1097
1098   if (G_CCLOSURE_SWAP_DATA (closure))
1099     {
1100       data1 = closure->data;
1101       data2 = instance;
1102     }
1103   else
1104     {
1105       data1 = instance;
1106       data2 = closure->data;
1107     }
1108   callback = (GMarshalFunc_VOID__ENUM_OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1109
1110   callback (data1,
1111             arg0,
1112             arg1,
1113             arg2,
1114             data2);
1115   if (arg1 != NULL)
1116     g_object_unref (arg1);
1117   if (arg2 != NULL)
1118     g_object_unref (arg2);
1119 }
1120
1121 /* VOID:INT,INT,INT */
1122 void
1123 _g_cclosure_marshal_VOID__INT_INT_INT (GClosure     *closure,
1124                                        GValue       *return_value G_GNUC_UNUSED,
1125                                        guint         n_param_values,
1126                                        const GValue *param_values,
1127                                        gpointer      invocation_hint G_GNUC_UNUSED,
1128                                        gpointer      marshal_data)
1129 {
1130   typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
1131                                                   gint arg1,
1132                                                   gint arg2,
1133                                                   gint arg3,
1134                                                   gpointer data2);
1135   GCClosure *cc = (GCClosure *) closure;
1136   gpointer data1, data2;
1137   GMarshalFunc_VOID__INT_INT_INT callback;
1138
1139   g_return_if_fail (n_param_values == 4);
1140
1141   if (G_CCLOSURE_SWAP_DATA (closure))
1142     {
1143       data1 = closure->data;
1144       data2 = g_value_peek_pointer (param_values + 0);
1145     }
1146   else
1147     {
1148       data1 = g_value_peek_pointer (param_values + 0);
1149       data2 = closure->data;
1150     }
1151   callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1152
1153   callback (data1,
1154             g_marshal_value_peek_int (param_values + 1),
1155             g_marshal_value_peek_int (param_values + 2),
1156             g_marshal_value_peek_int (param_values + 3),
1157             data2);
1158 }
1159
1160 void
1161 _g_cclosure_marshal_VOID__INT_INT_INTv (GClosure *closure,
1162                                         GValue   *return_value G_GNUC_UNUSED,
1163                                         gpointer  instance,
1164                                         va_list   args,
1165                                         gpointer  marshal_data,
1166                                         int       n_params,
1167                                         GType    *param_types)
1168 {
1169   typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer data1,
1170                                                   gint arg1,
1171                                                   gint arg2,
1172                                                   gint arg3,
1173                                                   gpointer data2);
1174   GCClosure *cc = (GCClosure *) closure;
1175   gpointer data1, data2;
1176   GMarshalFunc_VOID__INT_INT_INT callback;
1177   gint arg0;
1178   gint arg1;
1179   gint arg2;
1180   va_list args_copy;
1181
1182   G_VA_COPY (args_copy, args);
1183   arg0 = (gint) va_arg (args_copy, gint);
1184   arg1 = (gint) va_arg (args_copy, gint);
1185   arg2 = (gint) va_arg (args_copy, gint);
1186   va_end (args_copy);
1187
1188
1189   if (G_CCLOSURE_SWAP_DATA (closure))
1190     {
1191       data1 = closure->data;
1192       data2 = instance;
1193     }
1194   else
1195     {
1196       data1 = instance;
1197       data2 = closure->data;
1198     }
1199   callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
1200
1201   callback (data1,
1202             arg0,
1203             arg1,
1204             arg2,
1205             data2);
1206
1207 }
1208
1209 /* VOID:OBJECT,OBJECT */
1210 void
1211 _g_cclosure_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
1212                                          GValue       *return_value G_GNUC_UNUSED,
1213                                          guint         n_param_values,
1214                                          const GValue *param_values,
1215                                          gpointer      invocation_hint G_GNUC_UNUSED,
1216                                          gpointer      marshal_data)
1217 {
1218   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
1219                                                     gpointer arg1,
1220                                                     gpointer arg2,
1221                                                     gpointer data2);
1222   GCClosure *cc = (GCClosure *) closure;
1223   gpointer data1, data2;
1224   GMarshalFunc_VOID__OBJECT_OBJECT callback;
1225
1226   g_return_if_fail (n_param_values == 3);
1227
1228   if (G_CCLOSURE_SWAP_DATA (closure))
1229     {
1230       data1 = closure->data;
1231       data2 = g_value_peek_pointer (param_values + 0);
1232     }
1233   else
1234     {
1235       data1 = g_value_peek_pointer (param_values + 0);
1236       data2 = closure->data;
1237     }
1238   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1239
1240   callback (data1,
1241             g_marshal_value_peek_object (param_values + 1),
1242             g_marshal_value_peek_object (param_values + 2),
1243             data2);
1244 }
1245
1246 void
1247 _g_cclosure_marshal_VOID__OBJECT_OBJECTv (GClosure *closure,
1248                                           GValue   *return_value G_GNUC_UNUSED,
1249                                           gpointer  instance,
1250                                           va_list   args,
1251                                           gpointer  marshal_data,
1252                                           int       n_params,
1253                                           GType    *param_types)
1254 {
1255   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer data1,
1256                                                     gpointer arg1,
1257                                                     gpointer arg2,
1258                                                     gpointer data2);
1259   GCClosure *cc = (GCClosure *) closure;
1260   gpointer data1, data2;
1261   GMarshalFunc_VOID__OBJECT_OBJECT callback;
1262   gpointer arg0;
1263   gpointer arg1;
1264   va_list args_copy;
1265
1266   G_VA_COPY (args_copy, args);
1267   arg0 = (gpointer) va_arg (args_copy, gpointer);
1268   if (arg0 != NULL)
1269     arg0 = g_object_ref (arg0);
1270   arg1 = (gpointer) va_arg (args_copy, gpointer);
1271   if (arg1 != NULL)
1272     arg1 = g_object_ref (arg1);
1273   va_end (args_copy);
1274
1275
1276   if (G_CCLOSURE_SWAP_DATA (closure))
1277     {
1278       data1 = closure->data;
1279       data2 = instance;
1280     }
1281   else
1282     {
1283       data1 = instance;
1284       data2 = closure->data;
1285     }
1286   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
1287
1288   callback (data1,
1289             arg0,
1290             arg1,
1291             data2);
1292   if (arg0 != NULL)
1293     g_object_unref (arg0);
1294   if (arg1 != NULL)
1295     g_object_unref (arg1);
1296 }
1297
1298 /* VOID:OBJECT,OBJECT,ENUM */
1299 void
1300 _g_cclosure_marshal_VOID__OBJECT_OBJECT_ENUM (GClosure     *closure,
1301                                               GValue       *return_value G_GNUC_UNUSED,
1302                                               guint         n_param_values,
1303                                               const GValue *param_values,
1304                                               gpointer      invocation_hint G_GNUC_UNUSED,
1305                                               gpointer      marshal_data)
1306 {
1307   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (gpointer data1,
1308                                                          gpointer arg1,
1309                                                          gpointer arg2,
1310                                                          gint arg3,
1311                                                          gpointer data2);
1312   GCClosure *cc = (GCClosure *) closure;
1313   gpointer data1, data2;
1314   GMarshalFunc_VOID__OBJECT_OBJECT_ENUM callback;
1315
1316   g_return_if_fail (n_param_values == 4);
1317
1318   if (G_CCLOSURE_SWAP_DATA (closure))
1319     {
1320       data1 = closure->data;
1321       data2 = g_value_peek_pointer (param_values + 0);
1322     }
1323   else
1324     {
1325       data1 = g_value_peek_pointer (param_values + 0);
1326       data2 = closure->data;
1327     }
1328   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1329
1330   callback (data1,
1331             g_marshal_value_peek_object (param_values + 1),
1332             g_marshal_value_peek_object (param_values + 2),
1333             g_marshal_value_peek_enum (param_values + 3),
1334             data2);
1335 }
1336
1337 void
1338 _g_cclosure_marshal_VOID__OBJECT_OBJECT_ENUMv (GClosure *closure,
1339                                                GValue   *return_value G_GNUC_UNUSED,
1340                                                gpointer  instance,
1341                                                va_list   args,
1342                                                gpointer  marshal_data,
1343                                                int       n_params,
1344                                                GType    *param_types)
1345 {
1346   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (gpointer data1,
1347                                                          gpointer arg1,
1348                                                          gpointer arg2,
1349                                                          gint arg3,
1350                                                          gpointer data2);
1351   GCClosure *cc = (GCClosure *) closure;
1352   gpointer data1, data2;
1353   GMarshalFunc_VOID__OBJECT_OBJECT_ENUM callback;
1354   gpointer arg0;
1355   gpointer arg1;
1356   gint arg2;
1357   va_list args_copy;
1358
1359   G_VA_COPY (args_copy, args);
1360   arg0 = (gpointer) va_arg (args_copy, gpointer);
1361   if (arg0 != NULL)
1362     arg0 = g_object_ref (arg0);
1363   arg1 = (gpointer) va_arg (args_copy, gpointer);
1364   if (arg1 != NULL)
1365     arg1 = g_object_ref (arg1);
1366   arg2 = (gint) va_arg (args_copy, gint);
1367   va_end (args_copy);
1368
1369
1370   if (G_CCLOSURE_SWAP_DATA (closure))
1371     {
1372       data1 = closure->data;
1373       data2 = instance;
1374     }
1375   else
1376     {
1377       data1 = instance;
1378       data2 = closure->data;
1379     }
1380   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_ENUM) (marshal_data ? marshal_data : cc->callback);
1381
1382   callback (data1,
1383             arg0,
1384             arg1,
1385             arg2,
1386             data2);
1387   if (arg0 != NULL)
1388     g_object_unref (arg0);
1389   if (arg1 != NULL)
1390     g_object_unref (arg1);
1391 }
1392
1393 /* VOID:OBJECT,OBJECT,STRING,STRING,VARIANT */
1394 void
1395 _g_cclosure_marshal_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT (GClosure     *closure,
1396                                                                GValue       *return_value G_GNUC_UNUSED,
1397                                                                guint         n_param_values,
1398                                                                const GValue *param_values,
1399                                                                gpointer      invocation_hint G_GNUC_UNUSED,
1400                                                                gpointer      marshal_data)
1401 {
1402   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (gpointer data1,
1403                                                                           gpointer arg1,
1404                                                                           gpointer arg2,
1405                                                                           gpointer arg3,
1406                                                                           gpointer arg4,
1407                                                                           gpointer arg5,
1408                                                                           gpointer data2);
1409   GCClosure *cc = (GCClosure *) closure;
1410   gpointer data1, data2;
1411   GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT callback;
1412
1413   g_return_if_fail (n_param_values == 6);
1414
1415   if (G_CCLOSURE_SWAP_DATA (closure))
1416     {
1417       data1 = closure->data;
1418       data2 = g_value_peek_pointer (param_values + 0);
1419     }
1420   else
1421     {
1422       data1 = g_value_peek_pointer (param_values + 0);
1423       data2 = closure->data;
1424     }
1425   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
1426
1427   callback (data1,
1428             g_marshal_value_peek_object (param_values + 1),
1429             g_marshal_value_peek_object (param_values + 2),
1430             g_marshal_value_peek_string (param_values + 3),
1431             g_marshal_value_peek_string (param_values + 4),
1432             g_marshal_value_peek_variant (param_values + 5),
1433             data2);
1434 }
1435
1436 void
1437 _g_cclosure_marshal_VOID__OBJECT_OBJECT_STRING_STRING_VARIANTv (GClosure *closure,
1438                                                                 GValue   *return_value G_GNUC_UNUSED,
1439                                                                 gpointer  instance,
1440                                                                 va_list   args,
1441                                                                 gpointer  marshal_data,
1442                                                                 int       n_params,
1443                                                                 GType    *param_types)
1444 {
1445   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (gpointer data1,
1446                                                                           gpointer arg1,
1447                                                                           gpointer arg2,
1448                                                                           gpointer arg3,
1449                                                                           gpointer arg4,
1450                                                                           gpointer arg5,
1451                                                                           gpointer data2);
1452   GCClosure *cc = (GCClosure *) closure;
1453   gpointer data1, data2;
1454   GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT callback;
1455   gpointer arg0;
1456   gpointer arg1;
1457   gpointer arg2;
1458   gpointer arg3;
1459   gpointer arg4;
1460   va_list args_copy;
1461
1462   G_VA_COPY (args_copy, args);
1463   arg0 = (gpointer) va_arg (args_copy, gpointer);
1464   if (arg0 != NULL)
1465     arg0 = g_object_ref (arg0);
1466   arg1 = (gpointer) va_arg (args_copy, gpointer);
1467   if (arg1 != NULL)
1468     arg1 = g_object_ref (arg1);
1469   arg2 = (gpointer) va_arg (args_copy, gpointer);
1470   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1471     arg2 = g_strdup (arg2);
1472   arg3 = (gpointer) va_arg (args_copy, gpointer);
1473   if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1474     arg3 = g_strdup (arg3);
1475   arg4 = (gpointer) va_arg (args_copy, gpointer);
1476   if ((param_types[4] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg4 != NULL)
1477     arg4 = g_variant_ref_sink (arg4);
1478   va_end (args_copy);
1479
1480
1481   if (G_CCLOSURE_SWAP_DATA (closure))
1482     {
1483       data1 = closure->data;
1484       data2 = instance;
1485     }
1486   else
1487     {
1488       data1 = instance;
1489       data2 = closure->data;
1490     }
1491   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
1492
1493   callback (data1,
1494             arg0,
1495             arg1,
1496             arg2,
1497             arg3,
1498             arg4,
1499             data2);
1500   if (arg0 != NULL)
1501     g_object_unref (arg0);
1502   if (arg1 != NULL)
1503     g_object_unref (arg1);
1504   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1505     g_free (arg2);
1506   if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1507     g_free (arg3);
1508   if ((param_types[4] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg4 != NULL)
1509     g_variant_unref (arg4);
1510 }
1511
1512 /* VOID:OBJECT,OBJECT,VARIANT,BOXED */
1513 void
1514 _g_cclosure_marshal_VOID__OBJECT_OBJECT_VARIANT_BOXED (GClosure     *closure,
1515                                                        GValue       *return_value G_GNUC_UNUSED,
1516                                                        guint         n_param_values,
1517                                                        const GValue *param_values,
1518                                                        gpointer      invocation_hint G_GNUC_UNUSED,
1519                                                        gpointer      marshal_data)
1520 {
1521   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (gpointer data1,
1522                                                                   gpointer arg1,
1523                                                                   gpointer arg2,
1524                                                                   gpointer arg3,
1525                                                                   gpointer arg4,
1526                                                                   gpointer data2);
1527   GCClosure *cc = (GCClosure *) closure;
1528   gpointer data1, data2;
1529   GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED callback;
1530
1531   g_return_if_fail (n_param_values == 5);
1532
1533   if (G_CCLOSURE_SWAP_DATA (closure))
1534     {
1535       data1 = closure->data;
1536       data2 = g_value_peek_pointer (param_values + 0);
1537     }
1538   else
1539     {
1540       data1 = g_value_peek_pointer (param_values + 0);
1541       data2 = closure->data;
1542     }
1543   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
1544
1545   callback (data1,
1546             g_marshal_value_peek_object (param_values + 1),
1547             g_marshal_value_peek_object (param_values + 2),
1548             g_marshal_value_peek_variant (param_values + 3),
1549             g_marshal_value_peek_boxed (param_values + 4),
1550             data2);
1551 }
1552
1553 void
1554 _g_cclosure_marshal_VOID__OBJECT_OBJECT_VARIANT_BOXEDv (GClosure *closure,
1555                                                         GValue   *return_value G_GNUC_UNUSED,
1556                                                         gpointer  instance,
1557                                                         va_list   args,
1558                                                         gpointer  marshal_data,
1559                                                         int       n_params,
1560                                                         GType    *param_types)
1561 {
1562   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (gpointer data1,
1563                                                                   gpointer arg1,
1564                                                                   gpointer arg2,
1565                                                                   gpointer arg3,
1566                                                                   gpointer arg4,
1567                                                                   gpointer data2);
1568   GCClosure *cc = (GCClosure *) closure;
1569   gpointer data1, data2;
1570   GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED callback;
1571   gpointer arg0;
1572   gpointer arg1;
1573   gpointer arg2;
1574   gpointer arg3;
1575   va_list args_copy;
1576
1577   G_VA_COPY (args_copy, args);
1578   arg0 = (gpointer) va_arg (args_copy, gpointer);
1579   if (arg0 != NULL)
1580     arg0 = g_object_ref (arg0);
1581   arg1 = (gpointer) va_arg (args_copy, gpointer);
1582   if (arg1 != NULL)
1583     arg1 = g_object_ref (arg1);
1584   arg2 = (gpointer) va_arg (args_copy, gpointer);
1585   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1586     arg2 = g_variant_ref_sink (arg2);
1587   arg3 = (gpointer) va_arg (args_copy, gpointer);
1588   if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1589     arg3 = g_boxed_copy (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
1590   va_end (args_copy);
1591
1592
1593   if (G_CCLOSURE_SWAP_DATA (closure))
1594     {
1595       data1 = closure->data;
1596       data2 = instance;
1597     }
1598   else
1599     {
1600       data1 = instance;
1601       data2 = closure->data;
1602     }
1603   callback = (GMarshalFunc_VOID__OBJECT_OBJECT_VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
1604
1605   callback (data1,
1606             arg0,
1607             arg1,
1608             arg2,
1609             arg3,
1610             data2);
1611   if (arg0 != NULL)
1612     g_object_unref (arg0);
1613   if (arg1 != NULL)
1614     g_object_unref (arg1);
1615   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1616     g_variant_unref (arg2);
1617   if ((param_types[3] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg3 != NULL)
1618     g_boxed_free (param_types[3] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg3);
1619 }
1620
1621 /* VOID:OBJECT,VARIANT */
1622 void
1623 _g_cclosure_marshal_VOID__OBJECT_VARIANT (GClosure     *closure,
1624                                           GValue       *return_value G_GNUC_UNUSED,
1625                                           guint         n_param_values,
1626                                           const GValue *param_values,
1627                                           gpointer      invocation_hint G_GNUC_UNUSED,
1628                                           gpointer      marshal_data)
1629 {
1630   typedef void (*GMarshalFunc_VOID__OBJECT_VARIANT) (gpointer data1,
1631                                                      gpointer arg1,
1632                                                      gpointer arg2,
1633                                                      gpointer data2);
1634   GCClosure *cc = (GCClosure *) closure;
1635   gpointer data1, data2;
1636   GMarshalFunc_VOID__OBJECT_VARIANT callback;
1637
1638   g_return_if_fail (n_param_values == 3);
1639
1640   if (G_CCLOSURE_SWAP_DATA (closure))
1641     {
1642       data1 = closure->data;
1643       data2 = g_value_peek_pointer (param_values + 0);
1644     }
1645   else
1646     {
1647       data1 = g_value_peek_pointer (param_values + 0);
1648       data2 = closure->data;
1649     }
1650   callback = (GMarshalFunc_VOID__OBJECT_VARIANT) (marshal_data ? marshal_data : cc->callback);
1651
1652   callback (data1,
1653             g_marshal_value_peek_object (param_values + 1),
1654             g_marshal_value_peek_variant (param_values + 2),
1655             data2);
1656 }
1657
1658 void
1659 _g_cclosure_marshal_VOID__OBJECT_VARIANTv (GClosure *closure,
1660                                            GValue   *return_value G_GNUC_UNUSED,
1661                                            gpointer  instance,
1662                                            va_list   args,
1663                                            gpointer  marshal_data,
1664                                            int       n_params,
1665                                            GType    *param_types)
1666 {
1667   typedef void (*GMarshalFunc_VOID__OBJECT_VARIANT) (gpointer data1,
1668                                                      gpointer arg1,
1669                                                      gpointer arg2,
1670                                                      gpointer data2);
1671   GCClosure *cc = (GCClosure *) closure;
1672   gpointer data1, data2;
1673   GMarshalFunc_VOID__OBJECT_VARIANT callback;
1674   gpointer arg0;
1675   gpointer arg1;
1676   va_list args_copy;
1677
1678   G_VA_COPY (args_copy, args);
1679   arg0 = (gpointer) va_arg (args_copy, gpointer);
1680   if (arg0 != NULL)
1681     arg0 = g_object_ref (arg0);
1682   arg1 = (gpointer) va_arg (args_copy, gpointer);
1683   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1684     arg1 = g_variant_ref_sink (arg1);
1685   va_end (args_copy);
1686
1687
1688   if (G_CCLOSURE_SWAP_DATA (closure))
1689     {
1690       data1 = closure->data;
1691       data2 = instance;
1692     }
1693   else
1694     {
1695       data1 = instance;
1696       data2 = closure->data;
1697     }
1698   callback = (GMarshalFunc_VOID__OBJECT_VARIANT) (marshal_data ? marshal_data : cc->callback);
1699
1700   callback (data1,
1701             arg0,
1702             arg1,
1703             data2);
1704   if (arg0 != NULL)
1705     g_object_unref (arg0);
1706   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1707     g_variant_unref (arg1);
1708 }
1709
1710 /* VOID:POINTER,INT,STRING */
1711 void
1712 _g_cclosure_marshal_VOID__POINTER_INT_STRING (GClosure     *closure,
1713                                               GValue       *return_value G_GNUC_UNUSED,
1714                                               guint         n_param_values,
1715                                               const GValue *param_values,
1716                                               gpointer      invocation_hint G_GNUC_UNUSED,
1717                                               gpointer      marshal_data)
1718 {
1719   typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING) (gpointer data1,
1720                                                          gpointer arg1,
1721                                                          gint arg2,
1722                                                          gpointer arg3,
1723                                                          gpointer data2);
1724   GCClosure *cc = (GCClosure *) closure;
1725   gpointer data1, data2;
1726   GMarshalFunc_VOID__POINTER_INT_STRING callback;
1727
1728   g_return_if_fail (n_param_values == 4);
1729
1730   if (G_CCLOSURE_SWAP_DATA (closure))
1731     {
1732       data1 = closure->data;
1733       data2 = g_value_peek_pointer (param_values + 0);
1734     }
1735   else
1736     {
1737       data1 = g_value_peek_pointer (param_values + 0);
1738       data2 = closure->data;
1739     }
1740   callback = (GMarshalFunc_VOID__POINTER_INT_STRING) (marshal_data ? marshal_data : cc->callback);
1741
1742   callback (data1,
1743             g_marshal_value_peek_pointer (param_values + 1),
1744             g_marshal_value_peek_int (param_values + 2),
1745             g_marshal_value_peek_string (param_values + 3),
1746             data2);
1747 }
1748
1749 void
1750 _g_cclosure_marshal_VOID__POINTER_INT_STRINGv (GClosure *closure,
1751                                                GValue   *return_value G_GNUC_UNUSED,
1752                                                gpointer  instance,
1753                                                va_list   args,
1754                                                gpointer  marshal_data,
1755                                                int       n_params,
1756                                                GType    *param_types)
1757 {
1758   typedef void (*GMarshalFunc_VOID__POINTER_INT_STRING) (gpointer data1,
1759                                                          gpointer arg1,
1760                                                          gint arg2,
1761                                                          gpointer arg3,
1762                                                          gpointer data2);
1763   GCClosure *cc = (GCClosure *) closure;
1764   gpointer data1, data2;
1765   GMarshalFunc_VOID__POINTER_INT_STRING callback;
1766   gpointer arg0;
1767   gint arg1;
1768   gpointer arg2;
1769   va_list args_copy;
1770
1771   G_VA_COPY (args_copy, args);
1772   arg0 = (gpointer) va_arg (args_copy, gpointer);
1773   arg1 = (gint) va_arg (args_copy, gint);
1774   arg2 = (gpointer) va_arg (args_copy, gpointer);
1775   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1776     arg2 = g_strdup (arg2);
1777   va_end (args_copy);
1778
1779
1780   if (G_CCLOSURE_SWAP_DATA (closure))
1781     {
1782       data1 = closure->data;
1783       data2 = instance;
1784     }
1785   else
1786     {
1787       data1 = instance;
1788       data2 = closure->data;
1789     }
1790   callback = (GMarshalFunc_VOID__POINTER_INT_STRING) (marshal_data ? marshal_data : cc->callback);
1791
1792   callback (data1,
1793             arg0,
1794             arg1,
1795             arg2,
1796             data2);
1797   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
1798     g_free (arg2);
1799 }
1800
1801 /* VOID:STRING,BOOLEAN */
1802 void
1803 _g_cclosure_marshal_VOID__STRING_BOOLEAN (GClosure     *closure,
1804                                           GValue       *return_value G_GNUC_UNUSED,
1805                                           guint         n_param_values,
1806                                           const GValue *param_values,
1807                                           gpointer      invocation_hint G_GNUC_UNUSED,
1808                                           gpointer      marshal_data)
1809 {
1810   typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
1811                                                      gpointer arg1,
1812                                                      gboolean arg2,
1813                                                      gpointer data2);
1814   GCClosure *cc = (GCClosure *) closure;
1815   gpointer data1, data2;
1816   GMarshalFunc_VOID__STRING_BOOLEAN callback;
1817
1818   g_return_if_fail (n_param_values == 3);
1819
1820   if (G_CCLOSURE_SWAP_DATA (closure))
1821     {
1822       data1 = closure->data;
1823       data2 = g_value_peek_pointer (param_values + 0);
1824     }
1825   else
1826     {
1827       data1 = g_value_peek_pointer (param_values + 0);
1828       data2 = closure->data;
1829     }
1830   callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1831
1832   callback (data1,
1833             g_marshal_value_peek_string (param_values + 1),
1834             g_marshal_value_peek_boolean (param_values + 2),
1835             data2);
1836 }
1837
1838 void
1839 _g_cclosure_marshal_VOID__STRING_BOOLEANv (GClosure *closure,
1840                                            GValue   *return_value G_GNUC_UNUSED,
1841                                            gpointer  instance,
1842                                            va_list   args,
1843                                            gpointer  marshal_data,
1844                                            int       n_params,
1845                                            GType    *param_types)
1846 {
1847   typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
1848                                                      gpointer arg1,
1849                                                      gboolean arg2,
1850                                                      gpointer data2);
1851   GCClosure *cc = (GCClosure *) closure;
1852   gpointer data1, data2;
1853   GMarshalFunc_VOID__STRING_BOOLEAN callback;
1854   gpointer arg0;
1855   gboolean arg1;
1856   va_list args_copy;
1857
1858   G_VA_COPY (args_copy, args);
1859   arg0 = (gpointer) va_arg (args_copy, gpointer);
1860   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1861     arg0 = g_strdup (arg0);
1862   arg1 = (gboolean) va_arg (args_copy, gboolean);
1863   va_end (args_copy);
1864
1865
1866   if (G_CCLOSURE_SWAP_DATA (closure))
1867     {
1868       data1 = closure->data;
1869       data2 = instance;
1870     }
1871   else
1872     {
1873       data1 = instance;
1874       data2 = closure->data;
1875     }
1876   callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
1877
1878   callback (data1,
1879             arg0,
1880             arg1,
1881             data2);
1882   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1883     g_free (arg0);
1884 }
1885
1886 /* VOID:STRING,BOXED */
1887 void
1888 _g_cclosure_marshal_VOID__STRING_BOXED (GClosure     *closure,
1889                                         GValue       *return_value G_GNUC_UNUSED,
1890                                         guint         n_param_values,
1891                                         const GValue *param_values,
1892                                         gpointer      invocation_hint G_GNUC_UNUSED,
1893                                         gpointer      marshal_data)
1894 {
1895   typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
1896                                                    gpointer arg1,
1897                                                    gpointer arg2,
1898                                                    gpointer data2);
1899   GCClosure *cc = (GCClosure *) closure;
1900   gpointer data1, data2;
1901   GMarshalFunc_VOID__STRING_BOXED callback;
1902
1903   g_return_if_fail (n_param_values == 3);
1904
1905   if (G_CCLOSURE_SWAP_DATA (closure))
1906     {
1907       data1 = closure->data;
1908       data2 = g_value_peek_pointer (param_values + 0);
1909     }
1910   else
1911     {
1912       data1 = g_value_peek_pointer (param_values + 0);
1913       data2 = closure->data;
1914     }
1915   callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
1916
1917   callback (data1,
1918             g_marshal_value_peek_string (param_values + 1),
1919             g_marshal_value_peek_boxed (param_values + 2),
1920             data2);
1921 }
1922
1923 void
1924 _g_cclosure_marshal_VOID__STRING_BOXEDv (GClosure *closure,
1925                                          GValue   *return_value G_GNUC_UNUSED,
1926                                          gpointer  instance,
1927                                          va_list   args,
1928                                          gpointer  marshal_data,
1929                                          int       n_params,
1930                                          GType    *param_types)
1931 {
1932   typedef void (*GMarshalFunc_VOID__STRING_BOXED) (gpointer data1,
1933                                                    gpointer arg1,
1934                                                    gpointer arg2,
1935                                                    gpointer data2);
1936   GCClosure *cc = (GCClosure *) closure;
1937   gpointer data1, data2;
1938   GMarshalFunc_VOID__STRING_BOXED callback;
1939   gpointer arg0;
1940   gpointer arg1;
1941   va_list args_copy;
1942
1943   G_VA_COPY (args_copy, args);
1944   arg0 = (gpointer) va_arg (args_copy, gpointer);
1945   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1946     arg0 = g_strdup (arg0);
1947   arg1 = (gpointer) va_arg (args_copy, gpointer);
1948   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1949     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1950   va_end (args_copy);
1951
1952
1953   if (G_CCLOSURE_SWAP_DATA (closure))
1954     {
1955       data1 = closure->data;
1956       data2 = instance;
1957     }
1958   else
1959     {
1960       data1 = instance;
1961       data2 = closure->data;
1962     }
1963   callback = (GMarshalFunc_VOID__STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
1964
1965   callback (data1,
1966             arg0,
1967             arg1,
1968             data2);
1969   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
1970     g_free (arg0);
1971   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
1972     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
1973 }
1974
1975 /* VOID:STRING,BOXED,BOXED */
1976 void
1977 _g_cclosure_marshal_VOID__STRING_BOXED_BOXED (GClosure     *closure,
1978                                               GValue       *return_value G_GNUC_UNUSED,
1979                                               guint         n_param_values,
1980                                               const GValue *param_values,
1981                                               gpointer      invocation_hint G_GNUC_UNUSED,
1982                                               gpointer      marshal_data)
1983 {
1984   typedef void (*GMarshalFunc_VOID__STRING_BOXED_BOXED) (gpointer data1,
1985                                                          gpointer arg1,
1986                                                          gpointer arg2,
1987                                                          gpointer arg3,
1988                                                          gpointer data2);
1989   GCClosure *cc = (GCClosure *) closure;
1990   gpointer data1, data2;
1991   GMarshalFunc_VOID__STRING_BOXED_BOXED callback;
1992
1993   g_return_if_fail (n_param_values == 4);
1994
1995   if (G_CCLOSURE_SWAP_DATA (closure))
1996     {
1997       data1 = closure->data;
1998       data2 = g_value_peek_pointer (param_values + 0);
1999     }
2000   else
2001     {
2002       data1 = g_value_peek_pointer (param_values + 0);
2003       data2 = closure->data;
2004     }
2005   callback = (GMarshalFunc_VOID__STRING_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
2006
2007   callback (data1,
2008             g_marshal_value_peek_string (param_values + 1),
2009             g_marshal_value_peek_boxed (param_values + 2),
2010             g_marshal_value_peek_boxed (param_values + 3),
2011             data2);
2012 }
2013
2014 void
2015 _g_cclosure_marshal_VOID__STRING_BOXED_BOXEDv (GClosure *closure,
2016                                                GValue   *return_value G_GNUC_UNUSED,
2017                                                gpointer  instance,
2018                                                va_list   args,
2019                                                gpointer  marshal_data,
2020                                                int       n_params,
2021                                                GType    *param_types)
2022 {
2023   typedef void (*GMarshalFunc_VOID__STRING_BOXED_BOXED) (gpointer data1,
2024                                                          gpointer arg1,
2025                                                          gpointer arg2,
2026                                                          gpointer arg3,
2027                                                          gpointer data2);
2028   GCClosure *cc = (GCClosure *) closure;
2029   gpointer data1, data2;
2030   GMarshalFunc_VOID__STRING_BOXED_BOXED callback;
2031   gpointer arg0;
2032   gpointer arg1;
2033   gpointer arg2;
2034   va_list args_copy;
2035
2036   G_VA_COPY (args_copy, args);
2037   arg0 = (gpointer) va_arg (args_copy, gpointer);
2038   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2039     arg0 = g_strdup (arg0);
2040   arg1 = (gpointer) va_arg (args_copy, gpointer);
2041   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2042     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2043   arg2 = (gpointer) va_arg (args_copy, gpointer);
2044   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2045     arg2 = g_boxed_copy (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
2046   va_end (args_copy);
2047
2048
2049   if (G_CCLOSURE_SWAP_DATA (closure))
2050     {
2051       data1 = closure->data;
2052       data2 = instance;
2053     }
2054   else
2055     {
2056       data1 = instance;
2057       data2 = closure->data;
2058     }
2059   callback = (GMarshalFunc_VOID__STRING_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
2060
2061   callback (data1,
2062             arg0,
2063             arg1,
2064             arg2,
2065             data2);
2066   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2067     g_free (arg0);
2068   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2069     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2070   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2071     g_boxed_free (param_types[2] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg2);
2072 }
2073
2074 /* VOID:STRING,INT64,INT64 */
2075 void
2076 _g_cclosure_marshal_VOID__STRING_INT64_INT64 (GClosure     *closure,
2077                                               GValue       *return_value G_GNUC_UNUSED,
2078                                               guint         n_param_values,
2079                                               const GValue *param_values,
2080                                               gpointer      invocation_hint G_GNUC_UNUSED,
2081                                               gpointer      marshal_data)
2082 {
2083   typedef void (*GMarshalFunc_VOID__STRING_INT64_INT64) (gpointer data1,
2084                                                          gpointer arg1,
2085                                                          gint64 arg2,
2086                                                          gint64 arg3,
2087                                                          gpointer data2);
2088   GCClosure *cc = (GCClosure *) closure;
2089   gpointer data1, data2;
2090   GMarshalFunc_VOID__STRING_INT64_INT64 callback;
2091
2092   g_return_if_fail (n_param_values == 4);
2093
2094   if (G_CCLOSURE_SWAP_DATA (closure))
2095     {
2096       data1 = closure->data;
2097       data2 = g_value_peek_pointer (param_values + 0);
2098     }
2099   else
2100     {
2101       data1 = g_value_peek_pointer (param_values + 0);
2102       data2 = closure->data;
2103     }
2104   callback = (GMarshalFunc_VOID__STRING_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
2105
2106   callback (data1,
2107             g_marshal_value_peek_string (param_values + 1),
2108             g_marshal_value_peek_int64 (param_values + 2),
2109             g_marshal_value_peek_int64 (param_values + 3),
2110             data2);
2111 }
2112
2113 void
2114 _g_cclosure_marshal_VOID__STRING_INT64_INT64v (GClosure *closure,
2115                                                GValue   *return_value G_GNUC_UNUSED,
2116                                                gpointer  instance,
2117                                                va_list   args,
2118                                                gpointer  marshal_data,
2119                                                int       n_params,
2120                                                GType    *param_types)
2121 {
2122   typedef void (*GMarshalFunc_VOID__STRING_INT64_INT64) (gpointer data1,
2123                                                          gpointer arg1,
2124                                                          gint64 arg2,
2125                                                          gint64 arg3,
2126                                                          gpointer data2);
2127   GCClosure *cc = (GCClosure *) closure;
2128   gpointer data1, data2;
2129   GMarshalFunc_VOID__STRING_INT64_INT64 callback;
2130   gpointer arg0;
2131   gint64 arg1;
2132   gint64 arg2;
2133   va_list args_copy;
2134
2135   G_VA_COPY (args_copy, args);
2136   arg0 = (gpointer) va_arg (args_copy, gpointer);
2137   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2138     arg0 = g_strdup (arg0);
2139   arg1 = (gint64) va_arg (args_copy, gint64);
2140   arg2 = (gint64) va_arg (args_copy, gint64);
2141   va_end (args_copy);
2142
2143
2144   if (G_CCLOSURE_SWAP_DATA (closure))
2145     {
2146       data1 = closure->data;
2147       data2 = instance;
2148     }
2149   else
2150     {
2151       data1 = instance;
2152       data2 = closure->data;
2153     }
2154   callback = (GMarshalFunc_VOID__STRING_INT64_INT64) (marshal_data ? marshal_data : cc->callback);
2155
2156   callback (data1,
2157             arg0,
2158             arg1,
2159             arg2,
2160             data2);
2161   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2162     g_free (arg0);
2163 }
2164
2165 /* VOID:STRING,STRING,STRING,FLAGS */
2166 void
2167 _g_cclosure_marshal_VOID__STRING_STRING_STRING_FLAGS (GClosure     *closure,
2168                                                       GValue       *return_value G_GNUC_UNUSED,
2169                                                       guint         n_param_values,
2170                                                       const GValue *param_values,
2171                                                       gpointer      invocation_hint G_GNUC_UNUSED,
2172                                                       gpointer      marshal_data)
2173 {
2174   typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (gpointer data1,
2175                                                                  gpointer arg1,
2176                                                                  gpointer arg2,
2177                                                                  gpointer arg3,
2178                                                                  guint arg4,
2179                                                                  gpointer data2);
2180   GCClosure *cc = (GCClosure *) closure;
2181   gpointer data1, data2;
2182   GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS callback;
2183
2184   g_return_if_fail (n_param_values == 5);
2185
2186   if (G_CCLOSURE_SWAP_DATA (closure))
2187     {
2188       data1 = closure->data;
2189       data2 = g_value_peek_pointer (param_values + 0);
2190     }
2191   else
2192     {
2193       data1 = g_value_peek_pointer (param_values + 0);
2194       data2 = closure->data;
2195     }
2196   callback = (GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (marshal_data ? marshal_data : cc->callback);
2197
2198   callback (data1,
2199             g_marshal_value_peek_string (param_values + 1),
2200             g_marshal_value_peek_string (param_values + 2),
2201             g_marshal_value_peek_string (param_values + 3),
2202             g_marshal_value_peek_flags (param_values + 4),
2203             data2);
2204 }
2205
2206 void
2207 _g_cclosure_marshal_VOID__STRING_STRING_STRING_FLAGSv (GClosure *closure,
2208                                                        GValue   *return_value G_GNUC_UNUSED,
2209                                                        gpointer  instance,
2210                                                        va_list   args,
2211                                                        gpointer  marshal_data,
2212                                                        int       n_params,
2213                                                        GType    *param_types)
2214 {
2215   typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (gpointer data1,
2216                                                                  gpointer arg1,
2217                                                                  gpointer arg2,
2218                                                                  gpointer arg3,
2219                                                                  guint arg4,
2220                                                                  gpointer data2);
2221   GCClosure *cc = (GCClosure *) closure;
2222   gpointer data1, data2;
2223   GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS callback;
2224   gpointer arg0;
2225   gpointer arg1;
2226   gpointer arg2;
2227   guint arg3;
2228   va_list args_copy;
2229
2230   G_VA_COPY (args_copy, args);
2231   arg0 = (gpointer) va_arg (args_copy, gpointer);
2232   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2233     arg0 = g_strdup (arg0);
2234   arg1 = (gpointer) va_arg (args_copy, gpointer);
2235   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2236     arg1 = g_strdup (arg1);
2237   arg2 = (gpointer) va_arg (args_copy, gpointer);
2238   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2239     arg2 = g_strdup (arg2);
2240   arg3 = (guint) va_arg (args_copy, guint);
2241   va_end (args_copy);
2242
2243
2244   if (G_CCLOSURE_SWAP_DATA (closure))
2245     {
2246       data1 = closure->data;
2247       data2 = instance;
2248     }
2249   else
2250     {
2251       data1 = instance;
2252       data2 = closure->data;
2253     }
2254   callback = (GMarshalFunc_VOID__STRING_STRING_STRING_FLAGS) (marshal_data ? marshal_data : cc->callback);
2255
2256   callback (data1,
2257             arg0,
2258             arg1,
2259             arg2,
2260             arg3,
2261             data2);
2262   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2263     g_free (arg0);
2264   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2265     g_free (arg1);
2266   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2267     g_free (arg2);
2268 }
2269
2270 /* VOID:STRING,STRING,VARIANT */
2271 void
2272 _g_cclosure_marshal_VOID__STRING_STRING_VARIANT (GClosure     *closure,
2273                                                  GValue       *return_value G_GNUC_UNUSED,
2274                                                  guint         n_param_values,
2275                                                  const GValue *param_values,
2276                                                  gpointer      invocation_hint G_GNUC_UNUSED,
2277                                                  gpointer      marshal_data)
2278 {
2279   typedef void (*GMarshalFunc_VOID__STRING_STRING_VARIANT) (gpointer data1,
2280                                                             gpointer arg1,
2281                                                             gpointer arg2,
2282                                                             gpointer arg3,
2283                                                             gpointer data2);
2284   GCClosure *cc = (GCClosure *) closure;
2285   gpointer data1, data2;
2286   GMarshalFunc_VOID__STRING_STRING_VARIANT callback;
2287
2288   g_return_if_fail (n_param_values == 4);
2289
2290   if (G_CCLOSURE_SWAP_DATA (closure))
2291     {
2292       data1 = closure->data;
2293       data2 = g_value_peek_pointer (param_values + 0);
2294     }
2295   else
2296     {
2297       data1 = g_value_peek_pointer (param_values + 0);
2298       data2 = closure->data;
2299     }
2300   callback = (GMarshalFunc_VOID__STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2301
2302   callback (data1,
2303             g_marshal_value_peek_string (param_values + 1),
2304             g_marshal_value_peek_string (param_values + 2),
2305             g_marshal_value_peek_variant (param_values + 3),
2306             data2);
2307 }
2308
2309 void
2310 _g_cclosure_marshal_VOID__STRING_STRING_VARIANTv (GClosure *closure,
2311                                                   GValue   *return_value G_GNUC_UNUSED,
2312                                                   gpointer  instance,
2313                                                   va_list   args,
2314                                                   gpointer  marshal_data,
2315                                                   int       n_params,
2316                                                   GType    *param_types)
2317 {
2318   typedef void (*GMarshalFunc_VOID__STRING_STRING_VARIANT) (gpointer data1,
2319                                                             gpointer arg1,
2320                                                             gpointer arg2,
2321                                                             gpointer arg3,
2322                                                             gpointer data2);
2323   GCClosure *cc = (GCClosure *) closure;
2324   gpointer data1, data2;
2325   GMarshalFunc_VOID__STRING_STRING_VARIANT callback;
2326   gpointer arg0;
2327   gpointer arg1;
2328   gpointer arg2;
2329   va_list args_copy;
2330
2331   G_VA_COPY (args_copy, args);
2332   arg0 = (gpointer) va_arg (args_copy, gpointer);
2333   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2334     arg0 = g_strdup (arg0);
2335   arg1 = (gpointer) va_arg (args_copy, gpointer);
2336   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2337     arg1 = g_strdup (arg1);
2338   arg2 = (gpointer) va_arg (args_copy, gpointer);
2339   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2340     arg2 = g_variant_ref_sink (arg2);
2341   va_end (args_copy);
2342
2343
2344   if (G_CCLOSURE_SWAP_DATA (closure))
2345     {
2346       data1 = closure->data;
2347       data2 = instance;
2348     }
2349   else
2350     {
2351       data1 = instance;
2352       data2 = closure->data;
2353     }
2354   callback = (GMarshalFunc_VOID__STRING_STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2355
2356   callback (data1,
2357             arg0,
2358             arg1,
2359             arg2,
2360             data2);
2361   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2362     g_free (arg0);
2363   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2364     g_free (arg1);
2365   if ((param_types[2] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg2 != NULL)
2366     g_variant_unref (arg2);
2367 }
2368
2369 /* VOID:STRING,VARIANT */
2370 void
2371 _g_cclosure_marshal_VOID__STRING_VARIANT (GClosure     *closure,
2372                                           GValue       *return_value G_GNUC_UNUSED,
2373                                           guint         n_param_values,
2374                                           const GValue *param_values,
2375                                           gpointer      invocation_hint G_GNUC_UNUSED,
2376                                           gpointer      marshal_data)
2377 {
2378   typedef void (*GMarshalFunc_VOID__STRING_VARIANT) (gpointer data1,
2379                                                      gpointer arg1,
2380                                                      gpointer arg2,
2381                                                      gpointer data2);
2382   GCClosure *cc = (GCClosure *) closure;
2383   gpointer data1, data2;
2384   GMarshalFunc_VOID__STRING_VARIANT callback;
2385
2386   g_return_if_fail (n_param_values == 3);
2387
2388   if (G_CCLOSURE_SWAP_DATA (closure))
2389     {
2390       data1 = closure->data;
2391       data2 = g_value_peek_pointer (param_values + 0);
2392     }
2393   else
2394     {
2395       data1 = g_value_peek_pointer (param_values + 0);
2396       data2 = closure->data;
2397     }
2398   callback = (GMarshalFunc_VOID__STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2399
2400   callback (data1,
2401             g_marshal_value_peek_string (param_values + 1),
2402             g_marshal_value_peek_variant (param_values + 2),
2403             data2);
2404 }
2405
2406 void
2407 _g_cclosure_marshal_VOID__STRING_VARIANTv (GClosure *closure,
2408                                            GValue   *return_value G_GNUC_UNUSED,
2409                                            gpointer  instance,
2410                                            va_list   args,
2411                                            gpointer  marshal_data,
2412                                            int       n_params,
2413                                            GType    *param_types)
2414 {
2415   typedef void (*GMarshalFunc_VOID__STRING_VARIANT) (gpointer data1,
2416                                                      gpointer arg1,
2417                                                      gpointer arg2,
2418                                                      gpointer data2);
2419   GCClosure *cc = (GCClosure *) closure;
2420   gpointer data1, data2;
2421   GMarshalFunc_VOID__STRING_VARIANT callback;
2422   gpointer arg0;
2423   gpointer arg1;
2424   va_list args_copy;
2425
2426   G_VA_COPY (args_copy, args);
2427   arg0 = (gpointer) va_arg (args_copy, gpointer);
2428   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2429     arg0 = g_strdup (arg0);
2430   arg1 = (gpointer) va_arg (args_copy, gpointer);
2431   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2432     arg1 = g_variant_ref_sink (arg1);
2433   va_end (args_copy);
2434
2435
2436   if (G_CCLOSURE_SWAP_DATA (closure))
2437     {
2438       data1 = closure->data;
2439       data2 = instance;
2440     }
2441   else
2442     {
2443       data1 = instance;
2444       data2 = closure->data;
2445     }
2446   callback = (GMarshalFunc_VOID__STRING_VARIANT) (marshal_data ? marshal_data : cc->callback);
2447
2448   callback (data1,
2449             arg0,
2450             arg1,
2451             data2);
2452   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2453     g_free (arg0);
2454   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2455     g_variant_unref (arg1);
2456 }
2457
2458 /* VOID:UINT,UINT,UINT */
2459 void
2460 _g_cclosure_marshal_VOID__UINT_UINT_UINT (GClosure     *closure,
2461                                           GValue       *return_value G_GNUC_UNUSED,
2462                                           guint         n_param_values,
2463                                           const GValue *param_values,
2464                                           gpointer      invocation_hint G_GNUC_UNUSED,
2465                                           gpointer      marshal_data)
2466 {
2467   typedef void (*GMarshalFunc_VOID__UINT_UINT_UINT) (gpointer data1,
2468                                                      guint arg1,
2469                                                      guint arg2,
2470                                                      guint arg3,
2471                                                      gpointer data2);
2472   GCClosure *cc = (GCClosure *) closure;
2473   gpointer data1, data2;
2474   GMarshalFunc_VOID__UINT_UINT_UINT callback;
2475
2476   g_return_if_fail (n_param_values == 4);
2477
2478   if (G_CCLOSURE_SWAP_DATA (closure))
2479     {
2480       data1 = closure->data;
2481       data2 = g_value_peek_pointer (param_values + 0);
2482     }
2483   else
2484     {
2485       data1 = g_value_peek_pointer (param_values + 0);
2486       data2 = closure->data;
2487     }
2488   callback = (GMarshalFunc_VOID__UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2489
2490   callback (data1,
2491             g_marshal_value_peek_uint (param_values + 1),
2492             g_marshal_value_peek_uint (param_values + 2),
2493             g_marshal_value_peek_uint (param_values + 3),
2494             data2);
2495 }
2496
2497 void
2498 _g_cclosure_marshal_VOID__UINT_UINT_UINTv (GClosure *closure,
2499                                            GValue   *return_value G_GNUC_UNUSED,
2500                                            gpointer  instance,
2501                                            va_list   args,
2502                                            gpointer  marshal_data,
2503                                            int       n_params,
2504                                            GType    *param_types)
2505 {
2506   typedef void (*GMarshalFunc_VOID__UINT_UINT_UINT) (gpointer data1,
2507                                                      guint arg1,
2508                                                      guint arg2,
2509                                                      guint arg3,
2510                                                      gpointer data2);
2511   GCClosure *cc = (GCClosure *) closure;
2512   gpointer data1, data2;
2513   GMarshalFunc_VOID__UINT_UINT_UINT callback;
2514   guint arg0;
2515   guint arg1;
2516   guint arg2;
2517   va_list args_copy;
2518
2519   G_VA_COPY (args_copy, args);
2520   arg0 = (guint) va_arg (args_copy, guint);
2521   arg1 = (guint) va_arg (args_copy, guint);
2522   arg2 = (guint) va_arg (args_copy, guint);
2523   va_end (args_copy);
2524
2525
2526   if (G_CCLOSURE_SWAP_DATA (closure))
2527     {
2528       data1 = closure->data;
2529       data2 = instance;
2530     }
2531   else
2532     {
2533       data1 = instance;
2534       data2 = closure->data;
2535     }
2536   callback = (GMarshalFunc_VOID__UINT_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
2537
2538   callback (data1,
2539             arg0,
2540             arg1,
2541             arg2,
2542             data2);
2543
2544 }
2545
2546 /* VOID:VARIANT,BOXED */
2547 void
2548 _g_cclosure_marshal_VOID__VARIANT_BOXED (GClosure     *closure,
2549                                          GValue       *return_value G_GNUC_UNUSED,
2550                                          guint         n_param_values,
2551                                          const GValue *param_values,
2552                                          gpointer      invocation_hint G_GNUC_UNUSED,
2553                                          gpointer      marshal_data)
2554 {
2555   typedef void (*GMarshalFunc_VOID__VARIANT_BOXED) (gpointer data1,
2556                                                     gpointer arg1,
2557                                                     gpointer arg2,
2558                                                     gpointer data2);
2559   GCClosure *cc = (GCClosure *) closure;
2560   gpointer data1, data2;
2561   GMarshalFunc_VOID__VARIANT_BOXED callback;
2562
2563   g_return_if_fail (n_param_values == 3);
2564
2565   if (G_CCLOSURE_SWAP_DATA (closure))
2566     {
2567       data1 = closure->data;
2568       data2 = g_value_peek_pointer (param_values + 0);
2569     }
2570   else
2571     {
2572       data1 = g_value_peek_pointer (param_values + 0);
2573       data2 = closure->data;
2574     }
2575   callback = (GMarshalFunc_VOID__VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
2576
2577   callback (data1,
2578             g_marshal_value_peek_variant (param_values + 1),
2579             g_marshal_value_peek_boxed (param_values + 2),
2580             data2);
2581 }
2582
2583 void
2584 _g_cclosure_marshal_VOID__VARIANT_BOXEDv (GClosure *closure,
2585                                           GValue   *return_value G_GNUC_UNUSED,
2586                                           gpointer  instance,
2587                                           va_list   args,
2588                                           gpointer  marshal_data,
2589                                           int       n_params,
2590                                           GType    *param_types)
2591 {
2592   typedef void (*GMarshalFunc_VOID__VARIANT_BOXED) (gpointer data1,
2593                                                     gpointer arg1,
2594                                                     gpointer arg2,
2595                                                     gpointer data2);
2596   GCClosure *cc = (GCClosure *) closure;
2597   gpointer data1, data2;
2598   GMarshalFunc_VOID__VARIANT_BOXED callback;
2599   gpointer arg0;
2600   gpointer arg1;
2601   va_list args_copy;
2602
2603   G_VA_COPY (args_copy, args);
2604   arg0 = (gpointer) va_arg (args_copy, gpointer);
2605   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2606     arg0 = g_variant_ref_sink (arg0);
2607   arg1 = (gpointer) va_arg (args_copy, gpointer);
2608   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2609     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2610   va_end (args_copy);
2611
2612
2613   if (G_CCLOSURE_SWAP_DATA (closure))
2614     {
2615       data1 = closure->data;
2616       data2 = instance;
2617     }
2618   else
2619     {
2620       data1 = instance;
2621       data2 = closure->data;
2622     }
2623   callback = (GMarshalFunc_VOID__VARIANT_BOXED) (marshal_data ? marshal_data : cc->callback);
2624
2625   callback (data1,
2626             arg0,
2627             arg1,
2628             data2);
2629   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
2630     g_variant_unref (arg0);
2631   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
2632     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
2633 }