lib/gtksheet/gtkextra-marshal.c

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