00001
00002 #include <glib-object.h>
00003
00004
00005 #ifdef G_ENABLE_DEBUG
00006 #define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
00007 #define g_marshal_value_peek_char(v) g_value_get_char (v)
00008 #define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
00009 #define g_marshal_value_peek_int(v) g_value_get_int (v)
00010 #define g_marshal_value_peek_uint(v) g_value_get_uint (v)
00011 #define g_marshal_value_peek_long(v) g_value_get_long (v)
00012 #define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
00013 #define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
00014 #define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
00015 #define g_marshal_value_peek_enum(v) g_value_get_enum (v)
00016 #define g_marshal_value_peek_flags(v) g_value_get_flags (v)
00017 #define g_marshal_value_peek_float(v) g_value_get_float (v)
00018 #define g_marshal_value_peek_double(v) g_value_get_double (v)
00019 #define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
00020 #define g_marshal_value_peek_param(v) g_value_get_param (v)
00021 #define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
00022 #define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
00023 #define g_marshal_value_peek_object(v) g_value_get_object (v)
00024 #else
00025
00026
00027
00028
00029 #define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
00030 #define g_marshal_value_peek_char(v) (v)->data[0].v_int
00031 #define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
00032 #define g_marshal_value_peek_int(v) (v)->data[0].v_int
00033 #define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
00034 #define g_marshal_value_peek_long(v) (v)->data[0].v_long
00035 #define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
00036 #define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
00037 #define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
00038 #define g_marshal_value_peek_enum(v) (v)->data[0].v_int
00039 #define g_marshal_value_peek_flags(v) (v)->data[0].v_uint
00040 #define g_marshal_value_peek_float(v) (v)->data[0].v_float
00041 #define g_marshal_value_peek_double(v) (v)->data[0].v_double
00042 #define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
00043 #define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
00044 #define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
00045 #define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
00046 #define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
00047 #endif
00048
00049
00050
00051 void
00052 gtk_marshal_BOOLEAN__VOID (GClosure *closure,
00053 GValue *return_value,
00054 guint n_param_values,
00055 const GValue *param_values,
00056 gpointer invocation_hint,
00057 gpointer marshal_data)
00058 {
00059 typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
00060 gpointer data2);
00061 register GMarshalFunc_BOOLEAN__VOID callback;
00062 register GCClosure *cc = (GCClosure*) closure;
00063 register gpointer data1, data2;
00064 gboolean v_return;
00065
00066 g_return_if_fail (return_value != NULL);
00067 g_return_if_fail (n_param_values == 1);
00068
00069 if (G_CCLOSURE_SWAP_DATA (closure))
00070 {
00071 data1 = closure->data;
00072 data2 = g_value_peek_pointer (param_values + 0);
00073 }
00074 else
00075 {
00076 data1 = g_value_peek_pointer (param_values + 0);
00077 data2 = closure->data;
00078 }
00079 callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
00080
00081 v_return = callback (data1,
00082 data2);
00083
00084 g_value_set_boolean (return_value, v_return);
00085 }
00086
00087
00088 void
00089 gtk_marshal_BOOLEAN__POINTER (GClosure *closure,
00090 GValue *return_value,
00091 guint n_param_values,
00092 const GValue *param_values,
00093 gpointer invocation_hint,
00094 gpointer marshal_data)
00095 {
00096 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer data1,
00097 gpointer arg_1,
00098 gpointer data2);
00099 register GMarshalFunc_BOOLEAN__POINTER callback;
00100 register GCClosure *cc = (GCClosure*) closure;
00101 register gpointer data1, data2;
00102 gboolean v_return;
00103
00104 g_return_if_fail (return_value != NULL);
00105 g_return_if_fail (n_param_values == 2);
00106
00107 if (G_CCLOSURE_SWAP_DATA (closure))
00108 {
00109 data1 = closure->data;
00110 data2 = g_value_peek_pointer (param_values + 0);
00111 }
00112 else
00113 {
00114 data1 = g_value_peek_pointer (param_values + 0);
00115 data2 = closure->data;
00116 }
00117 callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
00118
00119 v_return = callback (data1,
00120 g_marshal_value_peek_pointer (param_values + 1),
00121 data2);
00122
00123 g_value_set_boolean (return_value, v_return);
00124 }
00125
00126
00127 void
00128 gtk_marshal_BOOLEAN__POINTER_POINTER_INT_INT (GClosure *closure,
00129 GValue *return_value,
00130 guint n_param_values,
00131 const GValue *param_values,
00132 gpointer invocation_hint,
00133 gpointer marshal_data)
00134 {
00135 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT) (gpointer data1,
00136 gpointer arg_1,
00137 gpointer arg_2,
00138 gint arg_3,
00139 gint arg_4,
00140 gpointer data2);
00141 register GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT callback;
00142 register GCClosure *cc = (GCClosure*) closure;
00143 register gpointer data1, data2;
00144 gboolean v_return;
00145
00146 g_return_if_fail (return_value != NULL);
00147 g_return_if_fail (n_param_values == 5);
00148
00149 if (G_CCLOSURE_SWAP_DATA (closure))
00150 {
00151 data1 = closure->data;
00152 data2 = g_value_peek_pointer (param_values + 0);
00153 }
00154 else
00155 {
00156 data1 = g_value_peek_pointer (param_values + 0);
00157 data2 = closure->data;
00158 }
00159 callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_INT_INT) (marshal_data ? marshal_data : cc->callback);
00160
00161 v_return = callback (data1,
00162 g_marshal_value_peek_pointer (param_values + 1),
00163 g_marshal_value_peek_pointer (param_values + 2),
00164 g_marshal_value_peek_int (param_values + 3),
00165 g_marshal_value_peek_int (param_values + 4),
00166 data2);
00167
00168 g_value_set_boolean (return_value, v_return);
00169 }
00170
00171
00172 void
00173 gtk_marshal_BOOLEAN__POINTER_INT_INT (GClosure *closure,
00174 GValue *return_value,
00175 guint n_param_values,
00176 const GValue *param_values,
00177 gpointer invocation_hint,
00178 gpointer marshal_data)
00179 {
00180 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT_INT) (gpointer data1,
00181 gpointer arg_1,
00182 gint arg_2,
00183 gint arg_3,
00184 gpointer data2);
00185 register GMarshalFunc_BOOLEAN__POINTER_INT_INT callback;
00186 register GCClosure *cc = (GCClosure*) closure;
00187 register gpointer data1, data2;
00188 gboolean v_return;
00189
00190 g_return_if_fail (return_value != NULL);
00191 g_return_if_fail (n_param_values == 4);
00192
00193 if (G_CCLOSURE_SWAP_DATA (closure))
00194 {
00195 data1 = closure->data;
00196 data2 = g_value_peek_pointer (param_values + 0);
00197 }
00198 else
00199 {
00200 data1 = g_value_peek_pointer (param_values + 0);
00201 data2 = closure->data;
00202 }
00203 callback = (GMarshalFunc_BOOLEAN__POINTER_INT_INT) (marshal_data ? marshal_data : cc->callback);
00204
00205 v_return = callback (data1,
00206 g_marshal_value_peek_pointer (param_values + 1),
00207 g_marshal_value_peek_int (param_values + 2),
00208 g_marshal_value_peek_int (param_values + 3),
00209 data2);
00210
00211 g_value_set_boolean (return_value, v_return);
00212 }
00213
00214
00215 void
00216 gtk_marshal_BOOLEAN__POINTER_INT_INT_UINT (GClosure *closure,
00217 GValue *return_value,
00218 guint n_param_values,
00219 const GValue *param_values,
00220 gpointer invocation_hint,
00221 gpointer marshal_data)
00222 {
00223 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT) (gpointer data1,
00224 gpointer arg_1,
00225 gint arg_2,
00226 gint arg_3,
00227 guint arg_4,
00228 gpointer data2);
00229 register GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT callback;
00230 register GCClosure *cc = (GCClosure*) closure;
00231 register gpointer data1, data2;
00232 gboolean v_return;
00233
00234 g_return_if_fail (return_value != NULL);
00235 g_return_if_fail (n_param_values == 5);
00236
00237 if (G_CCLOSURE_SWAP_DATA (closure))
00238 {
00239 data1 = closure->data;
00240 data2 = g_value_peek_pointer (param_values + 0);
00241 }
00242 else
00243 {
00244 data1 = g_value_peek_pointer (param_values + 0);
00245 data2 = closure->data;
00246 }
00247 callback = (GMarshalFunc_BOOLEAN__POINTER_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
00248
00249 v_return = callback (data1,
00250 g_marshal_value_peek_pointer (param_values + 1),
00251 g_marshal_value_peek_int (param_values + 2),
00252 g_marshal_value_peek_int (param_values + 3),
00253 g_marshal_value_peek_uint (param_values + 4),
00254 data2);
00255
00256 g_value_set_boolean (return_value, v_return);
00257 }
00258
00259
00260 void
00261 gtk_marshal_BOOLEAN__POINTER_STRING_STRING_POINTER (GClosure *closure,
00262 GValue *return_value,
00263 guint n_param_values,
00264 const GValue *param_values,
00265 gpointer invocation_hint,
00266 gpointer marshal_data)
00267 {
00268 typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER) (gpointer data1,
00269 gpointer arg_1,
00270 gpointer arg_2,
00271 gpointer arg_3,
00272 gpointer arg_4,
00273 gpointer data2);
00274 register GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER callback;
00275 register GCClosure *cc = (GCClosure*) closure;
00276 register gpointer data1, data2;
00277 gboolean v_return;
00278
00279 g_return_if_fail (return_value != NULL);
00280 g_return_if_fail (n_param_values == 5);
00281
00282 if (G_CCLOSURE_SWAP_DATA (closure))
00283 {
00284 data1 = closure->data;
00285 data2 = g_value_peek_pointer (param_values + 0);
00286 }
00287 else
00288 {
00289 data1 = g_value_peek_pointer (param_values + 0);
00290 data2 = closure->data;
00291 }
00292 callback = (GMarshalFunc_BOOLEAN__POINTER_STRING_STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
00293
00294 v_return = callback (data1,
00295 g_marshal_value_peek_pointer (param_values + 1),
00296 g_marshal_value_peek_string (param_values + 2),
00297 g_marshal_value_peek_string (param_values + 3),
00298 g_marshal_value_peek_pointer (param_values + 4),
00299 data2);
00300
00301 g_value_set_boolean (return_value, v_return);
00302 }
00303
00304
00305 void
00306 gtk_marshal_ENUM__ENUM (GClosure *closure,
00307 GValue *return_value,
00308 guint n_param_values,
00309 const GValue *param_values,
00310 gpointer invocation_hint,
00311 gpointer marshal_data)
00312 {
00313 typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer data1,
00314 gint arg_1,
00315 gpointer data2);
00316 register GMarshalFunc_ENUM__ENUM callback;
00317 register GCClosure *cc = (GCClosure*) closure;
00318 register gpointer data1, data2;
00319 gint v_return;
00320
00321 g_return_if_fail (return_value != NULL);
00322 g_return_if_fail (n_param_values == 2);
00323
00324 if (G_CCLOSURE_SWAP_DATA (closure))
00325 {
00326 data1 = closure->data;
00327 data2 = g_value_peek_pointer (param_values + 0);
00328 }
00329 else
00330 {
00331 data1 = g_value_peek_pointer (param_values + 0);
00332 data2 = closure->data;
00333 }
00334 callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
00335
00336 v_return = callback (data1,
00337 g_marshal_value_peek_enum (param_values + 1),
00338 data2);
00339
00340 g_value_set_enum (return_value, v_return);
00341 }
00342
00343
00344 void
00345 gtk_marshal_INT__POINTER (GClosure *closure,
00346 GValue *return_value,
00347 guint n_param_values,
00348 const GValue *param_values,
00349 gpointer invocation_hint,
00350 gpointer marshal_data)
00351 {
00352 typedef gint (*GMarshalFunc_INT__POINTER) (gpointer data1,
00353 gpointer arg_1,
00354 gpointer data2);
00355 register GMarshalFunc_INT__POINTER callback;
00356 register GCClosure *cc = (GCClosure*) closure;
00357 register gpointer data1, data2;
00358 gint v_return;
00359
00360 g_return_if_fail (return_value != NULL);
00361 g_return_if_fail (n_param_values == 2);
00362
00363 if (G_CCLOSURE_SWAP_DATA (closure))
00364 {
00365 data1 = closure->data;
00366 data2 = g_value_peek_pointer (param_values + 0);
00367 }
00368 else
00369 {
00370 data1 = g_value_peek_pointer (param_values + 0);
00371 data2 = closure->data;
00372 }
00373 callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
00374
00375 v_return = callback (data1,
00376 g_marshal_value_peek_pointer (param_values + 1),
00377 data2);
00378
00379 g_value_set_int (return_value, v_return);
00380 }
00381
00382
00383 void
00384 gtk_marshal_INT__POINTER_CHAR_CHAR (GClosure *closure,
00385 GValue *return_value,
00386 guint n_param_values,
00387 const GValue *param_values,
00388 gpointer invocation_hint,
00389 gpointer marshal_data)
00390 {
00391 typedef gint (*GMarshalFunc_INT__POINTER_CHAR_CHAR) (gpointer data1,
00392 gpointer arg_1,
00393 gchar arg_2,
00394 gchar arg_3,
00395 gpointer data2);
00396 register GMarshalFunc_INT__POINTER_CHAR_CHAR callback;
00397 register GCClosure *cc = (GCClosure*) closure;
00398 register gpointer data1, data2;
00399 gint v_return;
00400
00401 g_return_if_fail (return_value != NULL);
00402 g_return_if_fail (n_param_values == 4);
00403
00404 if (G_CCLOSURE_SWAP_DATA (closure))
00405 {
00406 data1 = closure->data;
00407 data2 = g_value_peek_pointer (param_values + 0);
00408 }
00409 else
00410 {
00411 data1 = g_value_peek_pointer (param_values + 0);
00412 data2 = closure->data;
00413 }
00414 callback = (GMarshalFunc_INT__POINTER_CHAR_CHAR) (marshal_data ? marshal_data : cc->callback);
00415
00416 v_return = callback (data1,
00417 g_marshal_value_peek_pointer (param_values + 1),
00418 g_marshal_value_peek_char (param_values + 2),
00419 g_marshal_value_peek_char (param_values + 3),
00420 data2);
00421
00422 g_value_set_int (return_value, v_return);
00423 }
00424
00425
00426
00427
00428
00429
00430
00431
00432 void
00433 gtk_marshal_VOID__ENUM_FLOAT (GClosure *closure,
00434 GValue *return_value,
00435 guint n_param_values,
00436 const GValue *param_values,
00437 gpointer invocation_hint,
00438 gpointer marshal_data)
00439 {
00440 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer data1,
00441 gint arg_1,
00442 gfloat arg_2,
00443 gpointer data2);
00444 register GMarshalFunc_VOID__ENUM_FLOAT callback;
00445 register GCClosure *cc = (GCClosure*) closure;
00446 register gpointer data1, data2;
00447
00448 g_return_if_fail (n_param_values == 3);
00449
00450 if (G_CCLOSURE_SWAP_DATA (closure))
00451 {
00452 data1 = closure->data;
00453 data2 = g_value_peek_pointer (param_values + 0);
00454 }
00455 else
00456 {
00457 data1 = g_value_peek_pointer (param_values + 0);
00458 data2 = closure->data;
00459 }
00460 callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
00461
00462 callback (data1,
00463 g_marshal_value_peek_enum (param_values + 1),
00464 g_marshal_value_peek_float (param_values + 2),
00465 data2);
00466 }
00467
00468
00469 void
00470 gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure *closure,
00471 GValue *return_value,
00472 guint n_param_values,
00473 const GValue *param_values,
00474 gpointer invocation_hint,
00475 gpointer marshal_data)
00476 {
00477 typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer data1,
00478 gint arg_1,
00479 gfloat arg_2,
00480 gboolean arg_3,
00481 gpointer data2);
00482 register GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
00483 register GCClosure *cc = (GCClosure*) closure;
00484 register gpointer data1, data2;
00485
00486 g_return_if_fail (n_param_values == 4);
00487
00488 if (G_CCLOSURE_SWAP_DATA (closure))
00489 {
00490 data1 = closure->data;
00491 data2 = g_value_peek_pointer (param_values + 0);
00492 }
00493 else
00494 {
00495 data1 = g_value_peek_pointer (param_values + 0);
00496 data2 = closure->data;
00497 }
00498 callback = (GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
00499
00500 callback (data1,
00501 g_marshal_value_peek_enum (param_values + 1),
00502 g_marshal_value_peek_float (param_values + 2),
00503 g_marshal_value_peek_boolean (param_values + 3),
00504 data2);
00505 }
00506
00507
00508
00509
00510 void
00511 gtk_marshal_VOID__INT_INT (GClosure *closure,
00512 GValue *return_value,
00513 guint n_param_values,
00514 const GValue *param_values,
00515 gpointer invocation_hint,
00516 gpointer marshal_data)
00517 {
00518 typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1,
00519 gint arg_1,
00520 gint arg_2,
00521 gpointer data2);
00522 register GMarshalFunc_VOID__INT_INT callback;
00523 register GCClosure *cc = (GCClosure*) closure;
00524 register gpointer data1, data2;
00525
00526 g_return_if_fail (n_param_values == 3);
00527
00528 if (G_CCLOSURE_SWAP_DATA (closure))
00529 {
00530 data1 = closure->data;
00531 data2 = g_value_peek_pointer (param_values + 0);
00532 }
00533 else
00534 {
00535 data1 = g_value_peek_pointer (param_values + 0);
00536 data2 = closure->data;
00537 }
00538 callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
00539
00540 callback (data1,
00541 g_marshal_value_peek_int (param_values + 1),
00542 g_marshal_value_peek_int (param_values + 2),
00543 data2);
00544 }
00545
00546
00547 void
00548 gtk_marshal_VOID__INT_INT_POINTER (GClosure *closure,
00549 GValue *return_value,
00550 guint n_param_values,
00551 const GValue *param_values,
00552 gpointer invocation_hint,
00553 gpointer marshal_data)
00554 {
00555 typedef void (*GMarshalFunc_VOID__INT_INT_POINTER) (gpointer data1,
00556 gint arg_1,
00557 gint arg_2,
00558 gpointer arg_3,
00559 gpointer data2);
00560 register GMarshalFunc_VOID__INT_INT_POINTER callback;
00561 register GCClosure *cc = (GCClosure*) closure;
00562 register gpointer data1, data2;
00563
00564 g_return_if_fail (n_param_values == 4);
00565
00566 if (G_CCLOSURE_SWAP_DATA (closure))
00567 {
00568 data1 = closure->data;
00569 data2 = g_value_peek_pointer (param_values + 0);
00570 }
00571 else
00572 {
00573 data1 = g_value_peek_pointer (param_values + 0);
00574 data2 = closure->data;
00575 }
00576 callback = (GMarshalFunc_VOID__INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00577
00578 callback (data1,
00579 g_marshal_value_peek_int (param_values + 1),
00580 g_marshal_value_peek_int (param_values + 2),
00581 g_marshal_value_peek_pointer (param_values + 3),
00582 data2);
00583 }
00584
00585
00586
00587
00588
00589
00590
00591
00592 void
00593 gtk_marshal_VOID__POINTER_INT (GClosure *closure,
00594 GValue *return_value,
00595 guint n_param_values,
00596 const GValue *param_values,
00597 gpointer invocation_hint,
00598 gpointer marshal_data)
00599 {
00600 typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer data1,
00601 gpointer arg_1,
00602 gint arg_2,
00603 gpointer data2);
00604 register GMarshalFunc_VOID__POINTER_INT callback;
00605 register GCClosure *cc = (GCClosure*) closure;
00606 register gpointer data1, data2;
00607
00608 g_return_if_fail (n_param_values == 3);
00609
00610 if (G_CCLOSURE_SWAP_DATA (closure))
00611 {
00612 data1 = closure->data;
00613 data2 = g_value_peek_pointer (param_values + 0);
00614 }
00615 else
00616 {
00617 data1 = g_value_peek_pointer (param_values + 0);
00618 data2 = closure->data;
00619 }
00620 callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
00621
00622 callback (data1,
00623 g_marshal_value_peek_pointer (param_values + 1),
00624 g_marshal_value_peek_int (param_values + 2),
00625 data2);
00626 }
00627
00628
00629 void
00630 gtk_marshal_VOID__POINTER_POINTER (GClosure *closure,
00631 GValue *return_value,
00632 guint n_param_values,
00633 const GValue *param_values,
00634 gpointer invocation_hint,
00635 gpointer marshal_data)
00636 {
00637 typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer data1,
00638 gpointer arg_1,
00639 gpointer arg_2,
00640 gpointer data2);
00641 register GMarshalFunc_VOID__POINTER_POINTER callback;
00642 register GCClosure *cc = (GCClosure*) closure;
00643 register gpointer data1, data2;
00644
00645 g_return_if_fail (n_param_values == 3);
00646
00647 if (G_CCLOSURE_SWAP_DATA (closure))
00648 {
00649 data1 = closure->data;
00650 data2 = g_value_peek_pointer (param_values + 0);
00651 }
00652 else
00653 {
00654 data1 = g_value_peek_pointer (param_values + 0);
00655 data2 = closure->data;
00656 }
00657 callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00658
00659 callback (data1,
00660 g_marshal_value_peek_pointer (param_values + 1),
00661 g_marshal_value_peek_pointer (param_values + 2),
00662 data2);
00663 }
00664
00665
00666 void
00667 gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure *closure,
00668 GValue *return_value,
00669 guint n_param_values,
00670 const GValue *param_values,
00671 gpointer invocation_hint,
00672 gpointer marshal_data)
00673 {
00674 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer data1,
00675 gpointer arg_1,
00676 gpointer arg_2,
00677 gpointer arg_3,
00678 gpointer data2);
00679 register GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
00680 register GCClosure *cc = (GCClosure*) closure;
00681 register gpointer data1, data2;
00682
00683 g_return_if_fail (n_param_values == 4);
00684
00685 if (G_CCLOSURE_SWAP_DATA (closure))
00686 {
00687 data1 = closure->data;
00688 data2 = g_value_peek_pointer (param_values + 0);
00689 }
00690 else
00691 {
00692 data1 = g_value_peek_pointer (param_values + 0);
00693 data2 = closure->data;
00694 }
00695 callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00696
00697 callback (data1,
00698 g_marshal_value_peek_pointer (param_values + 1),
00699 g_marshal_value_peek_pointer (param_values + 2),
00700 g_marshal_value_peek_pointer (param_values + 3),
00701 data2);
00702 }
00703
00704
00705 void
00706 gtk_marshal_VOID__POINTER_STRING_STRING (GClosure *closure,
00707 GValue *return_value,
00708 guint n_param_values,
00709 const GValue *param_values,
00710 gpointer invocation_hint,
00711 gpointer marshal_data)
00712 {
00713 typedef void (*GMarshalFunc_VOID__POINTER_STRING_STRING) (gpointer data1,
00714 gpointer arg_1,
00715 gpointer arg_2,
00716 gpointer arg_3,
00717 gpointer data2);
00718 register GMarshalFunc_VOID__POINTER_STRING_STRING callback;
00719 register GCClosure *cc = (GCClosure*) closure;
00720 register gpointer data1, data2;
00721
00722 g_return_if_fail (n_param_values == 4);
00723
00724 if (G_CCLOSURE_SWAP_DATA (closure))
00725 {
00726 data1 = closure->data;
00727 data2 = g_value_peek_pointer (param_values + 0);
00728 }
00729 else
00730 {
00731 data1 = g_value_peek_pointer (param_values + 0);
00732 data2 = closure->data;
00733 }
00734 callback = (GMarshalFunc_VOID__POINTER_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
00735
00736 callback (data1,
00737 g_marshal_value_peek_pointer (param_values + 1),
00738 g_marshal_value_peek_string (param_values + 2),
00739 g_marshal_value_peek_string (param_values + 3),
00740 data2);
00741 }
00742
00743
00744 void
00745 gtk_marshal_VOID__POINTER_UINT (GClosure *closure,
00746 GValue *return_value,
00747 guint n_param_values,
00748 const GValue *param_values,
00749 gpointer invocation_hint,
00750 gpointer marshal_data)
00751 {
00752 typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer data1,
00753 gpointer arg_1,
00754 guint arg_2,
00755 gpointer data2);
00756 register GMarshalFunc_VOID__POINTER_UINT callback;
00757 register GCClosure *cc = (GCClosure*) closure;
00758 register gpointer data1, data2;
00759
00760 g_return_if_fail (n_param_values == 3);
00761
00762 if (G_CCLOSURE_SWAP_DATA (closure))
00763 {
00764 data1 = closure->data;
00765 data2 = g_value_peek_pointer (param_values + 0);
00766 }
00767 else
00768 {
00769 data1 = g_value_peek_pointer (param_values + 0);
00770 data2 = closure->data;
00771 }
00772 callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
00773
00774 callback (data1,
00775 g_marshal_value_peek_pointer (param_values + 1),
00776 g_marshal_value_peek_uint (param_values + 2),
00777 data2);
00778 }
00779
00780
00781 void
00782 gtk_marshal_VOID__POINTER_UINT_ENUM (GClosure *closure,
00783 GValue *return_value,
00784 guint n_param_values,
00785 const GValue *param_values,
00786 gpointer invocation_hint,
00787 gpointer marshal_data)
00788 {
00789 typedef void (*GMarshalFunc_VOID__POINTER_UINT_ENUM) (gpointer data1,
00790 gpointer arg_1,
00791 guint arg_2,
00792 gint arg_3,
00793 gpointer data2);
00794 register GMarshalFunc_VOID__POINTER_UINT_ENUM callback;
00795 register GCClosure *cc = (GCClosure*) closure;
00796 register gpointer data1, data2;
00797
00798 g_return_if_fail (n_param_values == 4);
00799
00800 if (G_CCLOSURE_SWAP_DATA (closure))
00801 {
00802 data1 = closure->data;
00803 data2 = g_value_peek_pointer (param_values + 0);
00804 }
00805 else
00806 {
00807 data1 = g_value_peek_pointer (param_values + 0);
00808 data2 = closure->data;
00809 }
00810 callback = (GMarshalFunc_VOID__POINTER_UINT_ENUM) (marshal_data ? marshal_data : cc->callback);
00811
00812 callback (data1,
00813 g_marshal_value_peek_pointer (param_values + 1),
00814 g_marshal_value_peek_uint (param_values + 2),
00815 g_marshal_value_peek_enum (param_values + 3),
00816 data2);
00817 }
00818
00819
00820 void
00821 gtk_marshal_VOID__POINTER_POINTER_UINT_UINT (GClosure *closure,
00822 GValue *return_value,
00823 guint n_param_values,
00824 const GValue *param_values,
00825 gpointer invocation_hint,
00826 gpointer marshal_data)
00827 {
00828 typedef void (*GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT) (gpointer data1,
00829 gpointer arg_1,
00830 gpointer arg_2,
00831 guint arg_3,
00832 guint arg_4,
00833 gpointer data2);
00834 register GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT callback;
00835 register GCClosure *cc = (GCClosure*) closure;
00836 register gpointer data1, data2;
00837
00838 g_return_if_fail (n_param_values == 5);
00839
00840 if (G_CCLOSURE_SWAP_DATA (closure))
00841 {
00842 data1 = closure->data;
00843 data2 = g_value_peek_pointer (param_values + 0);
00844 }
00845 else
00846 {
00847 data1 = g_value_peek_pointer (param_values + 0);
00848 data2 = closure->data;
00849 }
00850 callback = (GMarshalFunc_VOID__POINTER_POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
00851
00852 callback (data1,
00853 g_marshal_value_peek_pointer (param_values + 1),
00854 g_marshal_value_peek_pointer (param_values + 2),
00855 g_marshal_value_peek_uint (param_values + 3),
00856 g_marshal_value_peek_uint (param_values + 4),
00857 data2);
00858 }
00859
00860
00861 void
00862 gtk_marshal_VOID__POINTER_INT_INT_POINTER_UINT_UINT (GClosure *closure,
00863 GValue *return_value,
00864 guint n_param_values,
00865 const GValue *param_values,
00866 gpointer invocation_hint,
00867 gpointer marshal_data)
00868 {
00869 typedef void (*GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT) (gpointer data1,
00870 gpointer arg_1,
00871 gint arg_2,
00872 gint arg_3,
00873 gpointer arg_4,
00874 guint arg_5,
00875 guint arg_6,
00876 gpointer data2);
00877 register GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT callback;
00878 register GCClosure *cc = (GCClosure*) closure;
00879 register gpointer data1, data2;
00880
00881 g_return_if_fail (n_param_values == 7);
00882
00883 if (G_CCLOSURE_SWAP_DATA (closure))
00884 {
00885 data1 = closure->data;
00886 data2 = g_value_peek_pointer (param_values + 0);
00887 }
00888 else
00889 {
00890 data1 = g_value_peek_pointer (param_values + 0);
00891 data2 = closure->data;
00892 }
00893 callback = (GMarshalFunc_VOID__POINTER_INT_INT_POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
00894
00895 callback (data1,
00896 g_marshal_value_peek_pointer (param_values + 1),
00897 g_marshal_value_peek_int (param_values + 2),
00898 g_marshal_value_peek_int (param_values + 3),
00899 g_marshal_value_peek_pointer (param_values + 4),
00900 g_marshal_value_peek_uint (param_values + 5),
00901 g_marshal_value_peek_uint (param_values + 6),
00902 data2);
00903 }
00904
00905
00906 void
00907 gtk_marshal_VOID__POINTER_UINT_UINT (GClosure *closure,
00908 GValue *return_value,
00909 guint n_param_values,
00910 const GValue *param_values,
00911 gpointer invocation_hint,
00912 gpointer marshal_data)
00913 {
00914 typedef void (*GMarshalFunc_VOID__POINTER_UINT_UINT) (gpointer data1,
00915 gpointer arg_1,
00916 guint arg_2,
00917 guint arg_3,
00918 gpointer data2);
00919 register GMarshalFunc_VOID__POINTER_UINT_UINT callback;
00920 register GCClosure *cc = (GCClosure*) closure;
00921 register gpointer data1, data2;
00922
00923 g_return_if_fail (n_param_values == 4);
00924
00925 if (G_CCLOSURE_SWAP_DATA (closure))
00926 {
00927 data1 = closure->data;
00928 data2 = g_value_peek_pointer (param_values + 0);
00929 }
00930 else
00931 {
00932 data1 = g_value_peek_pointer (param_values + 0);
00933 data2 = closure->data;
00934 }
00935 callback = (GMarshalFunc_VOID__POINTER_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
00936
00937 callback (data1,
00938 g_marshal_value_peek_pointer (param_values + 1),
00939 g_marshal_value_peek_uint (param_values + 2),
00940 g_marshal_value_peek_uint (param_values + 3),
00941 data2);
00942 }
00943
00944
00945
00946
00947
00948
00949 void
00950 gtk_marshal_VOID__STRING_INT_POINTER (GClosure *closure,
00951 GValue *return_value,
00952 guint n_param_values,
00953 const GValue *param_values,
00954 gpointer invocation_hint,
00955 gpointer marshal_data)
00956 {
00957 typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer data1,
00958 gpointer arg_1,
00959 gint arg_2,
00960 gpointer arg_3,
00961 gpointer data2);
00962 register GMarshalFunc_VOID__STRING_INT_POINTER callback;
00963 register GCClosure *cc = (GCClosure*) closure;
00964 register gpointer data1, data2;
00965
00966 g_return_if_fail (n_param_values == 4);
00967
00968 if (G_CCLOSURE_SWAP_DATA (closure))
00969 {
00970 data1 = closure->data;
00971 data2 = g_value_peek_pointer (param_values + 0);
00972 }
00973 else
00974 {
00975 data1 = g_value_peek_pointer (param_values + 0);
00976 data2 = closure->data;
00977 }
00978 callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00979
00980 callback (data1,
00981 g_marshal_value_peek_string (param_values + 1),
00982 g_marshal_value_peek_int (param_values + 2),
00983 g_marshal_value_peek_pointer (param_values + 3),
00984 data2);
00985 }
00986
00987
00988
00989
00990 void
00991 gtk_marshal_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER (GClosure *closure,
00992 GValue *return_value,
00993 guint n_param_values,
00994 const GValue *param_values,
00995 gpointer invocation_hint,
00996 gpointer marshal_data)
00997 {
00998 typedef void (*GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER) (gpointer data1,
00999 guint arg_1,
01000 gpointer arg_2,
01001 guint arg_3,
01002 gint arg_4,
01003 gint arg_5,
01004 gpointer arg_6,
01005 gpointer data2);
01006 register GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER callback;
01007 register GCClosure *cc = (GCClosure*) closure;
01008 register gpointer data1, data2;
01009
01010 g_return_if_fail (n_param_values == 7);
01011
01012 if (G_CCLOSURE_SWAP_DATA (closure))
01013 {
01014 data1 = closure->data;
01015 data2 = g_value_peek_pointer (param_values + 0);
01016 }
01017 else
01018 {
01019 data1 = g_value_peek_pointer (param_values + 0);
01020 data2 = closure->data;
01021 }
01022 callback = (GMarshalFunc_VOID__UINT_POINTER_UINT_ENUM_ENUM_POINTER) (marshal_data ? marshal_data : cc->callback);
01023
01024 callback (data1,
01025 g_marshal_value_peek_uint (param_values + 1),
01026 g_marshal_value_peek_pointer (param_values + 2),
01027 g_marshal_value_peek_uint (param_values + 3),
01028 g_marshal_value_peek_enum (param_values + 4),
01029 g_marshal_value_peek_enum (param_values + 5),
01030 g_marshal_value_peek_pointer (param_values + 6),
01031 data2);
01032 }
01033
01034
01035 void
01036 gtk_marshal_VOID__UINT_POINTER_UINT_UINT_ENUM (GClosure *closure,
01037 GValue *return_value,
01038 guint n_param_values,
01039 const GValue *param_values,
01040 gpointer invocation_hint,
01041 gpointer marshal_data)
01042 {
01043 typedef void (*GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM) (gpointer data1,
01044 guint arg_1,
01045 gpointer arg_2,
01046 guint arg_3,
01047 guint arg_4,
01048 gint arg_5,
01049 gpointer data2);
01050 register GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM callback;
01051 register GCClosure *cc = (GCClosure*) closure;
01052 register gpointer data1, data2;
01053
01054 g_return_if_fail (n_param_values == 6);
01055
01056 if (G_CCLOSURE_SWAP_DATA (closure))
01057 {
01058 data1 = closure->data;
01059 data2 = g_value_peek_pointer (param_values + 0);
01060 }
01061 else
01062 {
01063 data1 = g_value_peek_pointer (param_values + 0);
01064 data2 = closure->data;
01065 }
01066 callback = (GMarshalFunc_VOID__UINT_POINTER_UINT_UINT_ENUM) (marshal_data ? marshal_data : cc->callback);
01067
01068 callback (data1,
01069 g_marshal_value_peek_uint (param_values + 1),
01070 g_marshal_value_peek_pointer (param_values + 2),
01071 g_marshal_value_peek_uint (param_values + 3),
01072 g_marshal_value_peek_uint (param_values + 4),
01073 g_marshal_value_peek_enum (param_values + 5),
01074 data2);
01075 }
01076
01077
01078 void
01079 gtk_marshal_VOID__UINT_STRING (GClosure *closure,
01080 GValue *return_value,
01081 guint n_param_values,
01082 const GValue *param_values,
01083 gpointer invocation_hint,
01084 gpointer marshal_data)
01085 {
01086 typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer data1,
01087 guint arg_1,
01088 gpointer arg_2,
01089 gpointer data2);
01090 register GMarshalFunc_VOID__UINT_STRING callback;
01091 register GCClosure *cc = (GCClosure*) closure;
01092 register gpointer data1, data2;
01093
01094 g_return_if_fail (n_param_values == 3);
01095
01096 if (G_CCLOSURE_SWAP_DATA (closure))
01097 {
01098 data1 = closure->data;
01099 data2 = g_value_peek_pointer (param_values + 0);
01100 }
01101 else
01102 {
01103 data1 = g_value_peek_pointer (param_values + 0);
01104 data2 = closure->data;
01105 }
01106 callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
01107
01108 callback (data1,
01109 g_marshal_value_peek_uint (param_values + 1),
01110 g_marshal_value_peek_string (param_values + 2),
01111 data2);
01112 }
01113