1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 #ifdef G_ENABLE_DEBUG

    21 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)

    22 #define g_marshal_value_peek_char(v)     g_value_get_char (v)

    23 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)

    24 #define g_marshal_value_peek_int(v)      g_value_get_int (v)

    25 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)

    26 #define g_marshal_value_peek_long(v)     g_value_get_long (v)

    27 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)

    28 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)

    29 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)

    30 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)

    31 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)

    32 #define g_marshal_value_peek_float(v)    g_value_get_float (v)

    33 #define g_marshal_value_peek_double(v)   g_value_get_double (v)

    34 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)

    35 #define g_marshal_value_peek_param(v)    g_value_get_param (v)

    36 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)

    37 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)

    38 #define g_marshal_value_peek_object(v)   g_value_get_object (v)

    39 #else /* !G_ENABLE_DEBUG */

    40 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.

    41  *          Do not access GValues directly in your code. Instead, use the

    42  *          g_value_get_*() functions

    43  */

    44 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int

    45 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int

    46 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint

    47 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int

    48 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint

    49 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long

    50 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong

    51 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64

    52 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64

    53 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long

    54 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong

    55 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float

    56 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double

    57 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer

    58 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer

    59 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer

    60 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer

    61 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer

    62 #endif /* !G_ENABLE_DEBUG */

    63 

    64 

    65 /* VOID:VOID (./gmarshal.list:26) */

    66 EXPORT_C void

    67 g_cclosure_marshal_VOID__VOID (GClosure     *closure,

    68                                GValue       *return_value G_GNUC_UNUSED,

    69                                guint         n_param_values,

    70                                const GValue *param_values,

    71                                gpointer      invocation_hint G_GNUC_UNUSED,

    72                                gpointer      marshal_data)

    73 {

    74   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     data1,

    75                                            gpointer     data2);

    76   register GMarshalFunc_VOID__VOID callback;

    77   register GCClosure *cc = (GCClosure*) closure;

    78   register gpointer data1, data2;

    79 

    80   g_return_if_fail (n_param_values == 1);

    81 

    82   if (G_CCLOSURE_SWAP_DATA (closure))

    83     {

    84       data1 = closure->data;

    85       data2 = g_value_peek_pointer (param_values + 0);

    86     }

    87   else

    88     {

    89       data1 = g_value_peek_pointer (param_values + 0);

    90       data2 = closure->data;

    91     }

    92   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);

    93 

    94   callback (data1,

    95             data2);

    96 }

    97 

    98 /* VOID:BOOLEAN (./gmarshal.list:27) */

    99 EXPORT_C void

   100 g_cclosure_marshal_VOID__BOOLEAN (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__BOOLEAN) (gpointer     data1,

   108                                               gboolean     arg_1,

   109                                               gpointer     data2);

   110   register GMarshalFunc_VOID__BOOLEAN callback;

   111   register GCClosure *cc = (GCClosure*) closure;

   112   register gpointer data1, data2;

   113 

   114   g_return_if_fail (n_param_values == 2);

   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_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);

   127 

   128   callback (data1,

   129             g_marshal_value_peek_boolean (param_values + 1),

   130             data2);

   131 }

   132 

   133 /* VOID:CHAR (./gmarshal.list:28) */

   134 EXPORT_C void

   135 g_cclosure_marshal_VOID__CHAR (GClosure     *closure,

   136                                GValue       *return_value G_GNUC_UNUSED,

   137                                guint         n_param_values,

   138                                const GValue *param_values,

   139                                gpointer      invocation_hint G_GNUC_UNUSED,

   140                                gpointer      marshal_data)

   141 {

   142   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     data1,

   143                                            gchar        arg_1,

   144                                            gpointer     data2);

   145   register GMarshalFunc_VOID__CHAR callback;

   146   register GCClosure *cc = (GCClosure*) closure;

   147   register gpointer data1, data2;

   148 

   149   g_return_if_fail (n_param_values == 2);

   150 

   151   if (G_CCLOSURE_SWAP_DATA (closure))

   152     {

   153       data1 = closure->data;

   154       data2 = g_value_peek_pointer (param_values + 0);

   155     }

   156   else

   157     {

   158       data1 = g_value_peek_pointer (param_values + 0);

   159       data2 = closure->data;

   160     }

   161   callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);

   162 

   163   callback (data1,

   164             g_marshal_value_peek_char (param_values + 1),

   165             data2);

   166 }

   167 

   168 /* VOID:UCHAR (./gmarshal.list:29) */

   169 EXPORT_C void

   170 g_cclosure_marshal_VOID__UCHAR (GClosure     *closure,

   171                                 GValue       *return_value G_GNUC_UNUSED,

   172                                 guint         n_param_values,

   173                                 const GValue *param_values,

   174                                 gpointer      invocation_hint G_GNUC_UNUSED,

   175                                 gpointer      marshal_data)

   176 {

   177   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     data1,

   178                                             guchar       arg_1,

   179                                             gpointer     data2);

   180   register GMarshalFunc_VOID__UCHAR callback;

   181   register GCClosure *cc = (GCClosure*) closure;

   182   register gpointer data1, data2;

   183 

   184   g_return_if_fail (n_param_values == 2);

   185 

   186   if (G_CCLOSURE_SWAP_DATA (closure))

   187     {

   188       data1 = closure->data;

   189       data2 = g_value_peek_pointer (param_values + 0);

   190     }

   191   else

   192     {

   193       data1 = g_value_peek_pointer (param_values + 0);

   194       data2 = closure->data;

   195     }

   196   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);

   197 

   198   callback (data1,

   199             g_marshal_value_peek_uchar (param_values + 1),

   200             data2);

   201 }

   202 

   203 /* VOID:INT (./gmarshal.list:30) */

   204 EXPORT_C void

   205 g_cclosure_marshal_VOID__INT (GClosure     *closure,

   206                               GValue       *return_value G_GNUC_UNUSED,

   207                               guint         n_param_values,

   208                               const GValue *param_values,

   209                               gpointer      invocation_hint G_GNUC_UNUSED,

   210                               gpointer      marshal_data)

   211 {

   212   typedef void (*GMarshalFunc_VOID__INT) (gpointer     data1,

   213                                           gint         arg_1,

   214                                           gpointer     data2);

   215   register GMarshalFunc_VOID__INT callback;

   216   register GCClosure *cc = (GCClosure*) closure;

   217   register gpointer data1, data2;

   218 

   219   g_return_if_fail (n_param_values == 2);

   220 

   221   if (G_CCLOSURE_SWAP_DATA (closure))

   222     {

   223       data1 = closure->data;

   224       data2 = g_value_peek_pointer (param_values + 0);

   225     }

   226   else

   227     {

   228       data1 = g_value_peek_pointer (param_values + 0);

   229       data2 = closure->data;

   230     }

   231   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);

   232 

   233   callback (data1,

   234             g_marshal_value_peek_int (param_values + 1),

   235             data2);

   236 }

   237 

   238 /* VOID:UINT (./gmarshal.list:31) */

   239 EXPORT_C void

   240 g_cclosure_marshal_VOID__UINT (GClosure     *closure,

   241                                GValue       *return_value G_GNUC_UNUSED,

   242                                guint         n_param_values,

   243                                const GValue *param_values,

   244                                gpointer      invocation_hint G_GNUC_UNUSED,

   245                                gpointer      marshal_data)

   246 {

   247   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     data1,

   248                                            guint        arg_1,

   249                                            gpointer     data2);

   250   register GMarshalFunc_VOID__UINT callback;

   251   register GCClosure *cc = (GCClosure*) closure;

   252   register gpointer data1, data2;

   253 

   254   g_return_if_fail (n_param_values == 2);

   255 

   256   if (G_CCLOSURE_SWAP_DATA (closure))

   257     {

   258       data1 = closure->data;

   259       data2 = g_value_peek_pointer (param_values + 0);

   260     }

   261   else

   262     {

   263       data1 = g_value_peek_pointer (param_values + 0);

   264       data2 = closure->data;

   265     }

   266   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);

   267 

   268   callback (data1,

   269             g_marshal_value_peek_uint (param_values + 1),

   270             data2);

   271 }

   272 

   273 /* VOID:LONG (./gmarshal.list:32) */

   274 EXPORT_C void

   275 g_cclosure_marshal_VOID__LONG (GClosure     *closure,

   276                                GValue       *return_value G_GNUC_UNUSED,

   277                                guint         n_param_values,

   278                                const GValue *param_values,

   279                                gpointer      invocation_hint G_GNUC_UNUSED,

   280                                gpointer      marshal_data)

   281 {

   282   typedef void (*GMarshalFunc_VOID__LONG) (gpointer     data1,

   283                                            glong        arg_1,

   284                                            gpointer     data2);

   285   register GMarshalFunc_VOID__LONG callback;

   286   register GCClosure *cc = (GCClosure*) closure;

   287   register gpointer data1, data2;

   288 

   289   g_return_if_fail (n_param_values == 2);

   290 

   291   if (G_CCLOSURE_SWAP_DATA (closure))

   292     {

   293       data1 = closure->data;

   294       data2 = g_value_peek_pointer (param_values + 0);

   295     }

   296   else

   297     {

   298       data1 = g_value_peek_pointer (param_values + 0);

   299       data2 = closure->data;

   300     }

   301   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);

   302 

   303   callback (data1,

   304             g_marshal_value_peek_long (param_values + 1),

   305             data2);

   306 }

   307 

   308 /* VOID:ULONG (./gmarshal.list:33) */

   309 EXPORT_C void

   310 g_cclosure_marshal_VOID__ULONG (GClosure     *closure,

   311                                 GValue       *return_value G_GNUC_UNUSED,

   312                                 guint         n_param_values,

   313                                 const GValue *param_values,

   314                                 gpointer      invocation_hint G_GNUC_UNUSED,

   315                                 gpointer      marshal_data)

   316 {

   317   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     data1,

   318                                             gulong       arg_1,

   319                                             gpointer     data2);

   320   register GMarshalFunc_VOID__ULONG callback;

   321   register GCClosure *cc = (GCClosure*) closure;

   322   register gpointer data1, data2;

   323 

   324   g_return_if_fail (n_param_values == 2);

   325 

   326   if (G_CCLOSURE_SWAP_DATA (closure))

   327     {

   328       data1 = closure->data;

   329       data2 = g_value_peek_pointer (param_values + 0);

   330     }

   331   else

   332     {

   333       data1 = g_value_peek_pointer (param_values + 0);

   334       data2 = closure->data;

   335     }

   336   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);

   337 

   338   callback (data1,

   339             g_marshal_value_peek_ulong (param_values + 1),

   340             data2);

   341 }

   342 

   343 /* VOID:ENUM (./gmarshal.list:34) */

   344 EXPORT_C void

   345 g_cclosure_marshal_VOID__ENUM (GClosure     *closure,

   346                                GValue       *return_value G_GNUC_UNUSED,

   347                                guint         n_param_values,

   348                                const GValue *param_values,

   349                                gpointer      invocation_hint G_GNUC_UNUSED,

   350                                gpointer      marshal_data)

   351 {

   352   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     data1,

   353                                            gint         arg_1,

   354                                            gpointer     data2);

   355   register GMarshalFunc_VOID__ENUM callback;

   356   register GCClosure *cc = (GCClosure*) closure;

   357   register gpointer data1, data2;

   358 

   359   g_return_if_fail (n_param_values == 2);

   360 

   361   if (G_CCLOSURE_SWAP_DATA (closure))

   362     {

   363       data1 = closure->data;

   364       data2 = g_value_peek_pointer (param_values + 0);

   365     }

   366   else

   367     {

   368       data1 = g_value_peek_pointer (param_values + 0);

   369       data2 = closure->data;

   370     }

   371   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);

   372 

   373   callback (data1,

   374             g_marshal_value_peek_enum (param_values + 1),

   375             data2);

   376 }

   377 

   378 /* VOID:FLAGS (./gmarshal.list:35) */

   379 EXPORT_C void

   380 g_cclosure_marshal_VOID__FLAGS (GClosure     *closure,

   381                                 GValue       *return_value G_GNUC_UNUSED,

   382                                 guint         n_param_values,

   383                                 const GValue *param_values,

   384                                 gpointer      invocation_hint G_GNUC_UNUSED,

   385                                 gpointer      marshal_data)

   386 {

   387   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     data1,

   388                                             guint        arg_1,

   389                                             gpointer     data2);

   390   register GMarshalFunc_VOID__FLAGS callback;

   391   register GCClosure *cc = (GCClosure*) closure;

   392   register gpointer data1, data2;

   393 

   394   g_return_if_fail (n_param_values == 2);

   395 

   396   if (G_CCLOSURE_SWAP_DATA (closure))

   397     {

   398       data1 = closure->data;

   399       data2 = g_value_peek_pointer (param_values + 0);

   400     }

   401   else

   402     {

   403       data1 = g_value_peek_pointer (param_values + 0);

   404       data2 = closure->data;

   405     }

   406   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);

   407 

   408   callback (data1,

   409             g_marshal_value_peek_flags (param_values + 1),

   410             data2);

   411 }

   412 

   413 /* VOID:FLOAT (./gmarshal.list:36) */

   414 EXPORT_C void

   415 g_cclosure_marshal_VOID__FLOAT (GClosure     *closure,

   416                                 GValue       *return_value G_GNUC_UNUSED,

   417                                 guint         n_param_values,

   418                                 const GValue *param_values,

   419                                 gpointer      invocation_hint G_GNUC_UNUSED,

   420                                 gpointer      marshal_data)

   421 {

   422   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     data1,

   423                                             gfloat       arg_1,

   424                                             gpointer     data2);

   425   register GMarshalFunc_VOID__FLOAT callback;

   426   register GCClosure *cc = (GCClosure*) closure;

   427   register gpointer data1, data2;

   428 

   429   g_return_if_fail (n_param_values == 2);

   430 

   431   if (G_CCLOSURE_SWAP_DATA (closure))

   432     {

   433       data1 = closure->data;

   434       data2 = g_value_peek_pointer (param_values + 0);

   435     }

   436   else

   437     {

   438       data1 = g_value_peek_pointer (param_values + 0);

   439       data2 = closure->data;

   440     }

   441   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);

   442 

   443   callback (data1,

   444             g_marshal_value_peek_float (param_values + 1),

   445             data2);

   446 }

   447 

   448 /* VOID:DOUBLE (./gmarshal.list:37) */

   449 EXPORT_C void

   450 g_cclosure_marshal_VOID__DOUBLE (GClosure     *closure,

   451                                  GValue       *return_value G_GNUC_UNUSED,

   452                                  guint         n_param_values,

   453                                  const GValue *param_values,

   454                                  gpointer      invocation_hint G_GNUC_UNUSED,

   455                                  gpointer      marshal_data)

   456 {

   457   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     data1,

   458                                              gdouble      arg_1,

   459                                              gpointer     data2);

   460   register GMarshalFunc_VOID__DOUBLE callback;

   461   register GCClosure *cc = (GCClosure*) closure;

   462   register gpointer data1, data2;

   463 

   464   g_return_if_fail (n_param_values == 2);

   465 

   466   if (G_CCLOSURE_SWAP_DATA (closure))

   467     {

   468       data1 = closure->data;

   469       data2 = g_value_peek_pointer (param_values + 0);

   470     }

   471   else

   472     {

   473       data1 = g_value_peek_pointer (param_values + 0);

   474       data2 = closure->data;

   475     }

   476   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);

   477 

   478   callback (data1,

   479             g_marshal_value_peek_double (param_values + 1),

   480             data2);

   481 }

   482 

   483 /* VOID:STRING (./gmarshal.list:38) */

   484 EXPORT_C void

   485 g_cclosure_marshal_VOID__STRING (GClosure     *closure,

   486                                  GValue       *return_value G_GNUC_UNUSED,

   487                                  guint         n_param_values,

   488                                  const GValue *param_values,

   489                                  gpointer      invocation_hint G_GNUC_UNUSED,

   490                                  gpointer      marshal_data)

   491 {

   492   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     data1,

   493                                              gpointer     arg_1,

   494                                              gpointer     data2);

   495   register GMarshalFunc_VOID__STRING callback;

   496   register GCClosure *cc = (GCClosure*) closure;

   497   register gpointer data1, data2;

   498 

   499   g_return_if_fail (n_param_values == 2);

   500 

   501   if (G_CCLOSURE_SWAP_DATA (closure))

   502     {

   503       data1 = closure->data;

   504       data2 = g_value_peek_pointer (param_values + 0);

   505     }

   506   else

   507     {

   508       data1 = g_value_peek_pointer (param_values + 0);

   509       data2 = closure->data;

   510     }

   511   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);

   512 

   513   callback (data1,

   514             g_marshal_value_peek_string (param_values + 1),

   515             data2);

   516 }

   517 

   518 /* VOID:PARAM (./gmarshal.list:39) */

   519 EXPORT_C void

   520 g_cclosure_marshal_VOID__PARAM (GClosure     *closure,

   521                                 GValue       *return_value G_GNUC_UNUSED,

   522                                 guint         n_param_values,

   523                                 const GValue *param_values,

   524                                 gpointer      invocation_hint G_GNUC_UNUSED,

   525                                 gpointer      marshal_data)

   526 {

   527   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     data1,

   528                                             gpointer     arg_1,

   529                                             gpointer     data2);

   530   register GMarshalFunc_VOID__PARAM callback;

   531   register GCClosure *cc = (GCClosure*) closure;

   532   register gpointer data1, data2;

   533 

   534   g_return_if_fail (n_param_values == 2);

   535 

   536   if (G_CCLOSURE_SWAP_DATA (closure))

   537     {

   538       data1 = closure->data;

   539       data2 = g_value_peek_pointer (param_values + 0);

   540     }

   541   else

   542     {

   543       data1 = g_value_peek_pointer (param_values + 0);

   544       data2 = closure->data;

   545     }

   546   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);

   547 

   548   callback (data1,

   549             g_marshal_value_peek_param (param_values + 1),

   550             data2);

   551 }

   552 

   553 /* VOID:BOXED (./gmarshal.list:40) */

   554 EXPORT_C void

   555 g_cclosure_marshal_VOID__BOXED (GClosure     *closure,

   556                                 GValue       *return_value G_GNUC_UNUSED,

   557                                 guint         n_param_values,

   558                                 const GValue *param_values,

   559                                 gpointer      invocation_hint G_GNUC_UNUSED,

   560                                 gpointer      marshal_data)

   561 {

   562   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     data1,

   563                                             gpointer     arg_1,

   564                                             gpointer     data2);

   565   register GMarshalFunc_VOID__BOXED callback;

   566   register GCClosure *cc = (GCClosure*) closure;

   567   register gpointer data1, data2;

   568 

   569   g_return_if_fail (n_param_values == 2);

   570 

   571   if (G_CCLOSURE_SWAP_DATA (closure))

   572     {

   573       data1 = closure->data;

   574       data2 = g_value_peek_pointer (param_values + 0);

   575     }

   576   else

   577     {

   578       data1 = g_value_peek_pointer (param_values + 0);

   579       data2 = closure->data;

   580     }

   581   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);

   582 

   583   callback (data1,

   584             g_marshal_value_peek_boxed (param_values + 1),

   585             data2);

   586 }

   587 

   588 /* VOID:POINTER (./gmarshal.list:41) */

   589 EXPORT_C void

   590 g_cclosure_marshal_VOID__POINTER (GClosure     *closure,

   591                                   GValue       *return_value G_GNUC_UNUSED,

   592                                   guint         n_param_values,

   593                                   const GValue *param_values,

   594                                   gpointer      invocation_hint G_GNUC_UNUSED,

   595                                   gpointer      marshal_data)

   596 {

   597   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     data1,

   598                                               gpointer     arg_1,

   599                                               gpointer     data2);

   600   register GMarshalFunc_VOID__POINTER callback;

   601   register GCClosure *cc = (GCClosure*) closure;

   602   register gpointer data1, data2;

   603 

   604   g_return_if_fail (n_param_values == 2);

   605 

   606   if (G_CCLOSURE_SWAP_DATA (closure))

   607     {

   608       data1 = closure->data;

   609       data2 = g_value_peek_pointer (param_values + 0);

   610     }

   611   else

   612     {

   613       data1 = g_value_peek_pointer (param_values + 0);

   614       data2 = closure->data;

   615     }

   616   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);

   617 

   618   callback (data1,

   619             g_marshal_value_peek_pointer (param_values + 1),

   620             data2);

   621 }

   622 

   623 /* VOID:OBJECT (./gmarshal.list:42) */

   624 EXPORT_C void

   625 g_cclosure_marshal_VOID__OBJECT (GClosure     *closure,

   626                                  GValue       *return_value G_GNUC_UNUSED,

   627                                  guint         n_param_values,

   628                                  const GValue *param_values,

   629                                  gpointer      invocation_hint G_GNUC_UNUSED,

   630                                  gpointer      marshal_data)

   631 {

   632   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     data1,

   633                                              gpointer     arg_1,

   634                                              gpointer     data2);

   635   register GMarshalFunc_VOID__OBJECT callback;

   636   register GCClosure *cc = (GCClosure*) closure;

   637   register gpointer data1, data2;

   638 

   639   g_return_if_fail (n_param_values == 2);

   640 

   641   if (G_CCLOSURE_SWAP_DATA (closure))

   642     {

   643       data1 = closure->data;

   644       data2 = g_value_peek_pointer (param_values + 0);

   645     }

   646   else

   647     {

   648       data1 = g_value_peek_pointer (param_values + 0);

   649       data2 = closure->data;

   650     }

   651   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);

   652 

   653   callback (data1,

   654             g_marshal_value_peek_object (param_values + 1),

   655             data2);

   656 }

   657 

   658 /* VOID:UINT,POINTER (./gmarshal.list:45) */

   659 EXPORT_C void

   660 g_cclosure_marshal_VOID__UINT_POINTER (GClosure     *closure,

   661                                        GValue       *return_value G_GNUC_UNUSED,

   662                                        guint         n_param_values,

   663                                        const GValue *param_values,

   664                                        gpointer      invocation_hint G_GNUC_UNUSED,

   665                                        gpointer      marshal_data)

   666 {

   667   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     data1,

   668                                                    guint        arg_1,

   669                                                    gpointer     arg_2,

   670                                                    gpointer     data2);

   671   register GMarshalFunc_VOID__UINT_POINTER callback;

   672   register GCClosure *cc = (GCClosure*) closure;

   673   register gpointer data1, data2;

   674 

   675   g_return_if_fail (n_param_values == 3);

   676 

   677   if (G_CCLOSURE_SWAP_DATA (closure))

   678     {

   679       data1 = closure->data;

   680       data2 = g_value_peek_pointer (param_values + 0);

   681     }

   682   else

   683     {

   684       data1 = g_value_peek_pointer (param_values + 0);

   685       data2 = closure->data;

   686     }

   687   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);

   688 

   689   callback (data1,

   690             g_marshal_value_peek_uint (param_values + 1),

   691             g_marshal_value_peek_pointer (param_values + 2),

   692             data2);

   693 }

   694 

   695 /* BOOL:FLAGS (./gmarshal.list:46) */

   696 EXPORT_C void

   697 g_cclosure_marshal_BOOLEAN__FLAGS (GClosure     *closure,

   698                                    GValue       *return_value G_GNUC_UNUSED,

   699                                    guint         n_param_values,

   700                                    const GValue *param_values,

   701                                    gpointer      invocation_hint G_GNUC_UNUSED,

   702                                    gpointer      marshal_data)

   703 {

   704   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     data1,

   705                                                    guint        arg_1,

   706                                                    gpointer     data2);

   707   register GMarshalFunc_BOOLEAN__FLAGS callback;

   708   register GCClosure *cc = (GCClosure*) closure;

   709   register gpointer data1, data2;

   710   gboolean v_return;

   711 

   712   g_return_if_fail (return_value != NULL);

   713   g_return_if_fail (n_param_values == 2);

   714 

   715   if (G_CCLOSURE_SWAP_DATA (closure))

   716     {

   717       data1 = closure->data;

   718       data2 = g_value_peek_pointer (param_values + 0);

   719     }

   720   else

   721     {

   722       data1 = g_value_peek_pointer (param_values + 0);

   723       data2 = closure->data;

   724     }

   725   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);

   726 

   727   v_return = callback (data1,

   728                        g_marshal_value_peek_flags (param_values + 1),

   729                        data2);

   730 

   731   g_value_set_boolean (return_value, v_return);

   732 }

   733 

   734 /* STRING:OBJECT,POINTER (./gmarshal.list:47) */

   735 EXPORT_C void

   736 g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure     *closure,

   737                                            GValue       *return_value G_GNUC_UNUSED,

   738                                            guint         n_param_values,

   739                                            const GValue *param_values,

   740                                            gpointer      invocation_hint G_GNUC_UNUSED,

   741                                            gpointer      marshal_data)

   742 {

   743   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     data1,

   744                                                          gpointer     arg_1,

   745                                                          gpointer     arg_2,

   746                                                          gpointer     data2);

   747   register GMarshalFunc_STRING__OBJECT_POINTER callback;

   748   register GCClosure *cc = (GCClosure*) closure;

   749   register gpointer data1, data2;

   750   gchar* v_return;

   751 

   752   g_return_if_fail (return_value != NULL);

   753   g_return_if_fail (n_param_values == 3);

   754 

   755   if (G_CCLOSURE_SWAP_DATA (closure))

   756     {

   757       data1 = closure->data;

   758       data2 = g_value_peek_pointer (param_values + 0);

   759     }

   760   else

   761     {

   762       data1 = g_value_peek_pointer (param_values + 0);

   763       data2 = closure->data;

   764     }

   765   callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);

   766 

   767   v_return = callback (data1,

   768                        g_marshal_value_peek_object (param_values + 1),

   769                        g_marshal_value_peek_pointer (param_values + 2),

   770                        data2);

   771 

   772   g_value_take_string (return_value, v_return);

   773 }

   774