1 #include "gtkmarshal.h"
2 #include "gtkalias.h"
3 /* This file is generated by glib-genmarshal, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */
4 #include <glib-object.h>
5 
6 #ifdef G_ENABLE_DEBUG
7 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
8 #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
9 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
10 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
11 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
12 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
13 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
14 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
15 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
16 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
17 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
18 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
19 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
20 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
21 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
22 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
23 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
24 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
25 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
26 #else /* !G_ENABLE_DEBUG */
27 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
28  *          Do not access GValues directly in your code. Instead, use the
29  *          g_value_get_*() functions
30  */
31 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
32 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
33 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
34 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
35 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
36 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
37 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
38 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
39 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
40 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
41 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
42 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
43 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
44 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
45 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
46 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
47 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
48 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
49 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
50 #endif /* !G_ENABLE_DEBUG */
51 
52 /* BOOL:NONE (./gtkmarshal.list:1) */
53 void
gtk_marshal_BOOLEAN__VOID(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)54 gtk_marshal_BOOLEAN__VOID (GClosure     *closure,
55                            GValue       *return_value,
56                            guint         n_param_values,
57                            const GValue *param_values,
58                            gpointer      invocation_hint G_GNUC_UNUSED,
59                            gpointer      marshal_data)
60 {
61   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
62                                                   gpointer data2);
63   GCClosure *cc = (GCClosure *) closure;
64   gpointer data1, data2;
65   GMarshalFunc_BOOLEAN__VOID callback;
66   gboolean v_return;
67 
68   g_return_if_fail (return_value != NULL);
69   g_return_if_fail (n_param_values == 1);
70 
71   if (G_CCLOSURE_SWAP_DATA (closure))
72     {
73       data1 = closure->data;
74       data2 = g_value_peek_pointer (param_values + 0);
75     }
76   else
77     {
78       data1 = g_value_peek_pointer (param_values + 0);
79       data2 = closure->data;
80     }
81   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
82 
83   v_return = callback (data1,
84                        data2);
85 
86   g_value_set_boolean (return_value, v_return);
87 }
88 
89 /* BOOL:POINTER (./gtkmarshal.list:2) */
90 void
gtk_marshal_BOOLEAN__POINTER(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)91 gtk_marshal_BOOLEAN__POINTER (GClosure     *closure,
92                               GValue       *return_value,
93                               guint         n_param_values,
94                               const GValue *param_values,
95                               gpointer      invocation_hint G_GNUC_UNUSED,
96                               gpointer      marshal_data)
97 {
98   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1,
99                                                      gpointer arg1,
100                                                      gpointer data2);
101   GCClosure *cc = (GCClosure *) closure;
102   gpointer data1, data2;
103   GMarshalFunc_BOOLEAN__POINTER callback;
104   gboolean v_return;
105 
106   g_return_if_fail (return_value != NULL);
107   g_return_if_fail (n_param_values == 2);
108 
109   if (G_CCLOSURE_SWAP_DATA (closure))
110     {
111       data1 = closure->data;
112       data2 = g_value_peek_pointer (param_values + 0);
113     }
114   else
115     {
116       data1 = g_value_peek_pointer (param_values + 0);
117       data2 = closure->data;
118     }
119   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
120 
121   v_return = callback (data1,
122                        g_marshal_value_peek_pointer (param_values + 1),
123                        data2);
124 
125   g_value_set_boolean (return_value, v_return);
126 }
127 
128 /* BOOL:POINTER,POINTER,INT,INT (./gtkmarshal.list:3) */
129 void
gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)130 gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT (GClosure     *closure,
131                                               GValue       *return_value,
132                                               guint         n_param_values,
133                                               const GValue *param_values,
134                                               gpointer      invocation_hint G_GNUC_UNUSED,
135                                               gpointer      marshal_data)
136 {
137   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT) (gpointer data1,
138                                                                      gpointer arg1,
139                                                                      gpointer arg2,
140                                                                      gint arg3,
141                                                                      gint arg4,
142                                                                      gpointer data2);
143   GCClosure *cc = (GCClosure *) closure;
144   gpointer data1, data2;
145   GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT callback;
146   gboolean v_return;
147 
148   g_return_if_fail (return_value != NULL);
149   g_return_if_fail (n_param_values == 5);
150 
151   if (G_CCLOSURE_SWAP_DATA (closure))
152     {
153       data1 = closure->data;
154       data2 = g_value_peek_pointer (param_values + 0);
155     }
156   else
157     {
158       data1 = g_value_peek_pointer (param_values + 0);
159       data2 = closure->data;
160     }
161   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT) (marshal_data ? marshal_data : cc->callback);
162 
163   v_return = callback (data1,
164                        g_marshal_value_peek_pointer (param_values + 1),
165                        g_marshal_value_peek_pointer (param_values + 2),
166                        g_marshal_value_peek_int (param_values + 3),
167                        g_marshal_value_peek_int (param_values + 4),
168                        data2);
169 
170   g_value_set_boolean (return_value, v_return);
171 }
172 
173 /* BOOL:POINTER,INT,INT (./gtkmarshal.list:4) */
174 void
gtk_marshal_BOOLEAN__POINTER_INT_INT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)175 gtk_marshal_BOOLEAN__POINTER_INT_INT (GClosure     *closure,
176                                       GValue       *return_value,
177                                       guint         n_param_values,
178                                       const GValue *param_values,
179                                       gpointer      invocation_hint G_GNUC_UNUSED,
180                                       gpointer      marshal_data)
181 {
182   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT_INT) (gpointer data1,
183                                                              gpointer arg1,
184                                                              gint arg2,
185                                                              gint arg3,
186                                                              gpointer data2);
187   GCClosure *cc = (GCClosure *) closure;
188   gpointer data1, data2;
189   GMarshalFunc_BOOLEAN__POINTER_INT_INT callback;
190   gboolean v_return;
191 
192   g_return_if_fail (return_value != NULL);
193   g_return_if_fail (n_param_values == 4);
194 
195   if (G_CCLOSURE_SWAP_DATA (closure))
196     {
197       data1 = closure->data;
198       data2 = g_value_peek_pointer (param_values + 0);
199     }
200   else
201     {
202       data1 = g_value_peek_pointer (param_values + 0);
203       data2 = closure->data;
204     }
205   callback = (GMarshalFunc_BOOLEAN__POINTER_INT_INT) (marshal_data ? marshal_data : cc->callback);
206 
207   v_return = callback (data1,
208                        g_marshal_value_peek_pointer (param_values + 1),
209                        g_marshal_value_peek_int (param_values + 2),
210                        g_marshal_value_peek_int (param_values + 3),
211                        data2);
212 
213   g_value_set_boolean (return_value, v_return);
214 }
215 
216 /* BOOL:POINTER,INT,INT,UINT (./gtkmarshal.list:5) */
217 void
gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)218 gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT (GClosure     *closure,
219                                            GValue       *return_value,
220                                            guint         n_param_values,
221                                            const GValue *param_values,
222                                            gpointer      invocation_hint G_GNUC_UNUSED,
223                                            gpointer      marshal_data)
224 {
225   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT) (gpointer data1,
226                                                                   gpointer arg1,
227                                                                   gint arg2,
228                                                                   gint arg3,
229                                                                   guint arg4,
230                                                                   gpointer data2);
231   GCClosure *cc = (GCClosure *) closure;
232   gpointer data1, data2;
233   GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT callback;
234   gboolean v_return;
235 
236   g_return_if_fail (return_value != NULL);
237   g_return_if_fail (n_param_values == 5);
238 
239   if (G_CCLOSURE_SWAP_DATA (closure))
240     {
241       data1 = closure->data;
242       data2 = g_value_peek_pointer (param_values + 0);
243     }
244   else
245     {
246       data1 = g_value_peek_pointer (param_values + 0);
247       data2 = closure->data;
248     }
249   callback = (GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
250 
251   v_return = callback (data1,
252                        g_marshal_value_peek_pointer (param_values + 1),
253                        g_marshal_value_peek_int (param_values + 2),
254                        g_marshal_value_peek_int (param_values + 3),
255                        g_marshal_value_peek_uint (param_values + 4),
256                        data2);
257 
258   g_value_set_boolean (return_value, v_return);
259 }
260 
261 /* BOOL:POINTER,STRING,STRING,POINTER (./gtkmarshal.list:6) */
262 void
gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)263 gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER (GClosure     *closure,
264                                                     GValue       *return_value,
265                                                     guint         n_param_values,
266                                                     const GValue *param_values,
267                                                     gpointer      invocation_hint G_GNUC_UNUSED,
268                                                     gpointer      marshal_data)
269 {
270   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER) (gpointer data1,
271                                                                            gpointer arg1,
272                                                                            gpointer arg2,
273                                                                            gpointer arg3,
274                                                                            gpointer arg4,
275                                                                            gpointer data2);
276   GCClosure *cc = (GCClosure *) closure;
277   gpointer data1, data2;
278   GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER callback;
279   gboolean v_return;
280 
281   g_return_if_fail (return_value != NULL);
282   g_return_if_fail (n_param_values == 5);
283 
284   if (G_CCLOSURE_SWAP_DATA (closure))
285     {
286       data1 = closure->data;
287       data2 = g_value_peek_pointer (param_values + 0);
288     }
289   else
290     {
291       data1 = g_value_peek_pointer (param_values + 0);
292       data2 = closure->data;
293     }
294   callback = (GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
295 
296   v_return = callback (data1,
297                        g_marshal_value_peek_pointer (param_values + 1),
298                        g_marshal_value_peek_string (param_values + 2),
299                        g_marshal_value_peek_string (param_values + 3),
300                        g_marshal_value_peek_pointer (param_values + 4),
301                        data2);
302 
303   g_value_set_boolean (return_value, v_return);
304 }
305 
306 /* ENUM:ENUM (./gtkmarshal.list:7) */
307 void
gtk_marshal_ENUM__ENUM(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)308 gtk_marshal_ENUM__ENUM (GClosure     *closure,
309                         GValue       *return_value,
310                         guint         n_param_values,
311                         const GValue *param_values,
312                         gpointer      invocation_hint G_GNUC_UNUSED,
313                         gpointer      marshal_data)
314 {
315   typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer data1,
316                                            gint arg1,
317                                            gpointer data2);
318   GCClosure *cc = (GCClosure *) closure;
319   gpointer data1, data2;
320   GMarshalFunc_ENUM__ENUM callback;
321   gint v_return;
322 
323   g_return_if_fail (return_value != NULL);
324   g_return_if_fail (n_param_values == 2);
325 
326   if (G_CCLOSURE_SWAP_DATA (closure))
327     {
328       data1 = closure->data;
329       data2 = g_value_peek_pointer (param_values + 0);
330     }
331   else
332     {
333       data1 = g_value_peek_pointer (param_values + 0);
334       data2 = closure->data;
335     }
336   callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
337 
338   v_return = callback (data1,
339                        g_marshal_value_peek_enum (param_values + 1),
340                        data2);
341 
342   g_value_set_enum (return_value, v_return);
343 }
344 
345 /* INT:POINTER (./gtkmarshal.list:8) */
346 void
gtk_marshal_INT__POINTER(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)347 gtk_marshal_INT__POINTER (GClosure     *closure,
348                           GValue       *return_value,
349                           guint         n_param_values,
350                           const GValue *param_values,
351                           gpointer      invocation_hint G_GNUC_UNUSED,
352                           gpointer      marshal_data)
353 {
354   typedef gint (*GMarshalFunc_INT__POINTER) (gpointer data1,
355                                              gpointer arg1,
356                                              gpointer data2);
357   GCClosure *cc = (GCClosure *) closure;
358   gpointer data1, data2;
359   GMarshalFunc_INT__POINTER callback;
360   gint v_return;
361 
362   g_return_if_fail (return_value != NULL);
363   g_return_if_fail (n_param_values == 2);
364 
365   if (G_CCLOSURE_SWAP_DATA (closure))
366     {
367       data1 = closure->data;
368       data2 = g_value_peek_pointer (param_values + 0);
369     }
370   else
371     {
372       data1 = g_value_peek_pointer (param_values + 0);
373       data2 = closure->data;
374     }
375   callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
376 
377   v_return = callback (data1,
378                        g_marshal_value_peek_pointer (param_values + 1),
379                        data2);
380 
381   g_value_set_int (return_value, v_return);
382 }
383 
384 /* INT:POINTER,CHAR,CHAR (./gtkmarshal.list:9) */
385 void
gtk_marshal_INT__POINTER_CHAR_CHAR(GClosure * closure,GValue * return_value,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)386 gtk_marshal_INT__POINTER_CHAR_CHAR (GClosure     *closure,
387                                     GValue       *return_value,
388                                     guint         n_param_values,
389                                     const GValue *param_values,
390                                     gpointer      invocation_hint G_GNUC_UNUSED,
391                                     gpointer      marshal_data)
392 {
393   typedef gint (*GMarshalFunc_INT__POINTER_CHAR_CHAR) (gpointer data1,
394                                                        gpointer arg1,
395                                                        gchar arg2,
396                                                        gchar arg3,
397                                                        gpointer data2);
398   GCClosure *cc = (GCClosure *) closure;
399   gpointer data1, data2;
400   GMarshalFunc_INT__POINTER_CHAR_CHAR callback;
401   gint v_return;
402 
403   g_return_if_fail (return_value != NULL);
404   g_return_if_fail (n_param_values == 4);
405 
406   if (G_CCLOSURE_SWAP_DATA (closure))
407     {
408       data1 = closure->data;
409       data2 = g_value_peek_pointer (param_values + 0);
410     }
411   else
412     {
413       data1 = g_value_peek_pointer (param_values + 0);
414       data2 = closure->data;
415     }
416   callback = (GMarshalFunc_INT__POINTER_CHAR_CHAR) (marshal_data ? marshal_data : cc->callback);
417 
418   v_return = callback (data1,
419                        g_marshal_value_peek_pointer (param_values + 1),
420                        g_marshal_value_peek_char (param_values + 2),
421                        g_marshal_value_peek_char (param_values + 3),
422                        data2);
423 
424   g_value_set_int (return_value, v_return);
425 }
426 
427 /* NONE:ENUM,FLOAT (./gtkmarshal.list:13) */
428 void
gtk_marshal_VOID__ENUM_FLOAT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)429 gtk_marshal_VOID__ENUM_FLOAT (GClosure     *closure,
430                               GValue       *return_value G_GNUC_UNUSED,
431                               guint         n_param_values,
432                               const GValue *param_values,
433                               gpointer      invocation_hint G_GNUC_UNUSED,
434                               gpointer      marshal_data)
435 {
436   typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer data1,
437                                                  gint arg1,
438                                                  gfloat arg2,
439                                                  gpointer data2);
440   GCClosure *cc = (GCClosure *) closure;
441   gpointer data1, data2;
442   GMarshalFunc_VOID__ENUM_FLOAT callback;
443 
444   g_return_if_fail (n_param_values == 3);
445 
446   if (G_CCLOSURE_SWAP_DATA (closure))
447     {
448       data1 = closure->data;
449       data2 = g_value_peek_pointer (param_values + 0);
450     }
451   else
452     {
453       data1 = g_value_peek_pointer (param_values + 0);
454       data2 = closure->data;
455     }
456   callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
457 
458   callback (data1,
459             g_marshal_value_peek_enum (param_values + 1),
460             g_marshal_value_peek_float (param_values + 2),
461             data2);
462 }
463 
464 /* NONE:ENUM,FLOAT,BOOL (./gtkmarshal.list:14) */
465 void
gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)466 gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure     *closure,
467                                       GValue       *return_value G_GNUC_UNUSED,
468                                       guint         n_param_values,
469                                       const GValue *param_values,
470                                       gpointer      invocation_hint G_GNUC_UNUSED,
471                                       gpointer      marshal_data)
472 {
473   typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer data1,
474                                                          gint arg1,
475                                                          gfloat arg2,
476                                                          gboolean arg3,
477                                                          gpointer data2);
478   GCClosure *cc = (GCClosure *) closure;
479   gpointer data1, data2;
480   GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
481 
482   g_return_if_fail (n_param_values == 4);
483 
484   if (G_CCLOSURE_SWAP_DATA (closure))
485     {
486       data1 = closure->data;
487       data2 = g_value_peek_pointer (param_values + 0);
488     }
489   else
490     {
491       data1 = g_value_peek_pointer (param_values + 0);
492       data2 = closure->data;
493     }
494   callback = (GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
495 
496   callback (data1,
497             g_marshal_value_peek_enum (param_values + 1),
498             g_marshal_value_peek_float (param_values + 2),
499             g_marshal_value_peek_boolean (param_values + 3),
500             data2);
501 }
502 
503 /* NONE:INT,INT (./gtkmarshal.list:16) */
504 void
gtk_marshal_VOID__INT_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)505 gtk_marshal_VOID__INT_INT (GClosure     *closure,
506                            GValue       *return_value G_GNUC_UNUSED,
507                            guint         n_param_values,
508                            const GValue *param_values,
509                            gpointer      invocation_hint G_GNUC_UNUSED,
510                            gpointer      marshal_data)
511 {
512   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
513                                               gint arg1,
514                                               gint arg2,
515                                               gpointer data2);
516   GCClosure *cc = (GCClosure *) closure;
517   gpointer data1, data2;
518   GMarshalFunc_VOID__INT_INT callback;
519 
520   g_return_if_fail (n_param_values == 3);
521 
522   if (G_CCLOSURE_SWAP_DATA (closure))
523     {
524       data1 = closure->data;
525       data2 = g_value_peek_pointer (param_values + 0);
526     }
527   else
528     {
529       data1 = g_value_peek_pointer (param_values + 0);
530       data2 = closure->data;
531     }
532   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
533 
534   callback (data1,
535             g_marshal_value_peek_int (param_values + 1),
536             g_marshal_value_peek_int (param_values + 2),
537             data2);
538 }
539 
540 /* NONE:INT,INT,POINTER (./gtkmarshal.list:17) */
541 void
gtk_marshal_VOID__INT_INT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)542 gtk_marshal_VOID__INT_INT_POINTER (GClosure     *closure,
543                                    GValue       *return_value G_GNUC_UNUSED,
544                                    guint         n_param_values,
545                                    const GValue *param_values,
546                                    gpointer      invocation_hint G_GNUC_UNUSED,
547                                    gpointer      marshal_data)
548 {
549   typedef void (*GMarshalFunc_VOID__INT_INT_POINTER) (gpointer data1,
550                                                       gint arg1,
551                                                       gint arg2,
552                                                       gpointer arg3,
553                                                       gpointer data2);
554   GCClosure *cc = (GCClosure *) closure;
555   gpointer data1, data2;
556   GMarshalFunc_VOID__INT_INT_POINTER callback;
557 
558   g_return_if_fail (n_param_values == 4);
559 
560   if (G_CCLOSURE_SWAP_DATA (closure))
561     {
562       data1 = closure->data;
563       data2 = g_value_peek_pointer (param_values + 0);
564     }
565   else
566     {
567       data1 = g_value_peek_pointer (param_values + 0);
568       data2 = closure->data;
569     }
570   callback = (GMarshalFunc_VOID__INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
571 
572   callback (data1,
573             g_marshal_value_peek_int (param_values + 1),
574             g_marshal_value_peek_int (param_values + 2),
575             g_marshal_value_peek_pointer (param_values + 3),
576             data2);
577 }
578 
579 /* NONE:POINTER,INT (./gtkmarshal.list:21) */
580 void
gtk_marshal_VOID__POINTER_INT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)581 gtk_marshal_VOID__POINTER_INT (GClosure     *closure,
582                                GValue       *return_value G_GNUC_UNUSED,
583                                guint         n_param_values,
584                                const GValue *param_values,
585                                gpointer      invocation_hint G_GNUC_UNUSED,
586                                gpointer      marshal_data)
587 {
588   typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
589                                                   gpointer arg1,
590                                                   gint arg2,
591                                                   gpointer data2);
592   GCClosure *cc = (GCClosure *) closure;
593   gpointer data1, data2;
594   GMarshalFunc_VOID__POINTER_INT callback;
595 
596   g_return_if_fail (n_param_values == 3);
597 
598   if (G_CCLOSURE_SWAP_DATA (closure))
599     {
600       data1 = closure->data;
601       data2 = g_value_peek_pointer (param_values + 0);
602     }
603   else
604     {
605       data1 = g_value_peek_pointer (param_values + 0);
606       data2 = closure->data;
607     }
608   callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
609 
610   callback (data1,
611             g_marshal_value_peek_pointer (param_values + 1),
612             g_marshal_value_peek_int (param_values + 2),
613             data2);
614 }
615 
616 /* NONE:POINTER,POINTER (./gtkmarshal.list:22) */
617 void
gtk_marshal_VOID__POINTER_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)618 gtk_marshal_VOID__POINTER_POINTER (GClosure     *closure,
619                                    GValue       *return_value G_GNUC_UNUSED,
620                                    guint         n_param_values,
621                                    const GValue *param_values,
622                                    gpointer      invocation_hint G_GNUC_UNUSED,
623                                    gpointer      marshal_data)
624 {
625   typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer data1,
626                                                       gpointer arg1,
627                                                       gpointer arg2,
628                                                       gpointer data2);
629   GCClosure *cc = (GCClosure *) closure;
630   gpointer data1, data2;
631   GMarshalFunc_VOID__POINTER_POINTER callback;
632 
633   g_return_if_fail (n_param_values == 3);
634 
635   if (G_CCLOSURE_SWAP_DATA (closure))
636     {
637       data1 = closure->data;
638       data2 = g_value_peek_pointer (param_values + 0);
639     }
640   else
641     {
642       data1 = g_value_peek_pointer (param_values + 0);
643       data2 = closure->data;
644     }
645   callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
646 
647   callback (data1,
648             g_marshal_value_peek_pointer (param_values + 1),
649             g_marshal_value_peek_pointer (param_values + 2),
650             data2);
651 }
652 
653 /* NONE:POINTER,POINTER,POINTER (./gtkmarshal.list:23) */
654 void
gtk_marshal_VOID__POINTER_POINTER_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)655 gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure     *closure,
656                                            GValue       *return_value G_GNUC_UNUSED,
657                                            guint         n_param_values,
658                                            const GValue *param_values,
659                                            gpointer      invocation_hint G_GNUC_UNUSED,
660                                            gpointer      marshal_data)
661 {
662   typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
663                                                               gpointer arg1,
664                                                               gpointer arg2,
665                                                               gpointer arg3,
666                                                               gpointer data2);
667   GCClosure *cc = (GCClosure *) closure;
668   gpointer data1, data2;
669   GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
670 
671   g_return_if_fail (n_param_values == 4);
672 
673   if (G_CCLOSURE_SWAP_DATA (closure))
674     {
675       data1 = closure->data;
676       data2 = g_value_peek_pointer (param_values + 0);
677     }
678   else
679     {
680       data1 = g_value_peek_pointer (param_values + 0);
681       data2 = closure->data;
682     }
683   callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
684 
685   callback (data1,
686             g_marshal_value_peek_pointer (param_values + 1),
687             g_marshal_value_peek_pointer (param_values + 2),
688             g_marshal_value_peek_pointer (param_values + 3),
689             data2);
690 }
691 
692 /* NONE:POINTER,STRING,STRING (./gtkmarshal.list:24) */
693 void
gtk_marshal_VOID__POINTER_STRING_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)694 gtk_marshal_VOID__POINTER_STRING_STRING (GClosure     *closure,
695                                          GValue       *return_value G_GNUC_UNUSED,
696                                          guint         n_param_values,
697                                          const GValue *param_values,
698                                          gpointer      invocation_hint G_GNUC_UNUSED,
699                                          gpointer      marshal_data)
700 {
701   typedef void (*GMarshalFunc_VOID__POINTER_STRING_STRING) (gpointer data1,
702                                                             gpointer arg1,
703                                                             gpointer arg2,
704                                                             gpointer arg3,
705                                                             gpointer data2);
706   GCClosure *cc = (GCClosure *) closure;
707   gpointer data1, data2;
708   GMarshalFunc_VOID__POINTER_STRING_STRING callback;
709 
710   g_return_if_fail (n_param_values == 4);
711 
712   if (G_CCLOSURE_SWAP_DATA (closure))
713     {
714       data1 = closure->data;
715       data2 = g_value_peek_pointer (param_values + 0);
716     }
717   else
718     {
719       data1 = g_value_peek_pointer (param_values + 0);
720       data2 = closure->data;
721     }
722   callback = (GMarshalFunc_VOID__POINTER_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
723 
724   callback (data1,
725             g_marshal_value_peek_pointer (param_values + 1),
726             g_marshal_value_peek_string (param_values + 2),
727             g_marshal_value_peek_string (param_values + 3),
728             data2);
729 }
730 
731 /* NONE:POINTER,UINT (./gtkmarshal.list:25) */
732 void
gtk_marshal_VOID__POINTER_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)733 gtk_marshal_VOID__POINTER_UINT (GClosure     *closure,
734                                 GValue       *return_value G_GNUC_UNUSED,
735                                 guint         n_param_values,
736                                 const GValue *param_values,
737                                 gpointer      invocation_hint G_GNUC_UNUSED,
738                                 gpointer      marshal_data)
739 {
740   typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
741                                                    gpointer arg1,
742                                                    guint arg2,
743                                                    gpointer data2);
744   GCClosure *cc = (GCClosure *) closure;
745   gpointer data1, data2;
746   GMarshalFunc_VOID__POINTER_UINT callback;
747 
748   g_return_if_fail (n_param_values == 3);
749 
750   if (G_CCLOSURE_SWAP_DATA (closure))
751     {
752       data1 = closure->data;
753       data2 = g_value_peek_pointer (param_values + 0);
754     }
755   else
756     {
757       data1 = g_value_peek_pointer (param_values + 0);
758       data2 = closure->data;
759     }
760   callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
761 
762   callback (data1,
763             g_marshal_value_peek_pointer (param_values + 1),
764             g_marshal_value_peek_uint (param_values + 2),
765             data2);
766 }
767 
768 /* NONE:POINTER,UINT,ENUM (./gtkmarshal.list:26) */
769 void
gtk_marshal_VOID__POINTER_UINT_ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)770 gtk_marshal_VOID__POINTER_UINT_ENUM (GClosure     *closure,
771                                      GValue       *return_value G_GNUC_UNUSED,
772                                      guint         n_param_values,
773                                      const GValue *param_values,
774                                      gpointer      invocation_hint G_GNUC_UNUSED,
775                                      gpointer      marshal_data)
776 {
777   typedef void (*GMarshalFunc_VOID__POINTER_UINT_ENUM) (gpointer data1,
778                                                         gpointer arg1,
779                                                         guint arg2,
780                                                         gint arg3,
781                                                         gpointer data2);
782   GCClosure *cc = (GCClosure *) closure;
783   gpointer data1, data2;
784   GMarshalFunc_VOID__POINTER_UINT_ENUM callback;
785 
786   g_return_if_fail (n_param_values == 4);
787 
788   if (G_CCLOSURE_SWAP_DATA (closure))
789     {
790       data1 = closure->data;
791       data2 = g_value_peek_pointer (param_values + 0);
792     }
793   else
794     {
795       data1 = g_value_peek_pointer (param_values + 0);
796       data2 = closure->data;
797     }
798   callback = (GMarshalFunc_VOID__POINTER_UINT_ENUM) (marshal_data ? marshal_data : cc->callback);
799 
800   callback (data1,
801             g_marshal_value_peek_pointer (param_values + 1),
802             g_marshal_value_peek_uint (param_values + 2),
803             g_marshal_value_peek_enum (param_values + 3),
804             data2);
805 }
806 
807 /* NONE:POINTER,POINTER,UINT,UINT (./gtkmarshal.list:27) */
808 void
gtk_marshal_VOID__POINTER_POINTER_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)809 gtk_marshal_VOID__POINTER_POINTER_UINT_UINT (GClosure     *closure,
810                                              GValue       *return_value G_GNUC_UNUSED,
811                                              guint         n_param_values,
812                                              const GValue *param_values,
813                                              gpointer      invocation_hint G_GNUC_UNUSED,
814                                              gpointer      marshal_data)
815 {
816   typedef void (*GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT) (gpointer data1,
817                                                                 gpointer arg1,
818                                                                 gpointer arg2,
819                                                                 guint arg3,
820                                                                 guint arg4,
821                                                                 gpointer data2);
822   GCClosure *cc = (GCClosure *) closure;
823   gpointer data1, data2;
824   GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT callback;
825 
826   g_return_if_fail (n_param_values == 5);
827 
828   if (G_CCLOSURE_SWAP_DATA (closure))
829     {
830       data1 = closure->data;
831       data2 = g_value_peek_pointer (param_values + 0);
832     }
833   else
834     {
835       data1 = g_value_peek_pointer (param_values + 0);
836       data2 = closure->data;
837     }
838   callback = (GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
839 
840   callback (data1,
841             g_marshal_value_peek_pointer (param_values + 1),
842             g_marshal_value_peek_pointer (param_values + 2),
843             g_marshal_value_peek_uint (param_values + 3),
844             g_marshal_value_peek_uint (param_values + 4),
845             data2);
846 }
847 
848 /* NONE:POINTER,INT,INT,POINTER,UINT,UINT (./gtkmarshal.list:28) */
849 void
gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)850 gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT (GClosure     *closure,
851                                                      GValue       *return_value G_GNUC_UNUSED,
852                                                      guint         n_param_values,
853                                                      const GValue *param_values,
854                                                      gpointer      invocation_hint G_GNUC_UNUSED,
855                                                      gpointer      marshal_data)
856 {
857   typedef void (*GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT) (gpointer data1,
858                                                                         gpointer arg1,
859                                                                         gint arg2,
860                                                                         gint arg3,
861                                                                         gpointer arg4,
862                                                                         guint arg5,
863                                                                         guint arg6,
864                                                                         gpointer data2);
865   GCClosure *cc = (GCClosure *) closure;
866   gpointer data1, data2;
867   GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT callback;
868 
869   g_return_if_fail (n_param_values == 7);
870 
871   if (G_CCLOSURE_SWAP_DATA (closure))
872     {
873       data1 = closure->data;
874       data2 = g_value_peek_pointer (param_values + 0);
875     }
876   else
877     {
878       data1 = g_value_peek_pointer (param_values + 0);
879       data2 = closure->data;
880     }
881   callback = (GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
882 
883   callback (data1,
884             g_marshal_value_peek_pointer (param_values + 1),
885             g_marshal_value_peek_int (param_values + 2),
886             g_marshal_value_peek_int (param_values + 3),
887             g_marshal_value_peek_pointer (param_values + 4),
888             g_marshal_value_peek_uint (param_values + 5),
889             g_marshal_value_peek_uint (param_values + 6),
890             data2);
891 }
892 
893 /* NONE:POINTER,UINT,UINT (./gtkmarshal.list:29) */
894 void
gtk_marshal_VOID__POINTER_UINT_UINT(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)895 gtk_marshal_VOID__POINTER_UINT_UINT (GClosure     *closure,
896                                      GValue       *return_value G_GNUC_UNUSED,
897                                      guint         n_param_values,
898                                      const GValue *param_values,
899                                      gpointer      invocation_hint G_GNUC_UNUSED,
900                                      gpointer      marshal_data)
901 {
902   typedef void (*GMarshalFunc_VOID__POINTER_UINT_UINT) (gpointer data1,
903                                                         gpointer arg1,
904                                                         guint arg2,
905                                                         guint arg3,
906                                                         gpointer data2);
907   GCClosure *cc = (GCClosure *) closure;
908   gpointer data1, data2;
909   GMarshalFunc_VOID__POINTER_UINT_UINT callback;
910 
911   g_return_if_fail (n_param_values == 4);
912 
913   if (G_CCLOSURE_SWAP_DATA (closure))
914     {
915       data1 = closure->data;
916       data2 = g_value_peek_pointer (param_values + 0);
917     }
918   else
919     {
920       data1 = g_value_peek_pointer (param_values + 0);
921       data2 = closure->data;
922     }
923   callback = (GMarshalFunc_VOID__POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
924 
925   callback (data1,
926             g_marshal_value_peek_pointer (param_values + 1),
927             g_marshal_value_peek_uint (param_values + 2),
928             g_marshal_value_peek_uint (param_values + 3),
929             data2);
930 }
931 
932 /* NONE:STRING,INT,POINTER (./gtkmarshal.list:32) */
933 void
gtk_marshal_VOID__STRING_INT_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)934 gtk_marshal_VOID__STRING_INT_POINTER (GClosure     *closure,
935                                       GValue       *return_value G_GNUC_UNUSED,
936                                       guint         n_param_values,
937                                       const GValue *param_values,
938                                       gpointer      invocation_hint G_GNUC_UNUSED,
939                                       gpointer      marshal_data)
940 {
941   typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer data1,
942                                                          gpointer arg1,
943                                                          gint arg2,
944                                                          gpointer arg3,
945                                                          gpointer data2);
946   GCClosure *cc = (GCClosure *) closure;
947   gpointer data1, data2;
948   GMarshalFunc_VOID__STRING_INT_POINTER callback;
949 
950   g_return_if_fail (n_param_values == 4);
951 
952   if (G_CCLOSURE_SWAP_DATA (closure))
953     {
954       data1 = closure->data;
955       data2 = g_value_peek_pointer (param_values + 0);
956     }
957   else
958     {
959       data1 = g_value_peek_pointer (param_values + 0);
960       data2 = closure->data;
961     }
962   callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
963 
964   callback (data1,
965             g_marshal_value_peek_string (param_values + 1),
966             g_marshal_value_peek_int (param_values + 2),
967             g_marshal_value_peek_pointer (param_values + 3),
968             data2);
969 }
970 
971 /* NONE:UINT,POINTER,UINT,ENUM,ENUM,POINTER (./gtkmarshal.list:34) */
972 void
gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)973 gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER (GClosure     *closure,
974                                                        GValue       *return_value G_GNUC_UNUSED,
975                                                        guint         n_param_values,
976                                                        const GValue *param_values,
977                                                        gpointer      invocation_hint G_GNUC_UNUSED,
978                                                        gpointer      marshal_data)
979 {
980   typedef void (*GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER) (gpointer data1,
981                                                                           guint arg1,
982                                                                           gpointer arg2,
983                                                                           guint arg3,
984                                                                           gint arg4,
985                                                                           gint arg5,
986                                                                           gpointer arg6,
987                                                                           gpointer data2);
988   GCClosure *cc = (GCClosure *) closure;
989   gpointer data1, data2;
990   GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER callback;
991 
992   g_return_if_fail (n_param_values == 7);
993 
994   if (G_CCLOSURE_SWAP_DATA (closure))
995     {
996       data1 = closure->data;
997       data2 = g_value_peek_pointer (param_values + 0);
998     }
999   else
1000     {
1001       data1 = g_value_peek_pointer (param_values + 0);
1002       data2 = closure->data;
1003     }
1004   callback = (GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER) (marshal_data ? marshal_data : cc->callback);
1005 
1006   callback (data1,
1007             g_marshal_value_peek_uint (param_values + 1),
1008             g_marshal_value_peek_pointer (param_values + 2),
1009             g_marshal_value_peek_uint (param_values + 3),
1010             g_marshal_value_peek_enum (param_values + 4),
1011             g_marshal_value_peek_enum (param_values + 5),
1012             g_marshal_value_peek_pointer (param_values + 6),
1013             data2);
1014 }
1015 
1016 /* NONE:UINT,POINTER,UINT,UINT,ENUM (./gtkmarshal.list:35) */
1017 void
gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1018 gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM (GClosure     *closure,
1019                                                GValue       *return_value G_GNUC_UNUSED,
1020                                                guint         n_param_values,
1021                                                const GValue *param_values,
1022                                                gpointer      invocation_hint G_GNUC_UNUSED,
1023                                                gpointer      marshal_data)
1024 {
1025   typedef void (*GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM) (gpointer data1,
1026                                                                   guint arg1,
1027                                                                   gpointer arg2,
1028                                                                   guint arg3,
1029                                                                   guint arg4,
1030                                                                   gint arg5,
1031                                                                   gpointer data2);
1032   GCClosure *cc = (GCClosure *) closure;
1033   gpointer data1, data2;
1034   GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM callback;
1035 
1036   g_return_if_fail (n_param_values == 6);
1037 
1038   if (G_CCLOSURE_SWAP_DATA (closure))
1039     {
1040       data1 = closure->data;
1041       data2 = g_value_peek_pointer (param_values + 0);
1042     }
1043   else
1044     {
1045       data1 = g_value_peek_pointer (param_values + 0);
1046       data2 = closure->data;
1047     }
1048   callback = (GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM) (marshal_data ? marshal_data : cc->callback);
1049 
1050   callback (data1,
1051             g_marshal_value_peek_uint (param_values + 1),
1052             g_marshal_value_peek_pointer (param_values + 2),
1053             g_marshal_value_peek_uint (param_values + 3),
1054             g_marshal_value_peek_uint (param_values + 4),
1055             g_marshal_value_peek_enum (param_values + 5),
1056             data2);
1057 }
1058 
1059 /* NONE:UINT,STRING (./gtkmarshal.list:36) */
1060 void
gtk_marshal_VOID__UINT_STRING(GClosure * closure,GValue * return_value G_GNUC_UNUSED,guint n_param_values,const GValue * param_values,gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data)1061 gtk_marshal_VOID__UINT_STRING (GClosure     *closure,
1062                                GValue       *return_value G_GNUC_UNUSED,
1063                                guint         n_param_values,
1064                                const GValue *param_values,
1065                                gpointer      invocation_hint G_GNUC_UNUSED,
1066                                gpointer      marshal_data)
1067 {
1068   typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer data1,
1069                                                   guint arg1,
1070                                                   gpointer arg2,
1071                                                   gpointer data2);
1072   GCClosure *cc = (GCClosure *) closure;
1073   gpointer data1, data2;
1074   GMarshalFunc_VOID__UINT_STRING callback;
1075 
1076   g_return_if_fail (n_param_values == 3);
1077 
1078   if (G_CCLOSURE_SWAP_DATA (closure))
1079     {
1080       data1 = closure->data;
1081       data2 = g_value_peek_pointer (param_values + 0);
1082     }
1083   else
1084     {
1085       data1 = g_value_peek_pointer (param_values + 0);
1086       data2 = closure->data;
1087     }
1088   callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
1089 
1090   callback (data1,
1091             g_marshal_value_peek_uint (param_values + 1),
1092             g_marshal_value_peek_string (param_values + 2),
1093             data2);
1094 }
1095 
1096 #define __gtk_marshal_MARSHAL_C__
1097 #include "gtkaliasdef.c"
1098