src/ibusmarshalers.c

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