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