gattrib/src/gtkextra-marshal.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include        <glib-object.h>
   6
   7 #ifdef HAVE_LIBDMALLOC
   8 #include <dmalloc.h>
   9 #endif
  10
  11 #ifdef G_ENABLE_DEBUG
  12 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
  13 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
  14 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
  15 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
  16 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
  17 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
  18 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
  19 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
  20 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
  21 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
  22 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
  23 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
  24 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
  25 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
  26 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
  27 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
  28 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
  29 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
  30 #else /* !G_ENABLE_DEBUG */
  31 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
  32  *          Do not access GValues directly in your code. Instead, use the
  33  *          g_value_get_*() functions
  34  */
  35 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
  36 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
  37 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
  38 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
  39 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
  40 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
  41 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
  42 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
  43 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
  44 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_int
  45 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_uint
  46 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
  47 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
  48 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
  49 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
  50 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
  51 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
  52 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
  53 #endif /* !G_ENABLE_DEBUG */
  54
  55
  56 /* BOOL:INT,INT,POINTER,POINTER (gtkextra-marshal.list:1) */
  57 void
  58 gtkextra_BOOLEAN__INT_INT_POINTER_POINTER (GClosure     *closure,
  59                                            GValue       *return_value,
  60                                            guint         n_param_values,
  61                                            const GValue *param_values,
  62                                            gpointer      invocation_hint,
  63                                            gpointer      marshal_data)
  64 {
  65   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_POINTER_POINTER) (gpointer     data1,
  66                                                                      gint         arg_1,
  67                                                                      gint         arg_2,
  68                                                                      gpointer     arg_3,
  69                                                                      gpointer     arg_4,
  70                                                                      gpointer     data2);
  71   register GMarshalFunc_BOOLEAN__INT_INT_POINTER_POINTER callback;
  72   register GCClosure *cc = (GCClosure*) closure;
  73   register gpointer data1, data2;
  74   gboolean v_return;
  75
  76   g_return_if_fail (return_value != NULL);
  77   g_return_if_fail (n_param_values == 5);
  78
  79   if (G_CCLOSURE_SWAP_DATA (closure))
  80     {
  81       data1 = closure->data;
  82       data2 = g_value_peek_pointer (param_values + 0);
  83     }
  84   else
  85     {
  86       data1 = g_value_peek_pointer (param_values + 0);
  87       data2 = closure->data;
  88     }
  89   callback = (GMarshalFunc_BOOLEAN__INT_INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
  90
  91   v_return = callback (data1,
  92                        g_marshal_value_peek_int (param_values + 1),
  93                        g_marshal_value_peek_int (param_values + 2),
  94                        g_marshal_value_peek_pointer (param_values + 3),
  95                        g_marshal_value_peek_pointer (param_values + 4),
  96                        data2);
  97
  98   g_value_set_boolean (return_value, v_return);
  99 }
 100
 101 /* BOOL:BOXED,POINTER (gtkextra-marshal.list:2) */
 102 void
 103 gtkextra_BOOLEAN__BOXED_POINTER (GClosure     *closure,
 104                                  GValue       *return_value,
 105                                  guint         n_param_values,
 106                                  const GValue *param_values,
 107                                  gpointer      invocation_hint,
 108                                  gpointer      marshal_data)
 109 {
 110   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_POINTER) (gpointer     data1,
 111                                                            gpointer     arg_1,
 112                                                            gpointer     arg_2,
 113                                                            gpointer     data2);
 114   register GMarshalFunc_BOOLEAN__BOXED_POINTER callback;
 115   register GCClosure *cc = (GCClosure*) closure;
 116   register gpointer data1, data2;
 117   gboolean v_return;
 118
 119   g_return_if_fail (return_value != NULL);
 120   g_return_if_fail (n_param_values == 3);
 121
 122   if (G_CCLOSURE_SWAP_DATA (closure))
 123     {
 124       data1 = closure->data;
 125       data2 = g_value_peek_pointer (param_values + 0);
 126     }
 127   else
 128     {
 129       data1 = g_value_peek_pointer (param_values + 0);
 130       data2 = closure->data;
 131     }
 132   callback = (GMarshalFunc_BOOLEAN__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
 133
 134   v_return = callback (data1,
 135                        g_marshal_value_peek_boxed (param_values + 1),
 136                        g_marshal_value_peek_pointer (param_values + 2),
 137                        data2);
 138
 139   g_value_set_boolean (return_value, v_return);
 140 }
 141
 142 /* BOOL:BOXED,STRING (gtkextra-marshal.list:3) */
 143 void
 144 gtkextra_BOOLEAN__BOXED_STRING (GClosure     *closure,
 145                                 GValue       *return_value,
 146                                 guint         n_param_values,
 147                                 const GValue *param_values,
 148                                 gpointer      invocation_hint,
 149                                 gpointer      marshal_data)
 150 {
 151   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_STRING) (gpointer     data1,
 152                                                           gpointer     arg_1,
 153                                                           gpointer     arg_2,
 154                                                           gpointer     data2);
 155   register GMarshalFunc_BOOLEAN__BOXED_STRING callback;
 156   register GCClosure *cc = (GCClosure*) closure;
 157   register gpointer data1, data2;
 158   gboolean v_return;
 159
 160   g_return_if_fail (return_value != NULL);
 161   g_return_if_fail (n_param_values == 3);
 162
 163   if (G_CCLOSURE_SWAP_DATA (closure))
 164     {
 165       data1 = closure->data;
 166       data2 = g_value_peek_pointer (param_values + 0);
 167     }
 168   else
 169     {
 170       data1 = g_value_peek_pointer (param_values + 0);
 171       data2 = closure->data;
 172     }
 173   callback = (GMarshalFunc_BOOLEAN__BOXED_STRING) (marshal_data ? marshal_data : cc->callback);
 174
 175   v_return = callback (data1,
 176                        g_marshal_value_peek_boxed (param_values + 1),
 177                        g_marshal_value_peek_string (param_values + 2),
 178                        data2);
 179
 180   g_value_set_boolean (return_value, v_return);
 181 }
 182
 183 /* BOOL:BOXED,BOXED (gtkextra-marshal.list:4) */
 184 void
 185 gtkextra_BOOLEAN__BOXED_BOXED (GClosure     *closure,
 186                                GValue       *return_value,
 187                                guint         n_param_values,
 188                                const GValue *param_values,
 189                                gpointer      invocation_hint,
 190                                gpointer      marshal_data)
 191 {
 192   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     data1,
 193                                                          gpointer     arg_1,
 194                                                          gpointer     arg_2,
 195                                                          gpointer     data2);
 196   register GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
 197   register GCClosure *cc = (GCClosure*) closure;
 198   register gpointer data1, data2;
 199   gboolean v_return;
 200
 201   g_return_if_fail (return_value != NULL);
 202   g_return_if_fail (n_param_values == 3);
 203
 204   if (G_CCLOSURE_SWAP_DATA (closure))
 205     {
 206       data1 = closure->data;
 207       data2 = g_value_peek_pointer (param_values + 0);
 208     }
 209   else
 210     {
 211       data1 = g_value_peek_pointer (param_values + 0);
 212       data2 = closure->data;
 213     }
 214   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
 215
 216   v_return = callback (data1,
 217                        g_marshal_value_peek_boxed (param_values + 1),
 218                        g_marshal_value_peek_boxed (param_values + 2),
 219                        data2);
 220
 221   g_value_set_boolean (return_value, v_return);
 222 }
 223
 224 /* BOOL:BOXED,DOUBLE,DOUBLE (gtkextra-marshal.list:5) */
 225 void
 226 gtkextra_BOOLEAN__BOXED_DOUBLE_DOUBLE (GClosure     *closure,
 227                                        GValue       *return_value,
 228                                        guint         n_param_values,
 229                                        const GValue *param_values,
 230                                        gpointer      invocation_hint,
 231                                        gpointer      marshal_data)
 232 {
 233   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_DOUBLE_DOUBLE) (gpointer     data1,
 234                                                                  gpointer     arg_1,
 235                                                                  gdouble      arg_2,
 236                                                                  gdouble      arg_3,
 237                                                                  gpointer     data2);
 238   register GMarshalFunc_BOOLEAN__BOXED_DOUBLE_DOUBLE callback;
 239   register GCClosure *cc = (GCClosure*) closure;
 240   register gpointer data1, data2;
 241   gboolean v_return;
 242
 243   g_return_if_fail (return_value != NULL);
 244   g_return_if_fail (n_param_values == 4);
 245
 246   if (G_CCLOSURE_SWAP_DATA (closure))
 247     {
 248       data1 = closure->data;
 249       data2 = g_value_peek_pointer (param_values + 0);
 250     }
 251   else
 252     {
 253       data1 = g_value_peek_pointer (param_values + 0);
 254       data2 = closure->data;
 255     }
 256   callback = (GMarshalFunc_BOOLEAN__BOXED_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 257
 258   v_return = callback (data1,
 259                        g_marshal_value_peek_boxed (param_values + 1),
 260                        g_marshal_value_peek_double (param_values + 2),
 261                        g_marshal_value_peek_double (param_values + 3),
 262                        data2);
 263
 264   g_value_set_boolean (return_value, v_return);
 265 }
 266
 267 /* BOOL:POINTER,POINTER (gtkextra-marshal.list:6) */
 268 void
 269 gtkextra_BOOLEAN__POINTER_POINTER (GClosure     *closure,
 270                                    GValue       *return_value,
 271                                    guint         n_param_values,
 272                                    const GValue *param_values,
 273                                    gpointer      invocation_hint,
 274                                    gpointer      marshal_data)
 275 {
 276   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
 277                                                              gpointer     arg_1,
 278                                                              gpointer     arg_2,
 279                                                              gpointer     data2);
 280   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
 281   register GCClosure *cc = (GCClosure*) closure;
 282   register gpointer data1, data2;
 283   gboolean v_return;
 284
 285   g_return_if_fail (return_value != NULL);
 286   g_return_if_fail (n_param_values == 3);
 287
 288   if (G_CCLOSURE_SWAP_DATA (closure))
 289     {
 290       data1 = closure->data;
 291       data2 = g_value_peek_pointer (param_values + 0);
 292     }
 293   else
 294     {
 295       data1 = g_value_peek_pointer (param_values + 0);
 296       data2 = closure->data;
 297     }
 298   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 299
 300   v_return = callback (data1,
 301                        g_marshal_value_peek_pointer (param_values + 1),
 302                        g_marshal_value_peek_pointer (param_values + 2),
 303                        data2);
 304
 305   g_value_set_boolean (return_value, v_return);
 306 }
 307
 308 /* BOOL:POINTER,BOXED (gtkextra-marshal.list:7) */
 309 void
 310 gtkextra_BOOLEAN__POINTER_BOXED (GClosure     *closure,
 311                                  GValue       *return_value,
 312                                  guint         n_param_values,
 313                                  const GValue *param_values,
 314                                  gpointer      invocation_hint,
 315                                  gpointer      marshal_data)
 316 {
 317   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_BOXED) (gpointer     data1,
 318                                                            gpointer     arg_1,
 319                                                            gpointer     arg_2,
 320                                                            gpointer     data2);
 321   register GMarshalFunc_BOOLEAN__POINTER_BOXED callback;
 322   register GCClosure *cc = (GCClosure*) closure;
 323   register gpointer data1, data2;
 324   gboolean v_return;
 325
 326   g_return_if_fail (return_value != NULL);
 327   g_return_if_fail (n_param_values == 3);
 328
 329   if (G_CCLOSURE_SWAP_DATA (closure))
 330     {
 331       data1 = closure->data;
 332       data2 = g_value_peek_pointer (param_values + 0);
 333     }
 334   else
 335     {
 336       data1 = g_value_peek_pointer (param_values + 0);
 337       data2 = closure->data;
 338     }
 339   callback = (GMarshalFunc_BOOLEAN__POINTER_BOXED) (marshal_data ? marshal_data : cc->callback);
 340
 341   v_return = callback (data1,
 342                        g_marshal_value_peek_pointer (param_values + 1),
 343                        g_marshal_value_peek_boxed (param_values + 2),
 344                        data2);
 345
 346   g_value_set_boolean (return_value, v_return);
 347 }
 348
 349 /* BOOL:POINTER,STRING (gtkextra-marshal.list:8) */
 350 void
 351 gtkextra_BOOLEAN__POINTER_STRING (GClosure     *closure,
 352                                   GValue       *return_value,
 353                                   guint         n_param_values,
 354                                   const GValue *param_values,
 355                                   gpointer      invocation_hint,
 356                                   gpointer      marshal_data)
 357 {
 358   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_STRING) (gpointer     data1,
 359                                                             gpointer     arg_1,
 360                                                             gpointer     arg_2,
 361                                                             gpointer     data2);
 362   register GMarshalFunc_BOOLEAN__POINTER_STRING callback;
 363   register GCClosure *cc = (GCClosure*) closure;
 364   register gpointer data1, data2;
 365   gboolean v_return;
 366
 367   g_return_if_fail (return_value != NULL);
 368   g_return_if_fail (n_param_values == 3);
 369
 370   if (G_CCLOSURE_SWAP_DATA (closure))
 371     {
 372       data1 = closure->data;
 373       data2 = g_value_peek_pointer (param_values + 0);
 374     }
 375   else
 376     {
 377       data1 = g_value_peek_pointer (param_values + 0);
 378       data2 = closure->data;
 379     }
 380   callback = (GMarshalFunc_BOOLEAN__POINTER_STRING) (marshal_data ? marshal_data : cc->callback);
 381
 382   v_return = callback (data1,
 383                        g_marshal_value_peek_pointer (param_values + 1),
 384                        g_marshal_value_peek_string (param_values + 2),
 385                        data2);
 386
 387   g_value_set_boolean (return_value, v_return);
 388 }
 389
 390 /* BOOL:POINTER (gtkextra-marshal.list:9) */
 391 void
 392 gtkextra_BOOLEAN__POINTER (GClosure     *closure,
 393                            GValue       *return_value,
 394                            guint         n_param_values,
 395                            const GValue *param_values,
 396                            gpointer      invocation_hint,
 397                            gpointer      marshal_data)
 398 {
 399   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
 400                                                      gpointer     arg_1,
 401                                                      gpointer     data2);
 402   register GMarshalFunc_BOOLEAN__POINTER callback;
 403   register GCClosure *cc = (GCClosure*) closure;
 404   register gpointer data1, data2;
 405   gboolean v_return;
 406
 407   g_return_if_fail (return_value != NULL);
 408   g_return_if_fail (n_param_values == 2);
 409
 410   if (G_CCLOSURE_SWAP_DATA (closure))
 411     {
 412       data1 = closure->data;
 413       data2 = g_value_peek_pointer (param_values + 0);
 414     }
 415   else
 416     {
 417       data1 = g_value_peek_pointer (param_values + 0);
 418       data2 = closure->data;
 419     }
 420   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
 421
 422   v_return = callback (data1,
 423                        g_marshal_value_peek_pointer (param_values + 1),
 424                        data2);
 425
 426   g_value_set_boolean (return_value, v_return);
 427 }
 428
 429 /* BOOL:BOXED (gtkextra-marshal.list:10) */
 430 void
 431 gtkextra_BOOLEAN__BOXED (GClosure     *closure,
 432                          GValue       *return_value,
 433                          guint         n_param_values,
 434                          const GValue *param_values,
 435                          gpointer      invocation_hint,
 436                          gpointer      marshal_data)
 437 {
 438   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED) (gpointer     data1,
 439                                                    gpointer     arg_1,
 440                                                    gpointer     data2);
 441   register GMarshalFunc_BOOLEAN__BOXED callback;
 442   register GCClosure *cc = (GCClosure*) closure;
 443   register gpointer data1, data2;
 444   gboolean v_return;
 445
 446   g_return_if_fail (return_value != NULL);
 447   g_return_if_fail (n_param_values == 2);
 448
 449   if (G_CCLOSURE_SWAP_DATA (closure))
 450     {
 451       data1 = closure->data;
 452       data2 = g_value_peek_pointer (param_values + 0);
 453     }
 454   else
 455     {
 456       data1 = g_value_peek_pointer (param_values + 0);
 457       data2 = closure->data;
 458     }
 459   callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
 460
 461   v_return = callback (data1,
 462                        g_marshal_value_peek_boxed (param_values + 1),
 463                        data2);
 464
 465   g_value_set_boolean (return_value, v_return);
 466 }
 467
 468 /* BOOL:INT,INT (gtkextra-marshal.list:11) */
 469 void
 470 gtkextra_BOOLEAN__INT_INT (GClosure     *closure,
 471                            GValue       *return_value,
 472                            guint         n_param_values,
 473                            const GValue *param_values,
 474                            gpointer      invocation_hint,
 475                            gpointer      marshal_data)
 476 {
 477   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer     data1,
 478                                                      gint         arg_1,
 479                                                      gint         arg_2,
 480                                                      gpointer     data2);
 481   register GMarshalFunc_BOOLEAN__INT_INT callback;
 482   register GCClosure *cc = (GCClosure*) closure;
 483   register gpointer data1, data2;
 484   gboolean v_return;
 485
 486   g_return_if_fail (return_value != NULL);
 487   g_return_if_fail (n_param_values == 3);
 488
 489   if (G_CCLOSURE_SWAP_DATA (closure))
 490     {
 491       data1 = closure->data;
 492       data2 = g_value_peek_pointer (param_values + 0);
 493     }
 494   else
 495     {
 496       data1 = g_value_peek_pointer (param_values + 0);
 497       data2 = closure->data;
 498     }
 499   callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback);
 500
 501   v_return = callback (data1,
 502                        g_marshal_value_peek_int (param_values + 1),
 503                        g_marshal_value_peek_int (param_values + 2),
 504                        data2);
 505
 506   g_value_set_boolean (return_value, v_return);
 507 }
 508
 509 /* VOID:INT (gtkextra-marshal.list:12) */
 510
 511 /* VOID:INT,STRING (gtkextra-marshal.list:13) */
 512 void
 513 gtkextra_VOID__INT_STRING (GClosure     *closure,
 514                            GValue       *return_value,
 515                            guint         n_param_values,
 516                            const GValue *param_values,
 517                            gpointer      invocation_hint,
 518                            gpointer      marshal_data)
 519 {
 520   typedef void (*GMarshalFunc_VOID__INT_STRING) (gpointer     data1,
 521                                                  gint         arg_1,
 522                                                  gpointer     arg_2,
 523                                                  gpointer     data2);
 524   register GMarshalFunc_VOID__INT_STRING callback;
 525   register GCClosure *cc = (GCClosure*) closure;
 526   register gpointer data1, data2;
 527
 528   g_return_if_fail (n_param_values == 3);
 529
 530   if (G_CCLOSURE_SWAP_DATA (closure))
 531     {
 532       data1 = closure->data;
 533       data2 = g_value_peek_pointer (param_values + 0);
 534     }
 535   else
 536     {
 537       data1 = g_value_peek_pointer (param_values + 0);
 538       data2 = closure->data;
 539     }
 540   callback = (GMarshalFunc_VOID__INT_STRING) (marshal_data ? marshal_data : cc->callback);
 541
 542   callback (data1,
 543             g_marshal_value_peek_int (param_values + 1),
 544             g_marshal_value_peek_string (param_values + 2),
 545             data2);
 546 }
 547
 548 /* VOID:BOXED (gtkextra-marshal.list:14) */
 549
 550 /* VOID:VOID (gtkextra-marshal.list:15) */
 551
 552 /* VOID:BOOL (gtkextra-marshal.list:16) */
 553
 554 /* VOID:POINTER (gtkextra-marshal.list:17) */
 555
 556 /* VOID:INT,INT (gtkextra-marshal.list:18) */
 557 void
 558 gtkextra_VOID__INT_INT (GClosure     *closure,
 559                         GValue       *return_value,
 560                         guint         n_param_values,
 561                         const GValue *param_values,
 562                         gpointer      invocation_hint,
 563                         gpointer      marshal_data)
 564 {
 565   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
 566                                               gint         arg_1,
 567                                               gint         arg_2,
 568                                               gpointer     data2);
 569   register GMarshalFunc_VOID__INT_INT callback;
 570   register GCClosure *cc = (GCClosure*) closure;
 571   register gpointer data1, data2;
 572
 573   g_return_if_fail (n_param_values == 3);
 574
 575   if (G_CCLOSURE_SWAP_DATA (closure))
 576     {
 577       data1 = closure->data;
 578       data2 = g_value_peek_pointer (param_values + 0);
 579     }
 580   else
 581     {
 582       data1 = g_value_peek_pointer (param_values + 0);
 583       data2 = closure->data;
 584     }
 585   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
 586
 587   callback (data1,
 588             g_marshal_value_peek_int (param_values + 1),
 589             g_marshal_value_peek_int (param_values + 2),
 590             data2);
 591 }
 592
 593 /* VOID:INT,POINTER (gtkextra-marshal.list:19) */
 594 void
 595 gtkextra_VOID__INT_POINTER (GClosure     *closure,
 596                             GValue       *return_value,
 597                             guint         n_param_values,
 598                             const GValue *param_values,
 599                             gpointer      invocation_hint,
 600                             gpointer      marshal_data)
 601 {
 602   typedef void (*GMarshalFunc_VOID__INT_POINTER) (gpointer     data1,
 603                                                   gint         arg_1,
 604                                                   gpointer     arg_2,
 605                                                   gpointer     data2);
 606   register GMarshalFunc_VOID__INT_POINTER callback;
 607   register GCClosure *cc = (GCClosure*) closure;
 608   register gpointer data1, data2;
 609
 610   g_return_if_fail (n_param_values == 3);
 611
 612   if (G_CCLOSURE_SWAP_DATA (closure))
 613     {
 614       data1 = closure->data;
 615       data2 = g_value_peek_pointer (param_values + 0);
 616     }
 617   else
 618     {
 619       data1 = g_value_peek_pointer (param_values + 0);
 620       data2 = closure->data;
 621     }
 622   callback = (GMarshalFunc_VOID__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
 623
 624   callback (data1,
 625             g_marshal_value_peek_int (param_values + 1),
 626             g_marshal_value_peek_pointer (param_values + 2),
 627             data2);
 628 }
 629
 630 /* VOID:INT,BOXED (gtkextra-marshal.list:20) */
 631 void
 632 gtkextra_VOID__INT_BOXED (GClosure     *closure,
 633                           GValue       *return_value,
 634                           guint         n_param_values,
 635                           const GValue *param_values,
 636                           gpointer      invocation_hint,
 637                           gpointer      marshal_data)
 638 {
 639   typedef void (*GMarshalFunc_VOID__INT_BOXED) (gpointer     data1,
 640                                                 gint         arg_1,
 641                                                 gpointer     arg_2,
 642                                                 gpointer     data2);
 643   register GMarshalFunc_VOID__INT_BOXED callback;
 644   register GCClosure *cc = (GCClosure*) closure;
 645   register gpointer data1, data2;
 646
 647   g_return_if_fail (n_param_values == 3);
 648
 649   if (G_CCLOSURE_SWAP_DATA (closure))
 650     {
 651       data1 = closure->data;
 652       data2 = g_value_peek_pointer (param_values + 0);
 653     }
 654   else
 655     {
 656       data1 = g_value_peek_pointer (param_values + 0);
 657       data2 = closure->data;
 658     }
 659   callback = (GMarshalFunc_VOID__INT_BOXED) (marshal_data ? marshal_data : cc->callback);
 660
 661   callback (data1,
 662             g_marshal_value_peek_int (param_values + 1),
 663             g_marshal_value_peek_boxed (param_values + 2),
 664             data2);
 665 }
 666
 667 /* VOID:POINTER,POINTER (gtkextra-marshal.list:21) */
 668 void
 669 gtkextra_VOID__POINTER_POINTER (GClosure     *closure,
 670                                 GValue       *return_value,
 671                                 guint         n_param_values,
 672                                 const GValue *param_values,
 673                                 gpointer      invocation_hint,
 674                                 gpointer      marshal_data)
 675 {
 676   typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer     data1,
 677                                                       gpointer     arg_1,
 678                                                       gpointer     arg_2,
 679                                                       gpointer     data2);
 680   register GMarshalFunc_VOID__POINTER_POINTER callback;
 681   register GCClosure *cc = (GCClosure*) closure;
 682   register gpointer data1, data2;
 683
 684   g_return_if_fail (n_param_values == 3);
 685
 686   if (G_CCLOSURE_SWAP_DATA (closure))
 687     {
 688       data1 = closure->data;
 689       data2 = g_value_peek_pointer (param_values + 0);
 690     }
 691   else
 692     {
 693       data1 = g_value_peek_pointer (param_values + 0);
 694       data2 = closure->data;
 695     }
 696   callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
 697
 698   callback (data1,
 699             g_marshal_value_peek_pointer (param_values + 1),
 700             g_marshal_value_peek_pointer (param_values + 2),
 701             data2);
 702 }
 703
 704 /* VOID:BOXED,POINTER (gtkextra-marshal.list:22) */
 705 void
 706 gtkextra_VOID__BOXED_POINTER (GClosure     *closure,
 707                               GValue       *return_value,
 708                               guint         n_param_values,
 709                               const GValue *param_values,
 710                               gpointer      invocation_hint,
 711                               gpointer      marshal_data)
 712 {
 713   typedef void (*GMarshalFunc_VOID__BOXED_POINTER) (gpointer     data1,
 714                                                     gpointer     arg_1,
 715                                                     gpointer     arg_2,
 716                                                     gpointer     data2);
 717   register GMarshalFunc_VOID__BOXED_POINTER callback;
 718   register GCClosure *cc = (GCClosure*) closure;
 719   register gpointer data1, data2;
 720
 721   g_return_if_fail (n_param_values == 3);
 722
 723   if (G_CCLOSURE_SWAP_DATA (closure))
 724     {
 725       data1 = closure->data;
 726       data2 = g_value_peek_pointer (param_values + 0);
 727     }
 728   else
 729     {
 730       data1 = g_value_peek_pointer (param_values + 0);
 731       data2 = closure->data;
 732     }
 733   callback = (GMarshalFunc_VOID__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
 734
 735   callback (data1,
 736             g_marshal_value_peek_boxed (param_values + 1),
 737             g_marshal_value_peek_pointer (param_values + 2),
 738             data2);
 739 }
 740
 741 /* VOID:BOXED,BOXED (gtkextra-marshal.list:23) */
 742 void
 743 gtkextra_VOID__BOXED_BOXED (GClosure     *closure,
 744                             GValue       *return_value,
 745                             guint         n_param_values,
 746                             const GValue *param_values,
 747                             gpointer      invocation_hint,
 748                             gpointer      marshal_data)
 749 {
 750   typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer     data1,
 751                                                   gpointer     arg_1,
 752                                                   gpointer     arg_2,
 753                                                   gpointer     data2);
 754   register GMarshalFunc_VOID__BOXED_BOXED callback;
 755   register GCClosure *cc = (GCClosure*) closure;
 756   register gpointer data1, data2;
 757
 758   g_return_if_fail (n_param_values == 3);
 759
 760   if (G_CCLOSURE_SWAP_DATA (closure))
 761     {
 762       data1 = closure->data;
 763       data2 = g_value_peek_pointer (param_values + 0);
 764     }
 765   else
 766     {
 767       data1 = g_value_peek_pointer (param_values + 0);
 768       data2 = closure->data;
 769     }
 770   callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
 771
 772   callback (data1,
 773             g_marshal_value_peek_boxed (param_values + 1),
 774             g_marshal_value_peek_boxed (param_values + 2),
 775             data2);
 776 }
 777
 778 /* VOID:OBJECT,OBJECT (gtkextra-marshal.list:24) */
 779 void
 780 gtkextra_VOID__OBJECT_OBJECT (GClosure     *closure,
 781                               GValue       *return_value,
 782                               guint         n_param_values,
 783                               const GValue *param_values,
 784                               gpointer      invocation_hint,
 785                               gpointer      marshal_data)
 786 {
 787   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
 788                                                     gpointer     arg_1,
 789                                                     gpointer     arg_2,
 790                                                     gpointer     data2);
 791   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
 792   register GCClosure *cc = (GCClosure*) closure;
 793   register gpointer data1, data2;
 794
 795   g_return_if_fail (n_param_values == 3);
 796
 797   if (G_CCLOSURE_SWAP_DATA (closure))
 798     {
 799       data1 = closure->data;
 800       data2 = g_value_peek_pointer (param_values + 0);
 801     }
 802   else
 803     {
 804       data1 = g_value_peek_pointer (param_values + 0);
 805       data2 = closure->data;
 806     }
 807   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
 808
 809   callback (data1,
 810             g_marshal_value_peek_object (param_values + 1),
 811             g_marshal_value_peek_object (param_values + 2),
 812             data2);
 813 }
 814
 815 /* VOID:DOUBLE,DOUBLE,DOUBLE,DOUBLE (gtkextra-marshal.list:25) */
 816 void
 817 gtkextra_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE (GClosure     *closure,
 818                                             GValue       *return_value,
 819                                             guint         n_param_values,
 820                                             const GValue *param_values,
 821                                             gpointer      invocation_hint,
 822                                             gpointer      marshal_data)
 823 {
 824   typedef void (*GMarshalFunc_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE) (gpointer     data1,
 825                                                                   gdouble      arg_1,
 826                                                                   gdouble      arg_2,
 827                                                                   gdouble      arg_3,
 828                                                                   gdouble      arg_4,
 829                                                                   gpointer     data2);
 830   register GMarshalFunc_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE callback;
 831   register GCClosure *cc = (GCClosure*) closure;
 832   register gpointer data1, data2;
 833
 834   g_return_if_fail (n_param_values == 5);
 835
 836   if (G_CCLOSURE_SWAP_DATA (closure))
 837     {
 838       data1 = closure->data;
 839       data2 = g_value_peek_pointer (param_values + 0);
 840     }
 841   else
 842     {
 843       data1 = g_value_peek_pointer (param_values + 0);
 844       data2 = closure->data;
 845     }
 846   callback = (GMarshalFunc_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE) (marshal_data ? marshal_data : cc->callback);
 847
 848   callback (data1,
 849             g_marshal_value_peek_double (param_values + 1),
 850             g_marshal_value_peek_double (param_values + 2),
 851             g_marshal_value_peek_double (param_values + 3),
 852             g_marshal_value_peek_double (param_values + 4),
 853             data2);
 854 }
 855