lib/gtksheet/gtkextra-marshal.c

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