LCOV - code coverage report
Current view: top level - glib/gobject - gmarshal.c (source / functions) Hit Total Coverage
Test: unnamed Lines: 114 552 20.7 %
Date: 2024-05-21 07:38:11 Functions: 12 44 27.3 %
Branches: 40 232 17.2 %

           Branch data     Line data    Source code
       1                 :            : /* GObject - GLib Type, Object, Parameter and Signal Library
       2                 :            :  *
       3                 :            :  * This library is free software; you can redistribute it and/or
       4                 :            :  * modify it under the terms of the GNU Lesser General Public
       5                 :            :  * License as published by the Free Software Foundation; either
       6                 :            :  * version 2.1 of the License, or (at your option) any later version.
       7                 :            :  *
       8                 :            :  * This library is distributed in the hope that it will be useful,
       9                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      10                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      11                 :            :  * Lesser General Public License for more details.
      12                 :            :  *
      13                 :            :  * You should have received a copy of the GNU Lesser General
      14                 :            :  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
      15                 :            :  */
      16                 :            : 
      17                 :            : #include "config.h"
      18                 :            : 
      19                 :            : #include "gobject.h"
      20                 :            : #include "genums.h"
      21                 :            : #include "gboxed.h"
      22                 :            : #include "gvaluetypes.h"
      23                 :            : 
      24                 :            : 
      25                 :            : #ifdef G_ENABLE_DEBUG
      26                 :            : #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
      27                 :            : #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
      28                 :            : #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
      29                 :            : #define g_marshal_value_peek_int(v)      g_value_get_int (v)
      30                 :            : #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
      31                 :            : #define g_marshal_value_peek_long(v)     g_value_get_long (v)
      32                 :            : #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
      33                 :            : #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
      34                 :            : #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
      35                 :            : #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
      36                 :            : #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
      37                 :            : #define g_marshal_value_peek_float(v)    g_value_get_float (v)
      38                 :            : #define g_marshal_value_peek_double(v)   g_value_get_double (v)
      39                 :            : #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
      40                 :            : #define g_marshal_value_peek_param(v)    g_value_get_param (v)
      41                 :            : #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
      42                 :            : #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
      43                 :            : #define g_marshal_value_peek_object(v)   g_value_get_object (v)
      44                 :            : #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
      45                 :            : #else /* !G_ENABLE_DEBUG */
      46                 :            : /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
      47                 :            :  *          Do not access GValues directly in your code. Instead, use the
      48                 :            :  *          g_value_get_*() functions
      49                 :            :  */
      50                 :            : #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
      51                 :            : #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
      52                 :            : #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
      53                 :            : #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
      54                 :            : #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
      55                 :            : #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
      56                 :            : #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
      57                 :            : #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
      58                 :            : #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
      59                 :            : #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
      60                 :            : #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
      61                 :            : #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
      62                 :            : #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
      63                 :            : #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
      64                 :            : #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
      65                 :            : #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
      66                 :            : #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
      67                 :            : #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
      68                 :            : #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
      69                 :            : #endif /* !G_ENABLE_DEBUG */
      70                 :            : 
      71                 :            : 
      72                 :            : /**
      73                 :            :  * g_cclosure_marshal_VOID__VOID:
      74                 :            :  * @closure: A #GClosure.
      75                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
      76                 :            :  *   if the callback of closure doesn't return a value.
      77                 :            :  * @n_param_values: The length of the @param_values array.
      78                 :            :  * @param_values: An array of #GValues holding the arguments
      79                 :            :  *   on which to invoke the callback of closure.
      80                 :            :  * @invocation_hint: The invocation hint given as the last argument to
      81                 :            :  *   g_closure_invoke().
      82                 :            :  * @marshal_data: Additional data specified when registering the
      83                 :            :  *   marshaller, see g_closure_set_marshal() and
      84                 :            :  *   g_closure_set_meta_marshal()
      85                 :            :  *
      86                 :            :  * A #GClosureMarshal function for use with signals with no arguments.
      87                 :            :  */
      88                 :            : /* VOID:VOID */
      89                 :            : void
      90                 :     390185 : g_cclosure_marshal_VOID__VOID (GClosure     *closure,
      91                 :            :                                GValue       *return_value G_GNUC_UNUSED,
      92                 :            :                                guint         n_param_values,
      93                 :            :                                const GValue *param_values,
      94                 :            :                                gpointer      invocation_hint G_GNUC_UNUSED,
      95                 :            :                                gpointer      marshal_data)
      96                 :            : {
      97                 :            :   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     data1,
      98                 :            :                                            gpointer     data2);
      99                 :            :   GMarshalFunc_VOID__VOID callback;
     100                 :     390185 :   GCClosure *cc = (GCClosure*) closure;
     101                 :            :   gpointer data1, data2;
     102                 :            : 
     103                 :     390185 :   g_return_if_fail (n_param_values == 1);
     104                 :            : 
     105         [ -  + ]:     390185 :   if (G_CCLOSURE_SWAP_DATA (closure))
     106                 :            :     {
     107                 :          0 :       data1 = closure->data;
     108                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     109                 :            :     }
     110                 :            :   else
     111                 :            :     {
     112                 :     390185 :       data1 = g_value_peek_pointer (param_values + 0);
     113                 :     390174 :       data2 = closure->data;
     114                 :            :     }
     115         [ +  + ]:     390174 :   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
     116                 :            : 
     117                 :     390174 :   callback (data1,
     118                 :            :             data2);
     119                 :            : }
     120                 :            : 
     121                 :            : /**
     122                 :            :  * g_cclosure_marshal_VOID__VOIDv:
     123                 :            :  * @closure: the #GClosure to which the marshaller belongs
     124                 :            :  * @return_value: (nullable): a #GValue to store the return
     125                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     126                 :            :  *  value.
     127                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     128                 :            :  * @args: va_list of arguments to be passed to the closure.
     129                 :            :  * @marshal_data: (nullable): additional data specified when
     130                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     131                 :            :  *  g_closure_set_meta_marshal()
     132                 :            :  * @n_params: the length of the @param_types array
     133                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     134                 :            :  *  @args.
     135                 :            :  *
     136                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID().
     137                 :            :  */
     138                 :            : void
     139                 :     220790 : g_cclosure_marshal_VOID__VOIDv (GClosure     *closure,
     140                 :            :                                 GValue       *return_value,
     141                 :            :                                 gpointer      instance,
     142                 :            :                                 va_list       args,
     143                 :            :                                 gpointer      marshal_data,
     144                 :            :                                 int           n_params,
     145                 :            :                                 GType        *param_types)
     146                 :            : {
     147                 :            :   typedef void (*GMarshalFunc_VOID__VOID) (gpointer     instance,
     148                 :            :                                            gpointer     data);
     149                 :     220790 :   GCClosure *cc = (GCClosure*) closure;
     150                 :            :   gpointer data1, data2;
     151                 :            :   GMarshalFunc_VOID__VOID callback;
     152                 :            : 
     153         [ -  + ]:     220790 :   if (G_CCLOSURE_SWAP_DATA (closure))
     154                 :            :     {
     155                 :          0 :       data1 = closure->data;
     156                 :          0 :       data2 = instance;
     157                 :            :     }
     158                 :            :   else
     159                 :            :     {
     160                 :     220790 :       data1 = instance;
     161                 :     220790 :       data2 = closure->data;
     162                 :            :     }
     163         [ +  + ]:     220790 :   callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
     164                 :            : 
     165                 :     220790 :   callback (data1,
     166                 :            :             data2);
     167                 :     220788 : }
     168                 :            : 
     169                 :            : /**
     170                 :            :  * g_cclosure_marshal_VOID__BOOLEAN:
     171                 :            :  * @closure: A #GClosure.
     172                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     173                 :            :  *   if the callback of closure doesn't return a value.
     174                 :            :  * @n_param_values: The length of the @param_values array.
     175                 :            :  * @param_values: An array of #GValues holding the arguments
     176                 :            :  *   on which to invoke the callback of closure.
     177                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     178                 :            :  *   g_closure_invoke().
     179                 :            :  * @marshal_data: Additional data specified when registering the
     180                 :            :  *   marshaller, see g_closure_set_marshal() and
     181                 :            :  *   g_closure_set_meta_marshal()
     182                 :            :  *
     183                 :            :  * A #GClosureMarshal function for use with signals with a single
     184                 :            :  * boolean argument.
     185                 :            :  */
     186                 :            : /* VOID:BOOLEAN */
     187                 :            : void
     188                 :         21 : g_cclosure_marshal_VOID__BOOLEAN (GClosure     *closure,
     189                 :            :                                   GValue       *return_value G_GNUC_UNUSED,
     190                 :            :                                   guint         n_param_values,
     191                 :            :                                   const GValue *param_values,
     192                 :            :                                   gpointer      invocation_hint G_GNUC_UNUSED,
     193                 :            :                                   gpointer      marshal_data)
     194                 :            : {
     195                 :            :   typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer     data1,
     196                 :            :                                               gboolean     arg_1,
     197                 :            :                                               gpointer     data2);
     198                 :            :   GMarshalFunc_VOID__BOOLEAN callback;
     199                 :         21 :   GCClosure *cc = (GCClosure*) closure;
     200                 :            :   gpointer data1, data2;
     201                 :            : 
     202                 :         21 :   g_return_if_fail (n_param_values == 2);
     203                 :            : 
     204         [ -  + ]:         21 :   if (G_CCLOSURE_SWAP_DATA (closure))
     205                 :            :     {
     206                 :          0 :       data1 = closure->data;
     207                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     208                 :            :     }
     209                 :            :   else
     210                 :            :     {
     211                 :         21 :       data1 = g_value_peek_pointer (param_values + 0);
     212                 :         21 :       data2 = closure->data;
     213                 :            :     }
     214         [ +  - ]:         21 :   callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
     215                 :            : 
     216                 :         21 :   callback (data1,
     217                 :            :             g_marshal_value_peek_boolean (param_values + 1),
     218                 :            :             data2);
     219                 :            : }
     220                 :            : 
     221                 :            : /**
     222                 :            :  * g_cclosure_marshal_VOID__BOOLEANv:
     223                 :            :  * @closure: the #GClosure to which the marshaller belongs
     224                 :            :  * @return_value: (nullable): a #GValue to store the return
     225                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     226                 :            :  *  value.
     227                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     228                 :            :  * @args: va_list of arguments to be passed to the closure.
     229                 :            :  * @marshal_data: (nullable): additional data specified when
     230                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     231                 :            :  *  g_closure_set_meta_marshal()
     232                 :            :  * @n_params: the length of the @param_types array
     233                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     234                 :            :  *  @args.
     235                 :            :  *
     236                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN().
     237                 :            :  */
     238                 :            : void
     239                 :          0 : g_cclosure_marshal_VOID__BOOLEANv (GClosure     *closure,
     240                 :            :                                    GValue       *return_value,
     241                 :            :                                    gpointer      instance,
     242                 :            :                                    va_list       args,
     243                 :            :                                    gpointer      marshal_data,
     244                 :            :                                    int           n_params,
     245                 :            :                                    GType        *param_types)
     246                 :            : {
     247                 :            :   typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer     instance,
     248                 :            :                                               gboolean     arg_0,
     249                 :            :                                               gpointer     data);
     250                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     251                 :            :   gpointer data1, data2;
     252                 :            :   GMarshalFunc_VOID__BOOLEAN callback;
     253                 :            :   gboolean arg0;
     254                 :            :   va_list args_copy;
     255                 :            : 
     256                 :          0 :   va_copy (args_copy, args);
     257                 :          0 :   arg0 = (gboolean) va_arg (args_copy, gboolean);
     258                 :          0 :   va_end (args_copy);
     259                 :            : 
     260         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     261                 :            :     {
     262                 :          0 :       data1 = closure->data;
     263                 :          0 :       data2 = instance;
     264                 :            :     }
     265                 :            :   else
     266                 :            :     {
     267                 :          0 :       data1 = instance;
     268                 :          0 :       data2 = closure->data;
     269                 :            :     }
     270         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
     271                 :            : 
     272                 :          0 :   callback (data1,
     273                 :            :             arg0,
     274                 :            :             data2);
     275                 :          0 : }
     276                 :            : 
     277                 :            : /**
     278                 :            :  * g_cclosure_marshal_VOID__CHAR:
     279                 :            :  * @closure: A #GClosure.
     280                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     281                 :            :  *   if the callback of closure doesn't return a value.
     282                 :            :  * @n_param_values: The length of the @param_values array.
     283                 :            :  * @param_values: An array of #GValues holding the arguments
     284                 :            :  *   on which to invoke the callback of closure.
     285                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     286                 :            :  *   g_closure_invoke().
     287                 :            :  * @marshal_data: Additional data specified when registering the
     288                 :            :  *   marshaller, see g_closure_set_marshal() and
     289                 :            :  *   g_closure_set_meta_marshal()
     290                 :            :  *
     291                 :            :  * A #GClosureMarshal function for use with signals with a single
     292                 :            :  * character argument.
     293                 :            :  */
     294                 :            : /* VOID:CHAR */
     295                 :            : void
     296                 :          0 : g_cclosure_marshal_VOID__CHAR (GClosure     *closure,
     297                 :            :                                GValue       *return_value G_GNUC_UNUSED,
     298                 :            :                                guint         n_param_values,
     299                 :            :                                const GValue *param_values,
     300                 :            :                                gpointer      invocation_hint G_GNUC_UNUSED,
     301                 :            :                                gpointer      marshal_data)
     302                 :            : {
     303                 :            :   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     data1,
     304                 :            :                                            gchar        arg_1,
     305                 :            :                                            gpointer     data2);
     306                 :            :   GMarshalFunc_VOID__CHAR callback;
     307                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     308                 :            :   gpointer data1, data2;
     309                 :            : 
     310                 :          0 :   g_return_if_fail (n_param_values == 2);
     311                 :            : 
     312         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     313                 :            :     {
     314                 :          0 :       data1 = closure->data;
     315                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     316                 :            :     }
     317                 :            :   else
     318                 :            :     {
     319                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     320                 :          0 :       data2 = closure->data;
     321                 :            :     }
     322         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
     323                 :            : 
     324                 :          0 :   callback (data1,
     325                 :          0 :             g_marshal_value_peek_char (param_values + 1),
     326                 :            :             data2);
     327                 :            : }
     328                 :            : 
     329                 :            : /**
     330                 :            :  * g_cclosure_marshal_VOID__CHARv:
     331                 :            :  * @closure: the #GClosure to which the marshaller belongs
     332                 :            :  * @return_value: (nullable): a #GValue to store the return
     333                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     334                 :            :  *  value.
     335                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     336                 :            :  * @args: va_list of arguments to be passed to the closure.
     337                 :            :  * @marshal_data: (nullable): additional data specified when
     338                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     339                 :            :  *  g_closure_set_meta_marshal()
     340                 :            :  * @n_params: the length of the @param_types array
     341                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     342                 :            :  *  @args.
     343                 :            :  *
     344                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR().
     345                 :            :  */
     346                 :            : void
     347                 :          0 : g_cclosure_marshal_VOID__CHARv (GClosure     *closure,
     348                 :            :                                 GValue       *return_value,
     349                 :            :                                 gpointer      instance,
     350                 :            :                                 va_list       args,
     351                 :            :                                 gpointer      marshal_data,
     352                 :            :                                 int           n_params,
     353                 :            :                                 GType        *param_types)
     354                 :            : {
     355                 :            :   typedef void (*GMarshalFunc_VOID__CHAR) (gpointer     instance,
     356                 :            :                                            gchar        arg_0,
     357                 :            :                                            gpointer     data);
     358                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     359                 :            :   gpointer data1, data2;
     360                 :            :   GMarshalFunc_VOID__CHAR callback;
     361                 :            :   gchar arg0;
     362                 :            :   va_list args_copy;
     363                 :            : 
     364                 :          0 :   va_copy (args_copy, args);
     365                 :          0 :   arg0 = (gchar) va_arg (args_copy, gint);
     366                 :          0 :   va_end (args_copy);
     367                 :            : 
     368         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     369                 :            :     {
     370                 :          0 :       data1 = closure->data;
     371                 :          0 :       data2 = instance;
     372                 :            :     }
     373                 :            :   else
     374                 :            :     {
     375                 :          0 :       data1 = instance;
     376                 :          0 :       data2 = closure->data;
     377                 :            :     }
     378         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
     379                 :            : 
     380                 :          0 :   callback (data1,
     381                 :            :             arg0,
     382                 :            :             data2);
     383                 :          0 : }
     384                 :            : 
     385                 :            : /**
     386                 :            :  * g_cclosure_marshal_VOID__UCHAR:
     387                 :            :  * @closure: A #GClosure.
     388                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     389                 :            :  *   if the callback of closure doesn't return a value.
     390                 :            :  * @n_param_values: The length of the @param_values array.
     391                 :            :  * @param_values: An array of #GValues holding the arguments
     392                 :            :  *   on which to invoke the callback of closure.
     393                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     394                 :            :  *   g_closure_invoke().
     395                 :            :  * @marshal_data: Additional data specified when registering the
     396                 :            :  *   marshaller, see g_closure_set_marshal() and
     397                 :            :  *   g_closure_set_meta_marshal()
     398                 :            :  *
     399                 :            :  * A #GClosureMarshal function for use with signals with a single
     400                 :            :  * unsigned character argument.
     401                 :            :  */
     402                 :            : /* VOID:UCHAR */
     403                 :            : void
     404                 :          0 : g_cclosure_marshal_VOID__UCHAR (GClosure     *closure,
     405                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
     406                 :            :                                 guint         n_param_values,
     407                 :            :                                 const GValue *param_values,
     408                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
     409                 :            :                                 gpointer      marshal_data)
     410                 :            : {
     411                 :            :   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     data1,
     412                 :            :                                             guchar       arg_1,
     413                 :            :                                             gpointer     data2);
     414                 :            :   GMarshalFunc_VOID__UCHAR callback;
     415                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     416                 :            :   gpointer data1, data2;
     417                 :            : 
     418                 :          0 :   g_return_if_fail (n_param_values == 2);
     419                 :            : 
     420         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     421                 :            :     {
     422                 :          0 :       data1 = closure->data;
     423                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     424                 :            :     }
     425                 :            :   else
     426                 :            :     {
     427                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     428                 :          0 :       data2 = closure->data;
     429                 :            :     }
     430         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
     431                 :            : 
     432                 :          0 :   callback (data1,
     433                 :          0 :             g_marshal_value_peek_uchar (param_values + 1),
     434                 :            :             data2);
     435                 :            : }
     436                 :            : 
     437                 :            : /**
     438                 :            :  * g_cclosure_marshal_VOID__UCHARv:
     439                 :            :  * @closure: the #GClosure to which the marshaller belongs
     440                 :            :  * @return_value: (nullable): a #GValue to store the return
     441                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     442                 :            :  *  value.
     443                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     444                 :            :  * @args: va_list of arguments to be passed to the closure.
     445                 :            :  * @marshal_data: (nullable): additional data specified when
     446                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     447                 :            :  *  g_closure_set_meta_marshal()
     448                 :            :  * @n_params: the length of the @param_types array
     449                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     450                 :            :  *  @args.
     451                 :            :  *
     452                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR().
     453                 :            :  */
     454                 :            : void
     455                 :          0 : g_cclosure_marshal_VOID__UCHARv (GClosure     *closure,
     456                 :            :                                  GValue       *return_value,
     457                 :            :                                  gpointer      instance,
     458                 :            :                                  va_list       args,
     459                 :            :                                  gpointer      marshal_data,
     460                 :            :                                  int           n_params,
     461                 :            :                                  GType        *param_types)
     462                 :            : {
     463                 :            :   typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer     instance,
     464                 :            :                                             guchar       arg_0,
     465                 :            :                                             gpointer     data);
     466                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     467                 :            :   gpointer data1, data2;
     468                 :            :   GMarshalFunc_VOID__UCHAR callback;
     469                 :            :   guchar arg0;
     470                 :            :   va_list args_copy;
     471                 :            : 
     472                 :          0 :   va_copy (args_copy, args);
     473                 :          0 :   arg0 = (guchar) va_arg (args_copy, guint);
     474                 :          0 :   va_end (args_copy);
     475                 :            : 
     476         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     477                 :            :     {
     478                 :          0 :       data1 = closure->data;
     479                 :          0 :       data2 = instance;
     480                 :            :     }
     481                 :            :   else
     482                 :            :     {
     483                 :          0 :       data1 = instance;
     484                 :          0 :       data2 = closure->data;
     485                 :            :     }
     486         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
     487                 :            : 
     488                 :          0 :   callback (data1,
     489                 :            :             arg0,
     490                 :            :             data2);
     491                 :          0 : }
     492                 :            : 
     493                 :            : /**
     494                 :            :  * g_cclosure_marshal_VOID__INT:
     495                 :            :  * @closure: A #GClosure.
     496                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     497                 :            :  *   if the callback of closure doesn't return a value.
     498                 :            :  * @n_param_values: The length of the @param_values array.
     499                 :            :  * @param_values: An array of #GValues holding the arguments
     500                 :            :  *   on which to invoke the callback of closure.
     501                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     502                 :            :  *   g_closure_invoke().
     503                 :            :  * @marshal_data: Additional data specified when registering the
     504                 :            :  *   marshaller, see g_closure_set_marshal() and
     505                 :            :  *   g_closure_set_meta_marshal()
     506                 :            :  *
     507                 :            :  * A #GClosureMarshal function for use with signals with a single
     508                 :            :  * integer argument.
     509                 :            :  */
     510                 :            : /* VOID:INT */
     511                 :            : void
     512                 :    6774951 : g_cclosure_marshal_VOID__INT (GClosure     *closure,
     513                 :            :                               GValue       *return_value G_GNUC_UNUSED,
     514                 :            :                               guint         n_param_values,
     515                 :            :                               const GValue *param_values,
     516                 :            :                               gpointer      invocation_hint G_GNUC_UNUSED,
     517                 :            :                               gpointer      marshal_data)
     518                 :            : {
     519                 :            :   typedef void (*GMarshalFunc_VOID__INT) (gpointer     data1,
     520                 :            :                                           gint         arg_1,
     521                 :            :                                           gpointer     data2);
     522                 :            :   GMarshalFunc_VOID__INT callback;
     523                 :    6774951 :   GCClosure *cc = (GCClosure*) closure;
     524                 :            :   gpointer data1, data2;
     525                 :            : 
     526                 :    6774951 :   g_return_if_fail (n_param_values == 2);
     527                 :            : 
     528         [ -  + ]:    6774951 :   if (G_CCLOSURE_SWAP_DATA (closure))
     529                 :            :     {
     530                 :          0 :       data1 = closure->data;
     531                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     532                 :            :     }
     533                 :            :   else
     534                 :            :     {
     535                 :    6774951 :       data1 = g_value_peek_pointer (param_values + 0);
     536                 :    6777167 :       data2 = closure->data;
     537                 :            :     }
     538         [ +  + ]:    6778598 :   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
     539                 :            : 
     540                 :    6778598 :   callback (data1,
     541                 :            :             g_marshal_value_peek_int (param_values + 1),
     542                 :            :             data2);
     543                 :            : }
     544                 :            : 
     545                 :            : /**
     546                 :            :  * g_cclosure_marshal_VOID__INTv:
     547                 :            :  * @closure: the #GClosure to which the marshaller belongs
     548                 :            :  * @return_value: (nullable): a #GValue to store the return
     549                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     550                 :            :  *  value.
     551                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     552                 :            :  * @args: va_list of arguments to be passed to the closure.
     553                 :            :  * @marshal_data: (nullable): additional data specified when
     554                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     555                 :            :  *  g_closure_set_meta_marshal()
     556                 :            :  * @n_params: the length of the @param_types array
     557                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     558                 :            :  *  @args.
     559                 :            :  *
     560                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT().
     561                 :            :  */
     562                 :            : void
     563                 :          0 : g_cclosure_marshal_VOID__INTv (GClosure     *closure,
     564                 :            :                                GValue       *return_value,
     565                 :            :                                gpointer      instance,
     566                 :            :                                va_list       args,
     567                 :            :                                gpointer      marshal_data,
     568                 :            :                                int           n_params,
     569                 :            :                                GType        *param_types)
     570                 :            : {
     571                 :            :   typedef void (*GMarshalFunc_VOID__INT) (gpointer     instance,
     572                 :            :                                           gint         arg_0,
     573                 :            :                                           gpointer     data);
     574                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     575                 :            :   gpointer data1, data2;
     576                 :            :   GMarshalFunc_VOID__INT callback;
     577                 :            :   gint arg0;
     578                 :            :   va_list args_copy;
     579                 :            : 
     580                 :          0 :   va_copy (args_copy, args);
     581                 :          0 :   arg0 = (gint) va_arg (args_copy, gint);
     582                 :          0 :   va_end (args_copy);
     583                 :            : 
     584         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     585                 :            :     {
     586                 :          0 :       data1 = closure->data;
     587                 :          0 :       data2 = instance;
     588                 :            :     }
     589                 :            :   else
     590                 :            :     {
     591                 :          0 :       data1 = instance;
     592                 :          0 :       data2 = closure->data;
     593                 :            :     }
     594         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
     595                 :            : 
     596                 :          0 :   callback (data1,
     597                 :            :             arg0,
     598                 :            :             data2);
     599                 :          0 : }
     600                 :            : 
     601                 :            : /**
     602                 :            :  * g_cclosure_marshal_VOID__UINT:
     603                 :            :  * @closure: A #GClosure.
     604                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     605                 :            :  *   if the callback of closure doesn't return a value.
     606                 :            :  * @n_param_values: The length of the @param_values array.
     607                 :            :  * @param_values: An array of #GValues holding the arguments
     608                 :            :  *   on which to invoke the callback of closure.
     609                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     610                 :            :  *   g_closure_invoke().
     611                 :            :  * @marshal_data: Additional data specified when registering the
     612                 :            :  *   marshaller, see g_closure_set_marshal() and
     613                 :            :  *   g_closure_set_meta_marshal()
     614                 :            :  *
     615                 :            :  * A #GClosureMarshal function for use with signals with with a single
     616                 :            :  * unsigned integer argument.
     617                 :            :  */
     618                 :            : /* VOID:UINT */
     619                 :            : void
     620                 :          0 : g_cclosure_marshal_VOID__UINT (GClosure     *closure,
     621                 :            :                                GValue       *return_value G_GNUC_UNUSED,
     622                 :            :                                guint         n_param_values,
     623                 :            :                                const GValue *param_values,
     624                 :            :                                gpointer      invocation_hint G_GNUC_UNUSED,
     625                 :            :                                gpointer      marshal_data)
     626                 :            : {
     627                 :            :   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     data1,
     628                 :            :                                            guint        arg_1,
     629                 :            :                                            gpointer     data2);
     630                 :            :   GMarshalFunc_VOID__UINT callback;
     631                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     632                 :            :   gpointer data1, data2;
     633                 :            : 
     634                 :          0 :   g_return_if_fail (n_param_values == 2);
     635                 :            : 
     636         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     637                 :            :     {
     638                 :          0 :       data1 = closure->data;
     639                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     640                 :            :     }
     641                 :            :   else
     642                 :            :     {
     643                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     644                 :          0 :       data2 = closure->data;
     645                 :            :     }
     646         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
     647                 :            : 
     648                 :          0 :   callback (data1,
     649                 :            :             g_marshal_value_peek_uint (param_values + 1),
     650                 :            :             data2);
     651                 :            : }
     652                 :            : 
     653                 :            : /**
     654                 :            :  * g_cclosure_marshal_VOID__UINTv:
     655                 :            :  * @closure: the #GClosure to which the marshaller belongs
     656                 :            :  * @return_value: (nullable): a #GValue to store the return
     657                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     658                 :            :  *  value.
     659                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     660                 :            :  * @args: va_list of arguments to be passed to the closure.
     661                 :            :  * @marshal_data: (nullable): additional data specified when
     662                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     663                 :            :  *  g_closure_set_meta_marshal()
     664                 :            :  * @n_params: the length of the @param_types array
     665                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     666                 :            :  *  @args.
     667                 :            :  *
     668                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT().
     669                 :            :  */
     670                 :            : void
     671                 :          0 : g_cclosure_marshal_VOID__UINTv (GClosure     *closure,
     672                 :            :                                 GValue       *return_value,
     673                 :            :                                 gpointer      instance,
     674                 :            :                                 va_list       args,
     675                 :            :                                 gpointer      marshal_data,
     676                 :            :                                 int           n_params,
     677                 :            :                                 GType        *param_types)
     678                 :            : {
     679                 :            :   typedef void (*GMarshalFunc_VOID__UINT) (gpointer     instance,
     680                 :            :                                            guint        arg_0,
     681                 :            :                                            gpointer     data);
     682                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     683                 :            :   gpointer data1, data2;
     684                 :            :   GMarshalFunc_VOID__UINT callback;
     685                 :            :   guint arg0;
     686                 :            :   va_list args_copy;
     687                 :            : 
     688                 :          0 :   va_copy (args_copy, args);
     689                 :          0 :   arg0 = (guint) va_arg (args_copy, guint);
     690                 :          0 :   va_end (args_copy);
     691                 :            : 
     692         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     693                 :            :     {
     694                 :          0 :       data1 = closure->data;
     695                 :          0 :       data2 = instance;
     696                 :            :     }
     697                 :            :   else
     698                 :            :     {
     699                 :          0 :       data1 = instance;
     700                 :          0 :       data2 = closure->data;
     701                 :            :     }
     702         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
     703                 :            : 
     704                 :          0 :   callback (data1,
     705                 :            :             arg0,
     706                 :            :             data2);
     707                 :          0 : }
     708                 :            : 
     709                 :            : /**
     710                 :            :  * g_cclosure_marshal_VOID__LONG:
     711                 :            :  * @closure: A #GClosure.
     712                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     713                 :            :  *   if the callback of closure doesn't return a value.
     714                 :            :  * @n_param_values: The length of the @param_values array.
     715                 :            :  * @param_values: An array of #GValues holding the arguments
     716                 :            :  *   on which to invoke the callback of closure.
     717                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     718                 :            :  *   g_closure_invoke().
     719                 :            :  * @marshal_data: Additional data specified when registering the
     720                 :            :  *   marshaller, see g_closure_set_marshal() and
     721                 :            :  *   g_closure_set_meta_marshal()
     722                 :            :  *
     723                 :            :  * A #GClosureMarshal function for use with signals with with a single
     724                 :            :  * long integer argument.
     725                 :            :  */
     726                 :            : /* VOID:LONG */
     727                 :            : void
     728                 :          0 : g_cclosure_marshal_VOID__LONG (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__LONG) (gpointer     data1,
     736                 :            :                                            glong        arg_1,
     737                 :            :                                            gpointer     data2);
     738                 :            :   GMarshalFunc_VOID__LONG callback;
     739                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     740                 :            :   gpointer data1, data2;
     741                 :            : 
     742                 :          0 :   g_return_if_fail (n_param_values == 2);
     743                 :            : 
     744         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     745                 :            :     {
     746                 :          0 :       data1 = closure->data;
     747                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     748                 :            :     }
     749                 :            :   else
     750                 :            :     {
     751                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     752                 :          0 :       data2 = closure->data;
     753                 :            :     }
     754         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
     755                 :            : 
     756                 :          0 :   callback (data1,
     757                 :            :             g_marshal_value_peek_long (param_values + 1),
     758                 :            :             data2);
     759                 :            : }
     760                 :            : 
     761                 :            : /**
     762                 :            :  * g_cclosure_marshal_VOID__LONGv:
     763                 :            :  * @closure: the #GClosure to which the marshaller belongs
     764                 :            :  * @return_value: (nullable): a #GValue to store the return
     765                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     766                 :            :  *  value.
     767                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     768                 :            :  * @args: va_list of arguments to be passed to the closure.
     769                 :            :  * @marshal_data: (nullable): additional data specified when
     770                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     771                 :            :  *  g_closure_set_meta_marshal()
     772                 :            :  * @n_params: the length of the @param_types array
     773                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     774                 :            :  *  @args.
     775                 :            :  *
     776                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG().
     777                 :            :  */
     778                 :            : void
     779                 :          0 : g_cclosure_marshal_VOID__LONGv (GClosure     *closure,
     780                 :            :                                 GValue       *return_value,
     781                 :            :                                 gpointer      instance,
     782                 :            :                                 va_list       args,
     783                 :            :                                 gpointer      marshal_data,
     784                 :            :                                 int           n_params,
     785                 :            :                                 GType        *param_types)
     786                 :            : {
     787                 :            :   typedef void (*GMarshalFunc_VOID__LONG) (gpointer     instance,
     788                 :            :                                            glong        arg_0,
     789                 :            :                                            gpointer     data);
     790                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     791                 :            :   gpointer data1, data2;
     792                 :            :   GMarshalFunc_VOID__LONG callback;
     793                 :            :   glong arg0;
     794                 :            :   va_list args_copy;
     795                 :            : 
     796                 :          0 :   va_copy (args_copy, args);
     797                 :          0 :   arg0 = (glong) va_arg (args_copy, glong);
     798                 :          0 :   va_end (args_copy);
     799                 :            : 
     800         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     801                 :            :     {
     802                 :          0 :       data1 = closure->data;
     803                 :          0 :       data2 = instance;
     804                 :            :     }
     805                 :            :   else
     806                 :            :     {
     807                 :          0 :       data1 = instance;
     808                 :          0 :       data2 = closure->data;
     809                 :            :     }
     810         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
     811                 :            : 
     812                 :          0 :   callback (data1,
     813                 :            :             arg0,
     814                 :            :             data2);
     815                 :          0 : }
     816                 :            : 
     817                 :            : /**
     818                 :            :  * g_cclosure_marshal_VOID__ULONG:
     819                 :            :  * @closure: A #GClosure.
     820                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     821                 :            :  *   if the callback of closure doesn't return a value.
     822                 :            :  * @n_param_values: The length of the @param_values array.
     823                 :            :  * @param_values: An array of #GValues holding the arguments
     824                 :            :  *   on which to invoke the callback of closure.
     825                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     826                 :            :  *   g_closure_invoke().
     827                 :            :  * @marshal_data: Additional data specified when registering the
     828                 :            :  *   marshaller, see g_closure_set_marshal() and
     829                 :            :  *   g_closure_set_meta_marshal()
     830                 :            :  *
     831                 :            :  * A #GClosureMarshal function for use with signals with a single
     832                 :            :  * unsigned long integer argument.
     833                 :            :  */
     834                 :            : /* VOID:ULONG */
     835                 :            : void
     836                 :          0 : g_cclosure_marshal_VOID__ULONG (GClosure     *closure,
     837                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
     838                 :            :                                 guint         n_param_values,
     839                 :            :                                 const GValue *param_values,
     840                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
     841                 :            :                                 gpointer      marshal_data)
     842                 :            : {
     843                 :            :   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     data1,
     844                 :            :                                             gulong       arg_1,
     845                 :            :                                             gpointer     data2);
     846                 :            :   GMarshalFunc_VOID__ULONG callback;
     847                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     848                 :            :   gpointer data1, data2;
     849                 :            : 
     850                 :          0 :   g_return_if_fail (n_param_values == 2);
     851                 :            : 
     852         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     853                 :            :     {
     854                 :          0 :       data1 = closure->data;
     855                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     856                 :            :     }
     857                 :            :   else
     858                 :            :     {
     859                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     860                 :          0 :       data2 = closure->data;
     861                 :            :     }
     862         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
     863                 :            : 
     864                 :          0 :   callback (data1,
     865                 :            :             g_marshal_value_peek_ulong (param_values + 1),
     866                 :            :             data2);
     867                 :            : }
     868                 :            : 
     869                 :            : /**
     870                 :            :  * g_cclosure_marshal_VOID__ULONGv:
     871                 :            :  * @closure: the #GClosure to which the marshaller belongs
     872                 :            :  * @return_value: (nullable): a #GValue to store the return
     873                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     874                 :            :  *  value.
     875                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     876                 :            :  * @args: va_list of arguments to be passed to the closure.
     877                 :            :  * @marshal_data: (nullable): additional data specified when
     878                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     879                 :            :  *  g_closure_set_meta_marshal()
     880                 :            :  * @n_params: the length of the @param_types array
     881                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     882                 :            :  *  @args.
     883                 :            :  *
     884                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG().
     885                 :            :  */
     886                 :            : void
     887                 :          0 : g_cclosure_marshal_VOID__ULONGv (GClosure     *closure,
     888                 :            :                                  GValue       *return_value,
     889                 :            :                                  gpointer      instance,
     890                 :            :                                  va_list       args,
     891                 :            :                                  gpointer      marshal_data,
     892                 :            :                                  int           n_params,
     893                 :            :                                  GType        *param_types)
     894                 :            : {
     895                 :            :   typedef void (*GMarshalFunc_VOID__ULONG) (gpointer     instance,
     896                 :            :                                             gulong       arg_0,
     897                 :            :                                             gpointer     data);
     898                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     899                 :            :   gpointer data1, data2;
     900                 :            :   GMarshalFunc_VOID__ULONG callback;
     901                 :            :   gulong arg0;
     902                 :            :   va_list args_copy;
     903                 :            : 
     904                 :          0 :   va_copy (args_copy, args);
     905                 :          0 :   arg0 = (gulong) va_arg (args_copy, gulong);
     906                 :          0 :   va_end (args_copy);
     907                 :            : 
     908         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     909                 :            :     {
     910                 :          0 :       data1 = closure->data;
     911                 :          0 :       data2 = instance;
     912                 :            :     }
     913                 :            :   else
     914                 :            :     {
     915                 :          0 :       data1 = instance;
     916                 :          0 :       data2 = closure->data;
     917                 :            :     }
     918         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
     919                 :            : 
     920                 :          0 :   callback (data1,
     921                 :            :             arg0,
     922                 :            :             data2);
     923                 :          0 : }
     924                 :            : 
     925                 :            : /**
     926                 :            :  * g_cclosure_marshal_VOID__ENUM:
     927                 :            :  * @closure: A #GClosure.
     928                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
     929                 :            :  *   if the callback of closure doesn't return a value.
     930                 :            :  * @n_param_values: The length of the @param_values array.
     931                 :            :  * @param_values: An array of #GValues holding the arguments
     932                 :            :  *   on which to invoke the callback of closure.
     933                 :            :  * @invocation_hint: The invocation hint given as the last argument to
     934                 :            :  *   g_closure_invoke().
     935                 :            :  * @marshal_data: Additional data specified when registering the
     936                 :            :  *   marshaller, see g_closure_set_marshal() and
     937                 :            :  *   g_closure_set_meta_marshal()
     938                 :            :  *
     939                 :            :  * A #GClosureMarshal function for use with signals with a single
     940                 :            :  * argument with an enumerated type.
     941                 :            :  */
     942                 :            : /* VOID:ENUM */
     943                 :            : void
     944                 :          0 : g_cclosure_marshal_VOID__ENUM (GClosure     *closure,
     945                 :            :                                GValue       *return_value G_GNUC_UNUSED,
     946                 :            :                                guint         n_param_values,
     947                 :            :                                const GValue *param_values,
     948                 :            :                                gpointer      invocation_hint G_GNUC_UNUSED,
     949                 :            :                                gpointer      marshal_data)
     950                 :            : {
     951                 :            :   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     data1,
     952                 :            :                                            gint         arg_1,
     953                 :            :                                            gpointer     data2);
     954                 :            :   GMarshalFunc_VOID__ENUM callback;
     955                 :          0 :   GCClosure *cc = (GCClosure*) closure;
     956                 :            :   gpointer data1, data2;
     957                 :            : 
     958                 :          0 :   g_return_if_fail (n_param_values == 2);
     959                 :            : 
     960         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
     961                 :            :     {
     962                 :          0 :       data1 = closure->data;
     963                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
     964                 :            :     }
     965                 :            :   else
     966                 :            :     {
     967                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
     968                 :          0 :       data2 = closure->data;
     969                 :            :     }
     970         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
     971                 :            : 
     972                 :          0 :   callback (data1,
     973                 :            :             g_marshal_value_peek_enum (param_values + 1),
     974                 :            :             data2);
     975                 :            : }
     976                 :            : 
     977                 :            : /**
     978                 :            :  * g_cclosure_marshal_VOID__ENUMv:
     979                 :            :  * @closure: the #GClosure to which the marshaller belongs
     980                 :            :  * @return_value: (nullable): a #GValue to store the return
     981                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
     982                 :            :  *  value.
     983                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
     984                 :            :  * @args: va_list of arguments to be passed to the closure.
     985                 :            :  * @marshal_data: (nullable): additional data specified when
     986                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
     987                 :            :  *  g_closure_set_meta_marshal()
     988                 :            :  * @n_params: the length of the @param_types array
     989                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
     990                 :            :  *  @args.
     991                 :            :  *
     992                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM().
     993                 :            :  */
     994                 :            : void
     995                 :          0 : g_cclosure_marshal_VOID__ENUMv (GClosure     *closure,
     996                 :            :                                 GValue       *return_value,
     997                 :            :                                 gpointer      instance,
     998                 :            :                                 va_list       args,
     999                 :            :                                 gpointer      marshal_data,
    1000                 :            :                                 int           n_params,
    1001                 :            :                                 GType        *param_types)
    1002                 :            : {
    1003                 :            :   typedef void (*GMarshalFunc_VOID__ENUM) (gpointer     instance,
    1004                 :            :                                            gint         arg_0,
    1005                 :            :                                            gpointer     data);
    1006                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1007                 :            :   gpointer data1, data2;
    1008                 :            :   GMarshalFunc_VOID__ENUM callback;
    1009                 :            :   gint arg0;
    1010                 :            :   va_list args_copy;
    1011                 :            : 
    1012                 :          0 :   va_copy (args_copy, args);
    1013                 :          0 :   arg0 = (gint) va_arg (args_copy, gint);
    1014                 :          0 :   va_end (args_copy);
    1015                 :            : 
    1016         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1017                 :            :     {
    1018                 :          0 :       data1 = closure->data;
    1019                 :          0 :       data2 = instance;
    1020                 :            :     }
    1021                 :            :   else
    1022                 :            :     {
    1023                 :          0 :       data1 = instance;
    1024                 :          0 :       data2 = closure->data;
    1025                 :            :     }
    1026         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
    1027                 :            : 
    1028                 :          0 :   callback (data1,
    1029                 :            :             arg0,
    1030                 :            :             data2);
    1031                 :          0 : }
    1032                 :            : 
    1033                 :            : /**
    1034                 :            :  * g_cclosure_marshal_VOID__FLAGS:
    1035                 :            :  * @closure: A #GClosure.
    1036                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1037                 :            :  *   if the callback of closure doesn't return a value.
    1038                 :            :  * @n_param_values: The length of the @param_values array.
    1039                 :            :  * @param_values: An array of #GValues holding the arguments
    1040                 :            :  *   on which to invoke the callback of closure.
    1041                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1042                 :            :  *   g_closure_invoke().
    1043                 :            :  * @marshal_data: Additional data specified when registering the
    1044                 :            :  *   marshaller, see g_closure_set_marshal() and
    1045                 :            :  *   g_closure_set_meta_marshal()
    1046                 :            :  *
    1047                 :            :  * A #GClosureMarshal function for use with signals with a single
    1048                 :            :  * argument with a flags types.
    1049                 :            :  */
    1050                 :            : /* VOID:FLAGS */
    1051                 :            : void
    1052                 :          0 : g_cclosure_marshal_VOID__FLAGS (GClosure     *closure,
    1053                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
    1054                 :            :                                 guint         n_param_values,
    1055                 :            :                                 const GValue *param_values,
    1056                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
    1057                 :            :                                 gpointer      marshal_data)
    1058                 :            : {
    1059                 :            :   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     data1,
    1060                 :            :                                             guint        arg_1,
    1061                 :            :                                             gpointer     data2);
    1062                 :            :   GMarshalFunc_VOID__FLAGS callback;
    1063                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1064                 :            :   gpointer data1, data2;
    1065                 :            : 
    1066                 :          0 :   g_return_if_fail (n_param_values == 2);
    1067                 :            : 
    1068         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1069                 :            :     {
    1070                 :          0 :       data1 = closure->data;
    1071                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1072                 :            :     }
    1073                 :            :   else
    1074                 :            :     {
    1075                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    1076                 :          0 :       data2 = closure->data;
    1077                 :            :     }
    1078         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
    1079                 :            : 
    1080                 :          0 :   callback (data1,
    1081                 :            :             g_marshal_value_peek_flags (param_values + 1),
    1082                 :            :             data2);
    1083                 :            : }
    1084                 :            : 
    1085                 :            : /**
    1086                 :            :  * g_cclosure_marshal_VOID__FLAGSv:
    1087                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1088                 :            :  * @return_value: (nullable): a #GValue to store the return
    1089                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1090                 :            :  *  value.
    1091                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1092                 :            :  * @args: va_list of arguments to be passed to the closure.
    1093                 :            :  * @marshal_data: (nullable): additional data specified when
    1094                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1095                 :            :  *  g_closure_set_meta_marshal()
    1096                 :            :  * @n_params: the length of the @param_types array
    1097                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1098                 :            :  *  @args.
    1099                 :            :  *
    1100                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS().
    1101                 :            :  */
    1102                 :            : void
    1103                 :          0 : g_cclosure_marshal_VOID__FLAGSv (GClosure     *closure,
    1104                 :            :                                  GValue       *return_value,
    1105                 :            :                                  gpointer      instance,
    1106                 :            :                                  va_list       args,
    1107                 :            :                                  gpointer      marshal_data,
    1108                 :            :                                  int           n_params,
    1109                 :            :                                  GType        *param_types)
    1110                 :            : {
    1111                 :            :   typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer     instance,
    1112                 :            :                                             guint        arg_0,
    1113                 :            :                                             gpointer     data);
    1114                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1115                 :            :   gpointer data1, data2;
    1116                 :            :   GMarshalFunc_VOID__FLAGS callback;
    1117                 :            :   guint arg0;
    1118                 :            :   va_list args_copy;
    1119                 :            : 
    1120                 :          0 :   va_copy (args_copy, args);
    1121                 :          0 :   arg0 = (guint) va_arg (args_copy, guint);
    1122                 :          0 :   va_end (args_copy);
    1123                 :            : 
    1124         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1125                 :            :     {
    1126                 :          0 :       data1 = closure->data;
    1127                 :          0 :       data2 = instance;
    1128                 :            :     }
    1129                 :            :   else
    1130                 :            :     {
    1131                 :          0 :       data1 = instance;
    1132                 :          0 :       data2 = closure->data;
    1133                 :            :     }
    1134         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
    1135                 :            : 
    1136                 :          0 :   callback (data1,
    1137                 :            :             arg0,
    1138                 :            :             data2);
    1139                 :          0 : }
    1140                 :            : 
    1141                 :            : /**
    1142                 :            :  * g_cclosure_marshal_VOID__FLOAT:
    1143                 :            :  * @closure: A #GClosure.
    1144                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1145                 :            :  *   if the callback of closure doesn't return a value.
    1146                 :            :  * @n_param_values: The length of the @param_values array.
    1147                 :            :  * @param_values: An array of #GValues holding the arguments
    1148                 :            :  *   on which to invoke the callback of closure.
    1149                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1150                 :            :  *   g_closure_invoke().
    1151                 :            :  * @marshal_data: Additional data specified when registering the
    1152                 :            :  *   marshaller, see g_closure_set_marshal() and
    1153                 :            :  *   g_closure_set_meta_marshal()
    1154                 :            :  *
    1155                 :            :  * A #GClosureMarshal function for use with signals with one
    1156                 :            :  * single-precision floating point argument.
    1157                 :            :  */
    1158                 :            : /* VOID:FLOAT */
    1159                 :            : void
    1160                 :          0 : g_cclosure_marshal_VOID__FLOAT (GClosure     *closure,
    1161                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
    1162                 :            :                                 guint         n_param_values,
    1163                 :            :                                 const GValue *param_values,
    1164                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
    1165                 :            :                                 gpointer      marshal_data)
    1166                 :            : {
    1167                 :            :   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     data1,
    1168                 :            :                                             gfloat       arg_1,
    1169                 :            :                                             gpointer     data2);
    1170                 :            :   GMarshalFunc_VOID__FLOAT callback;
    1171                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1172                 :            :   gpointer data1, data2;
    1173                 :            : 
    1174                 :          0 :   g_return_if_fail (n_param_values == 2);
    1175                 :            : 
    1176         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1177                 :            :     {
    1178                 :          0 :       data1 = closure->data;
    1179                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1180                 :            :     }
    1181                 :            :   else
    1182                 :            :     {
    1183                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    1184                 :          0 :       data2 = closure->data;
    1185                 :            :     }
    1186         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
    1187                 :            : 
    1188                 :          0 :   callback (data1,
    1189                 :            :             g_marshal_value_peek_float (param_values + 1),
    1190                 :            :             data2);
    1191                 :            : }
    1192                 :            : 
    1193                 :            : /**
    1194                 :            :  * g_cclosure_marshal_VOID__FLOATv:
    1195                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1196                 :            :  * @return_value: (nullable): a #GValue to store the return
    1197                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1198                 :            :  *  value.
    1199                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1200                 :            :  * @args: va_list of arguments to be passed to the closure.
    1201                 :            :  * @marshal_data: (nullable): additional data specified when
    1202                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1203                 :            :  *  g_closure_set_meta_marshal()
    1204                 :            :  * @n_params: the length of the @param_types array
    1205                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1206                 :            :  *  @args.
    1207                 :            :  *
    1208                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT().
    1209                 :            :  */
    1210                 :            : void
    1211                 :          0 : g_cclosure_marshal_VOID__FLOATv (GClosure     *closure,
    1212                 :            :                                  GValue       *return_value,
    1213                 :            :                                  gpointer      instance,
    1214                 :            :                                  va_list       args,
    1215                 :            :                                  gpointer      marshal_data,
    1216                 :            :                                  int           n_params,
    1217                 :            :                                  GType        *param_types)
    1218                 :            : {
    1219                 :            :   typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer     instance,
    1220                 :            :                                             gfloat       arg_0,
    1221                 :            :                                             gpointer     data);
    1222                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1223                 :            :   gpointer data1, data2;
    1224                 :            :   GMarshalFunc_VOID__FLOAT callback;
    1225                 :            :   gfloat arg0;
    1226                 :            :   va_list args_copy;
    1227                 :            : 
    1228                 :          0 :   va_copy (args_copy, args);
    1229                 :          0 :   arg0 = (gfloat) va_arg (args_copy, gdouble);
    1230                 :          0 :   va_end (args_copy);
    1231                 :            : 
    1232         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1233                 :            :     {
    1234                 :          0 :       data1 = closure->data;
    1235                 :          0 :       data2 = instance;
    1236                 :            :     }
    1237                 :            :   else
    1238                 :            :     {
    1239                 :          0 :       data1 = instance;
    1240                 :          0 :       data2 = closure->data;
    1241                 :            :     }
    1242         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
    1243                 :            : 
    1244                 :          0 :   callback (data1,
    1245                 :            :             arg0,
    1246                 :            :             data2);
    1247                 :          0 : }
    1248                 :            : 
    1249                 :            : /**
    1250                 :            :  * g_cclosure_marshal_VOID__DOUBLE:
    1251                 :            :  * @closure: A #GClosure.
    1252                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1253                 :            :  *   if the callback of closure doesn't return a value.
    1254                 :            :  * @n_param_values: The length of the @param_values array.
    1255                 :            :  * @param_values: An array of #GValues holding the arguments
    1256                 :            :  *   on which to invoke the callback of closure.
    1257                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1258                 :            :  *   g_closure_invoke().
    1259                 :            :  * @marshal_data: Additional data specified when registering the
    1260                 :            :  *   marshaller, see g_closure_set_marshal() and
    1261                 :            :  *   g_closure_set_meta_marshal()
    1262                 :            :  *
    1263                 :            :  * A #GClosureMarshal function for use with signals with one
    1264                 :            :  * double-precision floating point argument.
    1265                 :            :  */
    1266                 :            : /* VOID:DOUBLE */
    1267                 :            : void
    1268                 :          0 : g_cclosure_marshal_VOID__DOUBLE (GClosure     *closure,
    1269                 :            :                                  GValue       *return_value G_GNUC_UNUSED,
    1270                 :            :                                  guint         n_param_values,
    1271                 :            :                                  const GValue *param_values,
    1272                 :            :                                  gpointer      invocation_hint G_GNUC_UNUSED,
    1273                 :            :                                  gpointer      marshal_data)
    1274                 :            : {
    1275                 :            :   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     data1,
    1276                 :            :                                              gdouble      arg_1,
    1277                 :            :                                              gpointer     data2);
    1278                 :            :   GMarshalFunc_VOID__DOUBLE callback;
    1279                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1280                 :            :   gpointer data1, data2;
    1281                 :            : 
    1282                 :          0 :   g_return_if_fail (n_param_values == 2);
    1283                 :            : 
    1284         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1285                 :            :     {
    1286                 :          0 :       data1 = closure->data;
    1287                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1288                 :            :     }
    1289                 :            :   else
    1290                 :            :     {
    1291                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    1292                 :          0 :       data2 = closure->data;
    1293                 :            :     }
    1294         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
    1295                 :            : 
    1296                 :          0 :   callback (data1,
    1297                 :            :             g_marshal_value_peek_double (param_values + 1),
    1298                 :            :             data2);
    1299                 :            : }
    1300                 :            : 
    1301                 :            : /**
    1302                 :            :  * g_cclosure_marshal_VOID__DOUBLEv:
    1303                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1304                 :            :  * @return_value: (nullable): a #GValue to store the return
    1305                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1306                 :            :  *  value.
    1307                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1308                 :            :  * @args: va_list of arguments to be passed to the closure.
    1309                 :            :  * @marshal_data: (nullable): additional data specified when
    1310                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1311                 :            :  *  g_closure_set_meta_marshal()
    1312                 :            :  * @n_params: the length of the @param_types array
    1313                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1314                 :            :  *  @args.
    1315                 :            :  *
    1316                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE().
    1317                 :            :  */
    1318                 :            : void
    1319                 :          0 : g_cclosure_marshal_VOID__DOUBLEv (GClosure     *closure,
    1320                 :            :                                   GValue       *return_value,
    1321                 :            :                                   gpointer      instance,
    1322                 :            :                                   va_list       args,
    1323                 :            :                                   gpointer      marshal_data,
    1324                 :            :                                   int           n_params,
    1325                 :            :                                   GType        *param_types)
    1326                 :            : {
    1327                 :            :   typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer     instance,
    1328                 :            :                                              gdouble      arg_0,
    1329                 :            :                                              gpointer     data);
    1330                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1331                 :            :   gpointer data1, data2;
    1332                 :            :   GMarshalFunc_VOID__DOUBLE callback;
    1333                 :            :   gdouble arg0;
    1334                 :            :   va_list args_copy;
    1335                 :            : 
    1336                 :          0 :   va_copy (args_copy, args);
    1337                 :          0 :   arg0 = (gdouble) va_arg (args_copy, gdouble);
    1338                 :          0 :   va_end (args_copy);
    1339                 :            : 
    1340         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1341                 :            :     {
    1342                 :          0 :       data1 = closure->data;
    1343                 :          0 :       data2 = instance;
    1344                 :            :     }
    1345                 :            :   else
    1346                 :            :     {
    1347                 :          0 :       data1 = instance;
    1348                 :          0 :       data2 = closure->data;
    1349                 :            :     }
    1350         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
    1351                 :            : 
    1352                 :          0 :   callback (data1,
    1353                 :            :             arg0,
    1354                 :            :             data2);
    1355                 :          0 : }
    1356                 :            : 
    1357                 :            : /**
    1358                 :            :  * g_cclosure_marshal_VOID__STRING:
    1359                 :            :  * @closure: A #GClosure.
    1360                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1361                 :            :  *   if the callback of closure doesn't return a value.
    1362                 :            :  * @n_param_values: The length of the @param_values array.
    1363                 :            :  * @param_values: An array of #GValues holding the arguments
    1364                 :            :  *   on which to invoke the callback of closure.
    1365                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1366                 :            :  *   g_closure_invoke().
    1367                 :            :  * @marshal_data: Additional data specified when registering the
    1368                 :            :  *   marshaller, see g_closure_set_marshal() and
    1369                 :            :  *   g_closure_set_meta_marshal()
    1370                 :            :  *
    1371                 :            :  * A #GClosureMarshal function for use with signals with a single string
    1372                 :            :  * argument.
    1373                 :            :  */
    1374                 :            : /* VOID:STRING */
    1375                 :            : void
    1376                 :         91 : g_cclosure_marshal_VOID__STRING (GClosure     *closure,
    1377                 :            :                                  GValue       *return_value G_GNUC_UNUSED,
    1378                 :            :                                  guint         n_param_values,
    1379                 :            :                                  const GValue *param_values,
    1380                 :            :                                  gpointer      invocation_hint G_GNUC_UNUSED,
    1381                 :            :                                  gpointer      marshal_data)
    1382                 :            : {
    1383                 :            :   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     data1,
    1384                 :            :                                              gpointer     arg_1,
    1385                 :            :                                              gpointer     data2);
    1386                 :            :   GMarshalFunc_VOID__STRING callback;
    1387                 :         91 :   GCClosure *cc = (GCClosure*) closure;
    1388                 :            :   gpointer data1, data2;
    1389                 :            : 
    1390                 :         91 :   g_return_if_fail (n_param_values == 2);
    1391                 :            : 
    1392         [ +  + ]:         91 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1393                 :            :     {
    1394                 :         59 :       data1 = closure->data;
    1395                 :         59 :       data2 = g_value_peek_pointer (param_values + 0);
    1396                 :            :     }
    1397                 :            :   else
    1398                 :            :     {
    1399                 :         32 :       data1 = g_value_peek_pointer (param_values + 0);
    1400                 :         32 :       data2 = closure->data;
    1401                 :            :     }
    1402         [ +  + ]:         91 :   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
    1403                 :            : 
    1404                 :         91 :   callback (data1,
    1405                 :         91 :             g_marshal_value_peek_string (param_values + 1),
    1406                 :            :             data2);
    1407                 :            : }
    1408                 :            : 
    1409                 :            : /**
    1410                 :            :  * g_cclosure_marshal_VOID__STRINGv:
    1411                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1412                 :            :  * @return_value: (nullable): a #GValue to store the return
    1413                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1414                 :            :  *  value.
    1415                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1416                 :            :  * @args: va_list of arguments to be passed to the closure.
    1417                 :            :  * @marshal_data: (nullable): additional data specified when
    1418                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1419                 :            :  *  g_closure_set_meta_marshal()
    1420                 :            :  * @n_params: the length of the @param_types array
    1421                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1422                 :            :  *  @args.
    1423                 :            :  *
    1424                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING().
    1425                 :            :  */
    1426                 :            : void
    1427                 :         62 : g_cclosure_marshal_VOID__STRINGv (GClosure     *closure,
    1428                 :            :                                   GValue       *return_value,
    1429                 :            :                                   gpointer      instance,
    1430                 :            :                                   va_list       args,
    1431                 :            :                                   gpointer      marshal_data,
    1432                 :            :                                   int           n_params,
    1433                 :            :                                   GType        *param_types)
    1434                 :            : {
    1435                 :            :   typedef void (*GMarshalFunc_VOID__STRING) (gpointer     instance,
    1436                 :            :                                              gpointer     arg_0,
    1437                 :            :                                              gpointer     data);
    1438                 :         62 :   GCClosure *cc = (GCClosure*) closure;
    1439                 :            :   gpointer data1, data2;
    1440                 :            :   GMarshalFunc_VOID__STRING callback;
    1441                 :            :   gpointer arg0;
    1442                 :            :   va_list args_copy;
    1443                 :            : 
    1444                 :         62 :   va_copy (args_copy, args);
    1445                 :         62 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    1446   [ +  +  +  - ]:         62 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1447                 :          2 :     arg0 = g_strdup (arg0);
    1448                 :         62 :   va_end (args_copy);
    1449                 :            : 
    1450         [ -  + ]:         62 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1451                 :            :     {
    1452                 :          0 :       data1 = closure->data;
    1453                 :          0 :       data2 = instance;
    1454                 :            :     }
    1455                 :            :   else
    1456                 :            :     {
    1457                 :         62 :       data1 = instance;
    1458                 :         62 :       data2 = closure->data;
    1459                 :            :     }
    1460         [ +  - ]:         62 :   callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
    1461                 :            : 
    1462                 :         62 :   callback (data1,
    1463                 :            :             arg0,
    1464                 :            :             data2);
    1465   [ +  +  +  - ]:         62 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1466                 :          2 :     g_free (arg0);
    1467                 :         62 : }
    1468                 :            : 
    1469                 :            : /**
    1470                 :            :  * g_cclosure_marshal_VOID__PARAM:
    1471                 :            :  * @closure: A #GClosure.
    1472                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1473                 :            :  *   if the callback of closure doesn't return a value.
    1474                 :            :  * @n_param_values: The length of the @param_values array.
    1475                 :            :  * @param_values: An array of #GValues holding the arguments
    1476                 :            :  *   on which to invoke the callback of closure.
    1477                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1478                 :            :  *   g_closure_invoke().
    1479                 :            :  * @marshal_data: Additional data specified when registering the
    1480                 :            :  *   marshaller, see g_closure_set_marshal() and
    1481                 :            :  *   g_closure_set_meta_marshal()
    1482                 :            :  *
    1483                 :            :  * A #GClosureMarshal function for use with signals with a single
    1484                 :            :  * argument of type #GParamSpec.
    1485                 :            :  */
    1486                 :            : /* VOID:PARAM */
    1487                 :            : void
    1488                 :    2445426 : g_cclosure_marshal_VOID__PARAM (GClosure     *closure,
    1489                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
    1490                 :            :                                 guint         n_param_values,
    1491                 :            :                                 const GValue *param_values,
    1492                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
    1493                 :            :                                 gpointer      marshal_data)
    1494                 :            : {
    1495                 :            :   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     data1,
    1496                 :            :                                             gpointer     arg_1,
    1497                 :            :                                             gpointer     data2);
    1498                 :            :   GMarshalFunc_VOID__PARAM callback;
    1499                 :    2445426 :   GCClosure *cc = (GCClosure*) closure;
    1500                 :            :   gpointer data1, data2;
    1501                 :            : 
    1502                 :    2445426 :   g_return_if_fail (n_param_values == 2);
    1503                 :            : 
    1504         [ -  + ]:    2445426 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1505                 :            :     {
    1506                 :          0 :       data1 = closure->data;
    1507                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1508                 :            :     }
    1509                 :            :   else
    1510                 :            :     {
    1511                 :    2445426 :       data1 = g_value_peek_pointer (param_values + 0);
    1512                 :    2445470 :       data2 = closure->data;
    1513                 :            :     }
    1514         [ +  + ]:    2445471 :   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
    1515                 :            : 
    1516                 :    2445351 :   callback (data1,
    1517                 :    2445471 :             g_marshal_value_peek_param (param_values + 1),
    1518                 :            :             data2);
    1519                 :            : }
    1520                 :            : 
    1521                 :            : /**
    1522                 :            :  * g_cclosure_marshal_VOID__PARAMv:
    1523                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1524                 :            :  * @return_value: (nullable): a #GValue to store the return
    1525                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1526                 :            :  *  value.
    1527                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1528                 :            :  * @args: va_list of arguments to be passed to the closure.
    1529                 :            :  * @marshal_data: (nullable): additional data specified when
    1530                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1531                 :            :  *  g_closure_set_meta_marshal()
    1532                 :            :  * @n_params: the length of the @param_types array
    1533                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1534                 :            :  *  @args.
    1535                 :            :  *
    1536                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM().
    1537                 :            :  */
    1538                 :            : void
    1539                 :          0 : g_cclosure_marshal_VOID__PARAMv (GClosure     *closure,
    1540                 :            :                                  GValue       *return_value,
    1541                 :            :                                  gpointer      instance,
    1542                 :            :                                  va_list       args,
    1543                 :            :                                  gpointer      marshal_data,
    1544                 :            :                                  int           n_params,
    1545                 :            :                                  GType        *param_types)
    1546                 :            : {
    1547                 :            :   typedef void (*GMarshalFunc_VOID__PARAM) (gpointer     instance,
    1548                 :            :                                             gpointer     arg_0,
    1549                 :            :                                             gpointer     data);
    1550                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1551                 :            :   gpointer data1, data2;
    1552                 :            :   GMarshalFunc_VOID__PARAM callback;
    1553                 :            :   gpointer arg0;
    1554                 :            :   va_list args_copy;
    1555                 :            : 
    1556                 :          0 :   va_copy (args_copy, args);
    1557                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    1558   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1559                 :          0 :     arg0 = g_param_spec_ref (arg0);
    1560                 :          0 :   va_end (args_copy);
    1561                 :            : 
    1562         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1563                 :            :     {
    1564                 :          0 :       data1 = closure->data;
    1565                 :          0 :       data2 = instance;
    1566                 :            :     }
    1567                 :            :   else
    1568                 :            :     {
    1569                 :          0 :       data1 = instance;
    1570                 :          0 :       data2 = closure->data;
    1571                 :            :     }
    1572         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
    1573                 :            : 
    1574                 :          0 :   callback (data1,
    1575                 :            :             arg0,
    1576                 :            :             data2);
    1577   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1578                 :          0 :     g_param_spec_unref (arg0);
    1579                 :          0 : }
    1580                 :            : 
    1581                 :            : /**
    1582                 :            :  * g_cclosure_marshal_VOID__BOXED:
    1583                 :            :  * @closure: A #GClosure.
    1584                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1585                 :            :  *   if the callback of closure doesn't return a value.
    1586                 :            :  * @n_param_values: The length of the @param_values array.
    1587                 :            :  * @param_values: An array of #GValues holding the arguments
    1588                 :            :  *   on which to invoke the callback of closure.
    1589                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1590                 :            :  *   g_closure_invoke().
    1591                 :            :  * @marshal_data: Additional data specified when registering the
    1592                 :            :  *   marshaller, see g_closure_set_marshal() and
    1593                 :            :  *   g_closure_set_meta_marshal()
    1594                 :            :  *
    1595                 :            :  * A #GClosureMarshal function for use with signals with a single
    1596                 :            :  * argument which is any boxed pointer type.
    1597                 :            :  */
    1598                 :            : /* VOID:BOXED */
    1599                 :            : void
    1600                 :          0 : g_cclosure_marshal_VOID__BOXED (GClosure     *closure,
    1601                 :            :                                 GValue       *return_value G_GNUC_UNUSED,
    1602                 :            :                                 guint         n_param_values,
    1603                 :            :                                 const GValue *param_values,
    1604                 :            :                                 gpointer      invocation_hint G_GNUC_UNUSED,
    1605                 :            :                                 gpointer      marshal_data)
    1606                 :            : {
    1607                 :            :   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     data1,
    1608                 :            :                                             gpointer     arg_1,
    1609                 :            :                                             gpointer     data2);
    1610                 :            :   GMarshalFunc_VOID__BOXED callback;
    1611                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1612                 :            :   gpointer data1, data2;
    1613                 :            : 
    1614                 :          0 :   g_return_if_fail (n_param_values == 2);
    1615                 :            : 
    1616         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1617                 :            :     {
    1618                 :          0 :       data1 = closure->data;
    1619                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1620                 :            :     }
    1621                 :            :   else
    1622                 :            :     {
    1623                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    1624                 :          0 :       data2 = closure->data;
    1625                 :            :     }
    1626         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
    1627                 :            : 
    1628                 :          0 :   callback (data1,
    1629                 :            :             g_marshal_value_peek_boxed (param_values + 1),
    1630                 :            :             data2);
    1631                 :            : }
    1632                 :            : 
    1633                 :            : /**
    1634                 :            :  * g_cclosure_marshal_VOID__BOXEDv:
    1635                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1636                 :            :  * @return_value: (nullable): a #GValue to store the return
    1637                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1638                 :            :  *  value.
    1639                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1640                 :            :  * @args: va_list of arguments to be passed to the closure.
    1641                 :            :  * @marshal_data: (nullable): additional data specified when
    1642                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1643                 :            :  *  g_closure_set_meta_marshal()
    1644                 :            :  * @n_params: the length of the @param_types array
    1645                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1646                 :            :  *  @args.
    1647                 :            :  *
    1648                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED().
    1649                 :            :  */
    1650                 :            : void
    1651                 :          0 : g_cclosure_marshal_VOID__BOXEDv (GClosure     *closure,
    1652                 :            :                                  GValue       *return_value,
    1653                 :            :                                  gpointer      instance,
    1654                 :            :                                  va_list       args,
    1655                 :            :                                  gpointer      marshal_data,
    1656                 :            :                                  int           n_params,
    1657                 :            :                                  GType        *param_types)
    1658                 :            : {
    1659                 :            :   typedef void (*GMarshalFunc_VOID__BOXED) (gpointer     instance,
    1660                 :            :                                             gpointer     arg_0,
    1661                 :            :                                             gpointer     data);
    1662                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1663                 :            :   gpointer data1, data2;
    1664                 :            :   GMarshalFunc_VOID__BOXED callback;
    1665                 :            :   gpointer arg0;
    1666                 :            :   va_list args_copy;
    1667                 :            : 
    1668                 :          0 :   va_copy (args_copy, args);
    1669                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    1670   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1671                 :          0 :     arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
    1672                 :          0 :   va_end (args_copy);
    1673                 :            : 
    1674         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1675                 :            :     {
    1676                 :          0 :       data1 = closure->data;
    1677                 :          0 :       data2 = instance;
    1678                 :            :     }
    1679                 :            :   else
    1680                 :            :     {
    1681                 :          0 :       data1 = instance;
    1682                 :          0 :       data2 = closure->data;
    1683                 :            :     }
    1684         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
    1685                 :            : 
    1686                 :          0 :   callback (data1,
    1687                 :            :             arg0,
    1688                 :            :             data2);
    1689   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    1690                 :          0 :     g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
    1691                 :          0 : }
    1692                 :            : 
    1693                 :            : /**
    1694                 :            :  * g_cclosure_marshal_VOID__POINTER:
    1695                 :            :  * @closure: A #GClosure.
    1696                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1697                 :            :  *   if the callback of closure doesn't return a value.
    1698                 :            :  * @n_param_values: The length of the @param_values array.
    1699                 :            :  * @param_values: An array of #GValues holding the arguments
    1700                 :            :  *   on which to invoke the callback of closure.
    1701                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1702                 :            :  *   g_closure_invoke().
    1703                 :            :  * @marshal_data: Additional data specified when registering the
    1704                 :            :  *   marshaller, see g_closure_set_marshal() and
    1705                 :            :  *   g_closure_set_meta_marshal()
    1706                 :            :  *
    1707                 :            :  * A #GClosureMarshal function for use with signals with a single raw
    1708                 :            :  * pointer argument type.
    1709                 :            :  *
    1710                 :            :  * If it is possible, it is better to use one of the more specific
    1711                 :            :  * functions such as g_cclosure_marshal_VOID__OBJECT() or
    1712                 :            :  * g_cclosure_marshal_VOID__OBJECT().
    1713                 :            :  */
    1714                 :            : /* VOID:POINTER */
    1715                 :            : void
    1716                 :          0 : g_cclosure_marshal_VOID__POINTER (GClosure     *closure,
    1717                 :            :                                   GValue       *return_value G_GNUC_UNUSED,
    1718                 :            :                                   guint         n_param_values,
    1719                 :            :                                   const GValue *param_values,
    1720                 :            :                                   gpointer      invocation_hint G_GNUC_UNUSED,
    1721                 :            :                                   gpointer      marshal_data)
    1722                 :            : {
    1723                 :            :   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     data1,
    1724                 :            :                                               gpointer     arg_1,
    1725                 :            :                                               gpointer     data2);
    1726                 :            :   GMarshalFunc_VOID__POINTER callback;
    1727                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1728                 :            :   gpointer data1, data2;
    1729                 :            : 
    1730                 :          0 :   g_return_if_fail (n_param_values == 2);
    1731                 :            : 
    1732         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1733                 :            :     {
    1734                 :          0 :       data1 = closure->data;
    1735                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1736                 :            :     }
    1737                 :            :   else
    1738                 :            :     {
    1739                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    1740                 :          0 :       data2 = closure->data;
    1741                 :            :     }
    1742         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
    1743                 :            : 
    1744                 :          0 :   callback (data1,
    1745                 :            :             g_marshal_value_peek_pointer (param_values + 1),
    1746                 :            :             data2);
    1747                 :            : }
    1748                 :            : 
    1749                 :            : /**
    1750                 :            :  * g_cclosure_marshal_VOID__POINTERv:
    1751                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1752                 :            :  * @return_value: (nullable): a #GValue to store the return
    1753                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1754                 :            :  *  value.
    1755                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1756                 :            :  * @args: va_list of arguments to be passed to the closure.
    1757                 :            :  * @marshal_data: (nullable): additional data specified when
    1758                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1759                 :            :  *  g_closure_set_meta_marshal()
    1760                 :            :  * @n_params: the length of the @param_types array
    1761                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1762                 :            :  *  @args.
    1763                 :            :  *
    1764                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER().
    1765                 :            :  */
    1766                 :            : void
    1767                 :          0 : g_cclosure_marshal_VOID__POINTERv (GClosure     *closure,
    1768                 :            :                                    GValue       *return_value,
    1769                 :            :                                    gpointer      instance,
    1770                 :            :                                    va_list       args,
    1771                 :            :                                    gpointer      marshal_data,
    1772                 :            :                                    int           n_params,
    1773                 :            :                                    GType        *param_types)
    1774                 :            : {
    1775                 :            :   typedef void (*GMarshalFunc_VOID__POINTER) (gpointer     instance,
    1776                 :            :                                               gpointer     arg_0,
    1777                 :            :                                               gpointer     data);
    1778                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1779                 :            :   gpointer data1, data2;
    1780                 :            :   GMarshalFunc_VOID__POINTER callback;
    1781                 :            :   gpointer arg0;
    1782                 :            :   va_list args_copy;
    1783                 :            : 
    1784                 :          0 :   va_copy (args_copy, args);
    1785                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    1786                 :          0 :   va_end (args_copy);
    1787                 :            : 
    1788         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1789                 :            :     {
    1790                 :          0 :       data1 = closure->data;
    1791                 :          0 :       data2 = instance;
    1792                 :            :     }
    1793                 :            :   else
    1794                 :            :     {
    1795                 :          0 :       data1 = instance;
    1796                 :          0 :       data2 = closure->data;
    1797                 :            :     }
    1798         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
    1799                 :            : 
    1800                 :          0 :   callback (data1,
    1801                 :            :             arg0,
    1802                 :            :             data2);
    1803                 :          0 : }
    1804                 :            : 
    1805                 :            : /**
    1806                 :            :  * g_cclosure_marshal_VOID__OBJECT:
    1807                 :            :  * @closure: A #GClosure.
    1808                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1809                 :            :  *   if the callback of closure doesn't return a value.
    1810                 :            :  * @n_param_values: The length of the @param_values array.
    1811                 :            :  * @param_values: An array of #GValues holding the arguments
    1812                 :            :  *   on which to invoke the callback of closure.
    1813                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1814                 :            :  *   g_closure_invoke().
    1815                 :            :  * @marshal_data: Additional data specified when registering the
    1816                 :            :  *   marshaller, see g_closure_set_marshal() and
    1817                 :            :  *   g_closure_set_meta_marshal()
    1818                 :            :  *
    1819                 :            :  * A #GClosureMarshal function for use with signals with a single
    1820                 :            :  * #GObject argument.
    1821                 :            :  */
    1822                 :            : /* VOID:OBJECT */
    1823                 :            : void
    1824                 :        195 : g_cclosure_marshal_VOID__OBJECT (GClosure     *closure,
    1825                 :            :                                  GValue       *return_value G_GNUC_UNUSED,
    1826                 :            :                                  guint         n_param_values,
    1827                 :            :                                  const GValue *param_values,
    1828                 :            :                                  gpointer      invocation_hint G_GNUC_UNUSED,
    1829                 :            :                                  gpointer      marshal_data)
    1830                 :            : {
    1831                 :            :   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     data1,
    1832                 :            :                                              gpointer     arg_1,
    1833                 :            :                                              gpointer     data2);
    1834                 :            :   GMarshalFunc_VOID__OBJECT callback;
    1835                 :        195 :   GCClosure *cc = (GCClosure*) closure;
    1836                 :            :   gpointer data1, data2;
    1837                 :            : 
    1838                 :        195 :   g_return_if_fail (n_param_values == 2);
    1839                 :            : 
    1840         [ +  + ]:        195 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1841                 :            :     {
    1842                 :         11 :       data1 = closure->data;
    1843                 :         11 :       data2 = g_value_peek_pointer (param_values + 0);
    1844                 :            :     }
    1845                 :            :   else
    1846                 :            :     {
    1847                 :        184 :       data1 = g_value_peek_pointer (param_values + 0);
    1848                 :        184 :       data2 = closure->data;
    1849                 :            :     }
    1850         [ +  + ]:        195 :   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
    1851                 :            : 
    1852                 :        195 :   callback (data1,
    1853                 :            :             g_marshal_value_peek_object (param_values + 1),
    1854                 :            :             data2);
    1855                 :            : }
    1856                 :            : 
    1857                 :            : /**
    1858                 :            :  * g_cclosure_marshal_VOID__OBJECTv:
    1859                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1860                 :            :  * @return_value: (nullable): a #GValue to store the return
    1861                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1862                 :            :  *  value.
    1863                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1864                 :            :  * @args: va_list of arguments to be passed to the closure.
    1865                 :            :  * @marshal_data: (nullable): additional data specified when
    1866                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1867                 :            :  *  g_closure_set_meta_marshal()
    1868                 :            :  * @n_params: the length of the @param_types array
    1869                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1870                 :            :  *  @args.
    1871                 :            :  *
    1872                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT().
    1873                 :            :  */
    1874                 :            : void
    1875                 :          0 : g_cclosure_marshal_VOID__OBJECTv (GClosure     *closure,
    1876                 :            :                                   GValue       *return_value,
    1877                 :            :                                   gpointer      instance,
    1878                 :            :                                   va_list       args,
    1879                 :            :                                   gpointer      marshal_data,
    1880                 :            :                                   int           n_params,
    1881                 :            :                                   GType        *param_types)
    1882                 :            : {
    1883                 :            :   typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer     instance,
    1884                 :            :                                              gpointer     arg_0,
    1885                 :            :                                              gpointer     data);
    1886                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1887                 :            :   gpointer data1, data2;
    1888                 :            :   GMarshalFunc_VOID__OBJECT callback;
    1889                 :            :   gpointer arg0;
    1890                 :            :   va_list args_copy;
    1891                 :            : 
    1892                 :          0 :   va_copy (args_copy, args);
    1893                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    1894         [ #  # ]:          0 :   if (arg0 != NULL)
    1895                 :          0 :     arg0 = g_object_ref (arg0);
    1896                 :          0 :   va_end (args_copy);
    1897                 :            : 
    1898         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1899                 :            :     {
    1900                 :          0 :       data1 = closure->data;
    1901                 :          0 :       data2 = instance;
    1902                 :            :     }
    1903                 :            :   else
    1904                 :            :     {
    1905                 :          0 :       data1 = instance;
    1906                 :          0 :       data2 = closure->data;
    1907                 :            :     }
    1908         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
    1909                 :            : 
    1910                 :          0 :   callback (data1,
    1911                 :            :             arg0,
    1912                 :            :             data2);
    1913         [ #  # ]:          0 :   if (arg0 != NULL)
    1914                 :          0 :     g_object_unref (arg0);
    1915                 :          0 : }
    1916                 :            : 
    1917                 :            : /**
    1918                 :            :  * g_cclosure_marshal_VOID__VARIANT:
    1919                 :            :  * @closure: A #GClosure.
    1920                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    1921                 :            :  *   if the callback of closure doesn't return a value.
    1922                 :            :  * @n_param_values: The length of the @param_values array.
    1923                 :            :  * @param_values: An array of #GValues holding the arguments
    1924                 :            :  *   on which to invoke the callback of closure.
    1925                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    1926                 :            :  *   g_closure_invoke().
    1927                 :            :  * @marshal_data: Additional data specified when registering the
    1928                 :            :  *   marshaller, see g_closure_set_marshal() and
    1929                 :            :  *   g_closure_set_meta_marshal()
    1930                 :            :  *
    1931                 :            :  * A #GClosureMarshal function for use with signals with a single
    1932                 :            :  * #GVariant argument.
    1933                 :            :  */
    1934                 :            : /* VOID:VARIANT */
    1935                 :            : void
    1936                 :         25 : g_cclosure_marshal_VOID__VARIANT (GClosure     *closure,
    1937                 :            :                                   GValue       *return_value G_GNUC_UNUSED,
    1938                 :            :                                   guint         n_param_values,
    1939                 :            :                                   const GValue *param_values,
    1940                 :            :                                   gpointer      invocation_hint G_GNUC_UNUSED,
    1941                 :            :                                   gpointer      marshal_data)
    1942                 :            : {
    1943                 :            :   typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer     data1,
    1944                 :            :                                               gpointer     arg_1,
    1945                 :            :                                               gpointer     data2);
    1946                 :            :   GMarshalFunc_VOID__VARIANT callback;
    1947                 :         25 :   GCClosure *cc = (GCClosure*) closure;
    1948                 :            :   gpointer data1, data2;
    1949                 :            : 
    1950                 :         25 :   g_return_if_fail (n_param_values == 2);
    1951                 :            : 
    1952         [ -  + ]:         25 :   if (G_CCLOSURE_SWAP_DATA (closure))
    1953                 :            :     {
    1954                 :          0 :       data1 = closure->data;
    1955                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    1956                 :            :     }
    1957                 :            :   else
    1958                 :            :     {
    1959                 :         25 :       data1 = g_value_peek_pointer (param_values + 0);
    1960                 :         25 :       data2 = closure->data;
    1961                 :            :     }
    1962         [ +  - ]:         25 :   callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
    1963                 :            : 
    1964                 :         25 :   callback (data1,
    1965                 :         25 :             g_marshal_value_peek_variant (param_values + 1),
    1966                 :            :             data2);
    1967                 :            : }
    1968                 :            : 
    1969                 :            : /**
    1970                 :            :  * g_cclosure_marshal_VOID__VARIANTv:
    1971                 :            :  * @closure: the #GClosure to which the marshaller belongs
    1972                 :            :  * @return_value: (nullable): a #GValue to store the return
    1973                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    1974                 :            :  *  value.
    1975                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    1976                 :            :  * @args: va_list of arguments to be passed to the closure.
    1977                 :            :  * @marshal_data: (nullable): additional data specified when
    1978                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    1979                 :            :  *  g_closure_set_meta_marshal()
    1980                 :            :  * @n_params: the length of the @param_types array
    1981                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    1982                 :            :  *  @args.
    1983                 :            :  *
    1984                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT().
    1985                 :            :  */
    1986                 :            : void
    1987                 :          0 : g_cclosure_marshal_VOID__VARIANTv (GClosure     *closure,
    1988                 :            :                                    GValue       *return_value,
    1989                 :            :                                    gpointer      instance,
    1990                 :            :                                    va_list       args,
    1991                 :            :                                    gpointer      marshal_data,
    1992                 :            :                                    int           n_params,
    1993                 :            :                                    GType        *param_types)
    1994                 :            : {
    1995                 :            :   typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer     instance,
    1996                 :            :                                               gpointer     arg_0,
    1997                 :            :                                               gpointer     data);
    1998                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    1999                 :            :   gpointer data1, data2;
    2000                 :            :   GMarshalFunc_VOID__VARIANT callback;
    2001                 :            :   gpointer arg0;
    2002                 :            :   va_list args_copy;
    2003                 :            : 
    2004                 :          0 :   va_copy (args_copy, args);
    2005                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    2006   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    2007                 :          0 :     arg0 = g_variant_ref_sink (arg0);
    2008                 :          0 :   va_end (args_copy);
    2009                 :            : 
    2010         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2011                 :            :     {
    2012                 :          0 :       data1 = closure->data;
    2013                 :          0 :       data2 = instance;
    2014                 :            :     }
    2015                 :            :   else
    2016                 :            :     {
    2017                 :          0 :       data1 = instance;
    2018                 :          0 :       data2 = closure->data;
    2019                 :            :     }
    2020         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);
    2021                 :            : 
    2022                 :          0 :   callback (data1,
    2023                 :            :             arg0,
    2024                 :            :             data2);
    2025   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    2026                 :          0 :     g_variant_unref (arg0);
    2027                 :          0 : }
    2028                 :            : 
    2029                 :            : /**
    2030                 :            :  * g_cclosure_marshal_VOID__UINT_POINTER:
    2031                 :            :  * @closure: A #GClosure.
    2032                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    2033                 :            :  *   if the callback of closure doesn't return a value.
    2034                 :            :  * @n_param_values: The length of the @param_values array.
    2035                 :            :  * @param_values: An array of #GValues holding the arguments
    2036                 :            :  *   on which to invoke the callback of closure.
    2037                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    2038                 :            :  *   g_closure_invoke().
    2039                 :            :  * @marshal_data: Additional data specified when registering the
    2040                 :            :  *   marshaller, see g_closure_set_marshal() and
    2041                 :            :  *   g_closure_set_meta_marshal()
    2042                 :            :  *
    2043                 :            :  * A #GClosureMarshal function for use with signals with an unsigned int
    2044                 :            :  * and a pointer as arguments.
    2045                 :            :  */
    2046                 :            : /* VOID:UINT,POINTER */
    2047                 :            : void
    2048                 :     184767 : g_cclosure_marshal_VOID__UINT_POINTER (GClosure     *closure,
    2049                 :            :                                        GValue       *return_value G_GNUC_UNUSED,
    2050                 :            :                                        guint         n_param_values,
    2051                 :            :                                        const GValue *param_values,
    2052                 :            :                                        gpointer      invocation_hint G_GNUC_UNUSED,
    2053                 :            :                                        gpointer      marshal_data)
    2054                 :            : {
    2055                 :            :   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     data1,
    2056                 :            :                                                    guint        arg_1,
    2057                 :            :                                                    gpointer     arg_2,
    2058                 :            :                                                    gpointer     data2);
    2059                 :            :   GMarshalFunc_VOID__UINT_POINTER callback;
    2060                 :     184767 :   GCClosure *cc = (GCClosure*) closure;
    2061                 :            :   gpointer data1, data2;
    2062                 :            : 
    2063                 :     184767 :   g_return_if_fail (n_param_values == 3);
    2064                 :            : 
    2065         [ -  + ]:     184767 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2066                 :            :     {
    2067                 :          0 :       data1 = closure->data;
    2068                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    2069                 :            :     }
    2070                 :            :   else
    2071                 :            :     {
    2072                 :     184767 :       data1 = g_value_peek_pointer (param_values + 0);
    2073                 :     184767 :       data2 = closure->data;
    2074                 :            :     }
    2075         [ +  + ]:     184767 :   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
    2076                 :            : 
    2077                 :     184767 :   callback (data1,
    2078                 :            :             g_marshal_value_peek_uint (param_values + 1),
    2079                 :            :             g_marshal_value_peek_pointer (param_values + 2),
    2080                 :            :             data2);
    2081                 :            : }
    2082                 :            : 
    2083                 :            : /**
    2084                 :            :  * g_cclosure_marshal_VOID__UINT_POINTERv:
    2085                 :            :  * @closure: the #GClosure to which the marshaller belongs
    2086                 :            :  * @return_value: (nullable): a #GValue to store the return
    2087                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    2088                 :            :  *  value.
    2089                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    2090                 :            :  * @args: va_list of arguments to be passed to the closure.
    2091                 :            :  * @marshal_data: (nullable): additional data specified when
    2092                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    2093                 :            :  *  g_closure_set_meta_marshal()
    2094                 :            :  * @n_params: the length of the @param_types array
    2095                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    2096                 :            :  *  @args.
    2097                 :            :  *
    2098                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER().
    2099                 :            :  */
    2100                 :            : void
    2101                 :          0 : g_cclosure_marshal_VOID__UINT_POINTERv (GClosure     *closure,
    2102                 :            :                                         GValue       *return_value,
    2103                 :            :                                         gpointer      instance,
    2104                 :            :                                         va_list       args,
    2105                 :            :                                         gpointer      marshal_data,
    2106                 :            :                                         int           n_params,
    2107                 :            :                                         GType        *param_types)
    2108                 :            : {
    2109                 :            :   typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer     instance,
    2110                 :            :                                                    guint        arg_0,
    2111                 :            :                                                    gpointer     arg_1,
    2112                 :            :                                                    gpointer     data);
    2113                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    2114                 :            :   gpointer data1, data2;
    2115                 :            :   GMarshalFunc_VOID__UINT_POINTER callback;
    2116                 :            :   guint arg0;
    2117                 :            :   gpointer arg1;
    2118                 :            :   va_list args_copy;
    2119                 :            : 
    2120                 :          0 :   va_copy (args_copy, args);
    2121                 :          0 :   arg0 = (guint) va_arg (args_copy, guint);
    2122                 :          0 :   arg1 = (gpointer) va_arg (args_copy, gpointer);
    2123                 :          0 :   va_end (args_copy);
    2124                 :            : 
    2125         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2126                 :            :     {
    2127                 :          0 :       data1 = closure->data;
    2128                 :          0 :       data2 = instance;
    2129                 :            :     }
    2130                 :            :   else
    2131                 :            :     {
    2132                 :          0 :       data1 = instance;
    2133                 :          0 :       data2 = closure->data;
    2134                 :            :     }
    2135         [ #  # ]:          0 :   callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
    2136                 :            : 
    2137                 :          0 :   callback (data1,
    2138                 :            :             arg0,
    2139                 :            :             arg1,
    2140                 :            :             data2);
    2141                 :          0 : }
    2142                 :            : 
    2143                 :            : /**
    2144                 :            :  * g_cclosure_marshal_BOOLEAN__FLAGS:
    2145                 :            :  * @closure: A #GClosure.
    2146                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    2147                 :            :  *   if the callback of closure doesn't return a value.
    2148                 :            :  * @n_param_values: The length of the @param_values array.
    2149                 :            :  * @param_values: An array of #GValues holding the arguments
    2150                 :            :  *   on which to invoke the callback of closure.
    2151                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    2152                 :            :  *   g_closure_invoke().
    2153                 :            :  * @marshal_data: Additional data specified when registering the
    2154                 :            :  *   marshaller, see g_closure_set_marshal() and
    2155                 :            :  *   g_closure_set_meta_marshal()
    2156                 :            :  *
    2157                 :            :  * A #GClosureMarshal function for use with signals with handlers that
    2158                 :            :  * take a flags type as an argument and return a boolean.  If you have
    2159                 :            :  * such a signal, you will probably also need to use an accumulator,
    2160                 :            :  * such as g_signal_accumulator_true_handled().
    2161                 :            :  */
    2162                 :            : /* BOOL:FLAGS */
    2163                 :            : void
    2164                 :          0 : g_cclosure_marshal_BOOLEAN__FLAGS (GClosure     *closure,
    2165                 :            :                                    GValue       *return_value G_GNUC_UNUSED,
    2166                 :            :                                    guint         n_param_values,
    2167                 :            :                                    const GValue *param_values,
    2168                 :            :                                    gpointer      invocation_hint G_GNUC_UNUSED,
    2169                 :            :                                    gpointer      marshal_data)
    2170                 :            : {
    2171                 :            :   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     data1,
    2172                 :            :                                                    guint        arg_1,
    2173                 :            :                                                    gpointer     data2);
    2174                 :            :   GMarshalFunc_BOOLEAN__FLAGS callback;
    2175                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    2176                 :            :   gpointer data1, data2;
    2177                 :            :   gboolean v_return;
    2178                 :            : 
    2179                 :          0 :   g_return_if_fail (return_value != NULL);
    2180                 :          0 :   g_return_if_fail (n_param_values == 2);
    2181                 :            : 
    2182         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2183                 :            :     {
    2184                 :          0 :       data1 = closure->data;
    2185                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    2186                 :            :     }
    2187                 :            :   else
    2188                 :            :     {
    2189                 :          0 :       data1 = g_value_peek_pointer (param_values + 0);
    2190                 :          0 :       data2 = closure->data;
    2191                 :            :     }
    2192         [ #  # ]:          0 :   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
    2193                 :            : 
    2194                 :          0 :   v_return = callback (data1,
    2195                 :            :                        g_marshal_value_peek_flags (param_values + 1),
    2196                 :            :                        data2);
    2197                 :            : 
    2198                 :          0 :   g_value_set_boolean (return_value, v_return);
    2199                 :            : }
    2200                 :            : 
    2201                 :            : /**
    2202                 :            :  * g_cclosure_marshal_BOOLEAN__FLAGSv:
    2203                 :            :  * @closure: the #GClosure to which the marshaller belongs
    2204                 :            :  * @return_value: (nullable): a #GValue to store the return
    2205                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    2206                 :            :  *  value.
    2207                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    2208                 :            :  * @args: va_list of arguments to be passed to the closure.
    2209                 :            :  * @marshal_data: (nullable): additional data specified when
    2210                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    2211                 :            :  *  g_closure_set_meta_marshal()
    2212                 :            :  * @n_params: the length of the @param_types array
    2213                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    2214                 :            :  *  @args.
    2215                 :            :  *
    2216                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS().
    2217                 :            :  */
    2218                 :            : void
    2219                 :          0 : g_cclosure_marshal_BOOLEAN__FLAGSv (GClosure     *closure,
    2220                 :            :                                     GValue       *return_value,
    2221                 :            :                                     gpointer      instance,
    2222                 :            :                                     va_list       args,
    2223                 :            :                                     gpointer      marshal_data,
    2224                 :            :                                     int           n_params,
    2225                 :            :                                     GType        *param_types)
    2226                 :            : {
    2227                 :            :   typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer     instance,
    2228                 :            :                                                    guint        arg_0,
    2229                 :            :                                                    gpointer     data);
    2230                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    2231                 :            :   gpointer data1, data2;
    2232                 :            :   GMarshalFunc_BOOLEAN__FLAGS callback;
    2233                 :            :   guint arg0;
    2234                 :            :   va_list args_copy;
    2235                 :            :   gboolean v_return;
    2236                 :            : 
    2237                 :          0 :   g_return_if_fail (return_value != NULL);
    2238                 :            : 
    2239                 :          0 :   va_copy (args_copy, args);
    2240                 :          0 :   arg0 = (guint) va_arg (args_copy, guint);
    2241                 :          0 :   va_end (args_copy);
    2242                 :            : 
    2243         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2244                 :            :     {
    2245                 :          0 :       data1 = closure->data;
    2246                 :          0 :       data2 = instance;
    2247                 :            :     }
    2248                 :            :   else
    2249                 :            :     {
    2250                 :          0 :       data1 = instance;
    2251                 :          0 :       data2 = closure->data;
    2252                 :            :     }
    2253         [ #  # ]:          0 :   callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
    2254                 :            : 
    2255                 :          0 :   v_return = callback (data1,
    2256                 :            :                        arg0,
    2257                 :            :                        data2);
    2258                 :            : 
    2259                 :          0 :   g_value_set_boolean (return_value, v_return);
    2260                 :            : }
    2261                 :            : 
    2262                 :            : /**
    2263                 :            :  * g_cclosure_marshal_STRING__OBJECT_POINTER:
    2264                 :            :  * @closure: A #GClosure.
    2265                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    2266                 :            :  *   if the callback of closure doesn't return a value.
    2267                 :            :  * @n_param_values: The length of the @param_values array.
    2268                 :            :  * @param_values: An array of #GValues holding the arguments
    2269                 :            :  *   on which to invoke the callback of closure.
    2270                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    2271                 :            :  *   g_closure_invoke().
    2272                 :            :  * @marshal_data: Additional data specified when registering the
    2273                 :            :  *   marshaller, see g_closure_set_marshal() and
    2274                 :            :  *   g_closure_set_meta_marshal()
    2275                 :            :  *
    2276                 :            :  * A #GClosureMarshal function for use with signals with handlers that
    2277                 :            :  * take a #GObject and a pointer and produce a string.  It is highly
    2278                 :            :  * unlikely that your signal handler fits this description.
    2279                 :            :  */
    2280                 :            : /* STRING:OBJECT,POINTER */
    2281                 :            : void
    2282                 :          9 : g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure     *closure,
    2283                 :            :                                            GValue       *return_value G_GNUC_UNUSED,
    2284                 :            :                                            guint         n_param_values,
    2285                 :            :                                            const GValue *param_values,
    2286                 :            :                                            gpointer      invocation_hint G_GNUC_UNUSED,
    2287                 :            :                                            gpointer      marshal_data)
    2288                 :            : {
    2289                 :            :   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     data1,
    2290                 :            :                                                          gpointer     arg_1,
    2291                 :            :                                                          gpointer     arg_2,
    2292                 :            :                                                          gpointer     data2);
    2293                 :            :   GMarshalFunc_STRING__OBJECT_POINTER callback;
    2294                 :          9 :   GCClosure *cc = (GCClosure*) closure;
    2295                 :            :   gpointer data1, data2;
    2296                 :            :   gchar* v_return;
    2297                 :            : 
    2298                 :          9 :   g_return_if_fail (return_value != NULL);
    2299                 :          9 :   g_return_if_fail (n_param_values == 3);
    2300                 :            : 
    2301         [ -  + ]:          9 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2302                 :            :     {
    2303                 :          0 :       data1 = closure->data;
    2304                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    2305                 :            :     }
    2306                 :            :   else
    2307                 :            :     {
    2308                 :          9 :       data1 = g_value_peek_pointer (param_values + 0);
    2309                 :          9 :       data2 = closure->data;
    2310                 :            :     }
    2311         [ +  + ]:          9 :   callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
    2312                 :            : 
    2313                 :          9 :   v_return = callback (data1,
    2314                 :            :                        g_marshal_value_peek_object (param_values + 1),
    2315                 :            :                        g_marshal_value_peek_pointer (param_values + 2),
    2316                 :            :                        data2);
    2317                 :            : 
    2318                 :          9 :   g_value_take_string (return_value, v_return);
    2319                 :            : }
    2320                 :            : 
    2321                 :            : /**
    2322                 :            :  * g_cclosure_marshal_STRING__OBJECT_POINTERv:
    2323                 :            :  * @closure: the #GClosure to which the marshaller belongs
    2324                 :            :  * @return_value: (nullable): a #GValue to store the return
    2325                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    2326                 :            :  *  value.
    2327                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    2328                 :            :  * @args: va_list of arguments to be passed to the closure.
    2329                 :            :  * @marshal_data: (nullable): additional data specified when
    2330                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    2331                 :            :  *  g_closure_set_meta_marshal()
    2332                 :            :  * @n_params: the length of the @param_types array
    2333                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    2334                 :            :  *  @args.
    2335                 :            :  *
    2336                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER().
    2337                 :            :  */
    2338                 :            : void
    2339                 :          0 : g_cclosure_marshal_STRING__OBJECT_POINTERv (GClosure     *closure,
    2340                 :            :                                             GValue       *return_value,
    2341                 :            :                                             gpointer      instance,
    2342                 :            :                                             va_list       args,
    2343                 :            :                                             gpointer      marshal_data,
    2344                 :            :                                             int           n_params,
    2345                 :            :                                             GType        *param_types)
    2346                 :            : {
    2347                 :            :   typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer     instance,
    2348                 :            :                                                          gpointer     arg_0,
    2349                 :            :                                                          gpointer     arg_1,
    2350                 :            :                                                          gpointer     data);
    2351                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    2352                 :            :   gpointer data1, data2;
    2353                 :            :   GMarshalFunc_STRING__OBJECT_POINTER callback;
    2354                 :            :   gpointer arg0;
    2355                 :            :   gpointer arg1;
    2356                 :            :   va_list args_copy;
    2357                 :            :   gchar* v_return;
    2358                 :            : 
    2359                 :          0 :   g_return_if_fail (return_value != NULL);
    2360                 :            : 
    2361                 :          0 :   va_copy (args_copy, args);
    2362                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    2363         [ #  # ]:          0 :   if (arg0 != NULL)
    2364                 :          0 :     arg0 = g_object_ref (arg0);
    2365                 :          0 :   arg1 = (gpointer) va_arg (args_copy, gpointer);
    2366                 :          0 :   va_end (args_copy);
    2367                 :            : 
    2368         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2369                 :            :     {
    2370                 :          0 :       data1 = closure->data;
    2371                 :          0 :       data2 = instance;
    2372                 :            :     }
    2373                 :            :   else
    2374                 :            :     {
    2375                 :          0 :       data1 = instance;
    2376                 :          0 :       data2 = closure->data;
    2377                 :            :     }
    2378         [ #  # ]:          0 :   callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
    2379                 :            : 
    2380                 :          0 :   v_return = callback (data1,
    2381                 :            :                        arg0,
    2382                 :            :                        arg1,
    2383                 :            :                        data2);
    2384         [ #  # ]:          0 :   if (arg0 != NULL)
    2385                 :          0 :     g_object_unref (arg0);
    2386                 :            : 
    2387                 :          0 :   g_value_take_string (return_value, v_return);
    2388                 :            : }
    2389                 :            : 
    2390                 :            : /**
    2391                 :            :  * g_cclosure_marshal_BOOLEAN__BOXED_BOXED:
    2392                 :            :  * @closure: A #GClosure.
    2393                 :            :  * @return_value: A #GValue to store the return value. May be %NULL
    2394                 :            :  *   if the callback of closure doesn't return a value.
    2395                 :            :  * @n_param_values: The length of the @param_values array.
    2396                 :            :  * @param_values: An array of #GValues holding the arguments
    2397                 :            :  *   on which to invoke the callback of closure.
    2398                 :            :  * @invocation_hint: The invocation hint given as the last argument to
    2399                 :            :  *   g_closure_invoke().
    2400                 :            :  * @marshal_data: Additional data specified when registering the
    2401                 :            :  *   marshaller, see g_closure_set_marshal() and
    2402                 :            :  *   g_closure_set_meta_marshal()
    2403                 :            :  *
    2404                 :            :  * A #GClosureMarshal function for use with signals with handlers that
    2405                 :            :  * take two boxed pointers as arguments and return a boolean.  If you
    2406                 :            :  * have such a signal, you will probably also need to use an
    2407                 :            :  * accumulator, such as g_signal_accumulator_true_handled().
    2408                 :            :  */
    2409                 :            : /* BOOL:BOXED,BOXED */
    2410                 :            : void
    2411                 :          5 : g_cclosure_marshal_BOOLEAN__BOXED_BOXED (GClosure     *closure,
    2412                 :            :                                          GValue       *return_value G_GNUC_UNUSED,
    2413                 :            :                                          guint         n_param_values,
    2414                 :            :                                          const GValue *param_values,
    2415                 :            :                                          gpointer      invocation_hint G_GNUC_UNUSED,
    2416                 :            :                                          gpointer      marshal_data)
    2417                 :            : {
    2418                 :            :   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     data1,
    2419                 :            :                                                          gpointer     arg_1,
    2420                 :            :                                                          gpointer     arg_2,
    2421                 :            :                                                          gpointer     data2);
    2422                 :            :   GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
    2423                 :          5 :   GCClosure *cc = (GCClosure*) closure;
    2424                 :            :   gpointer data1, data2;
    2425                 :            :   gboolean v_return;
    2426                 :            : 
    2427                 :          5 :   g_return_if_fail (return_value != NULL);
    2428                 :          5 :   g_return_if_fail (n_param_values == 3);
    2429                 :            : 
    2430         [ -  + ]:          5 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2431                 :            :     {
    2432                 :          0 :       data1 = closure->data;
    2433                 :          0 :       data2 = g_value_peek_pointer (param_values + 0);
    2434                 :            :     }
    2435                 :            :   else
    2436                 :            :     {
    2437                 :          5 :       data1 = g_value_peek_pointer (param_values + 0);
    2438                 :          5 :       data2 = closure->data;
    2439                 :            :     }
    2440         [ +  - ]:          5 :   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
    2441                 :            : 
    2442                 :          5 :   v_return = callback (data1,
    2443                 :            :                        g_marshal_value_peek_boxed (param_values + 1),
    2444                 :            :                        g_marshal_value_peek_boxed (param_values + 2),
    2445                 :            :                        data2);
    2446                 :            : 
    2447                 :          5 :   g_value_set_boolean (return_value, v_return);
    2448                 :            : }
    2449                 :            : 
    2450                 :            : /**
    2451                 :            :  * g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv:
    2452                 :            :  * @closure: the #GClosure to which the marshaller belongs
    2453                 :            :  * @return_value: (nullable): a #GValue to store the return
    2454                 :            :  *  value. May be %NULL if the callback of @closure doesn't return a
    2455                 :            :  *  value.
    2456                 :            :  * @instance: (type GObject.TypeInstance): the instance on which the closure is invoked.
    2457                 :            :  * @args: va_list of arguments to be passed to the closure.
    2458                 :            :  * @marshal_data: (nullable): additional data specified when
    2459                 :            :  *  registering the marshaller, see g_closure_set_marshal() and
    2460                 :            :  *  g_closure_set_meta_marshal()
    2461                 :            :  * @n_params: the length of the @param_types array
    2462                 :            :  * @param_types: (array length=n_params): the #GType of each argument from
    2463                 :            :  *  @args.
    2464                 :            :  *
    2465                 :            :  * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED().
    2466                 :            :  */
    2467                 :            : void
    2468                 :          0 : g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv (GClosure     *closure,
    2469                 :            :                                           GValue       *return_value,
    2470                 :            :                                           gpointer      instance,
    2471                 :            :                                           va_list       args,
    2472                 :            :                                           gpointer      marshal_data,
    2473                 :            :                                           int           n_params,
    2474                 :            :                                           GType        *param_types)
    2475                 :            : {
    2476                 :            :   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     instance,
    2477                 :            :                                                          gpointer     arg_0,
    2478                 :            :                                                          gpointer     arg_1,
    2479                 :            :                                                          gpointer     data);
    2480                 :          0 :   GCClosure *cc = (GCClosure*) closure;
    2481                 :            :   gpointer data1, data2;
    2482                 :            :   GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
    2483                 :            :   gpointer arg0;
    2484                 :            :   gpointer arg1;
    2485                 :            :   va_list args_copy;
    2486                 :            :   gboolean v_return;
    2487                 :            : 
    2488                 :          0 :   g_return_if_fail (return_value != NULL);
    2489                 :            : 
    2490                 :          0 :   va_copy (args_copy, args);
    2491                 :          0 :   arg0 = (gpointer) va_arg (args_copy, gpointer);
    2492   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    2493                 :          0 :     arg0 = g_boxed_copy (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
    2494                 :          0 :   arg1 = (gpointer) va_arg (args_copy, gpointer);
    2495   [ #  #  #  # ]:          0 :   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
    2496                 :          0 :     arg1 = g_boxed_copy (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
    2497                 :          0 :   va_end (args_copy);
    2498                 :            : 
    2499         [ #  # ]:          0 :   if (G_CCLOSURE_SWAP_DATA (closure))
    2500                 :            :     {
    2501                 :          0 :       data1 = closure->data;
    2502                 :          0 :       data2 = instance;
    2503                 :            :     }
    2504                 :            :   else
    2505                 :            :     {
    2506                 :          0 :       data1 = instance;
    2507                 :          0 :       data2 = closure->data;
    2508                 :            :     }
    2509         [ #  # ]:          0 :   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
    2510                 :            : 
    2511                 :          0 :   v_return = callback (data1,
    2512                 :            :                        arg0,
    2513                 :            :                        arg1,
    2514                 :            :                        data2);
    2515   [ #  #  #  # ]:          0 :   if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
    2516                 :          0 :     g_boxed_free (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg0);
    2517   [ #  #  #  # ]:          0 :   if ((param_types[1] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg1 != NULL)
    2518                 :          0 :     g_boxed_free (param_types[1] & ~G_SIGNAL_TYPE_STATIC_SCOPE, arg1);
    2519                 :            : 
    2520                 :          0 :   g_value_set_boolean (return_value, v_return);
    2521                 :            : }

Generated by: LCOV version 1.14