The data contained in this repository can be downloaded to your computer using one of several clients.
Please see the documentation of your version control software client for more information.
Please select the desired protocol below to get the URL.
This URL has Read-Only access.
main_repo / finch / libgnt / gntmarshal.c @ a274da4f
History | View | Annotate | Download (19.8 KB)
| 1 |
#include "gntmarshal.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_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 |
|
| 53 |
/* BOOLEAN:VOID (./genmarshal:1) */
|
| 54 |
void
|
| 55 |
gnt_closure_marshal_BOOLEAN__VOID (GClosure *closure, |
| 56 |
GValue *return_value G_GNUC_UNUSED, |
| 57 |
guint n_param_values, |
| 58 |
const GValue *param_values,
|
| 59 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 60 |
gpointer marshal_data) |
| 61 |
{
|
| 62 |
typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer data1,
|
| 63 |
gpointer data2); |
| 64 |
register GMarshalFunc_BOOLEAN__VOID callback;
|
| 65 |
register GCClosure *cc = (GCClosure*) closure;
|
| 66 |
register gpointer data1, data2;
|
| 67 |
gboolean v_return; |
| 68 |
|
| 69 |
g_return_if_fail (return_value != NULL);
|
| 70 |
g_return_if_fail (n_param_values == 1);
|
| 71 |
|
| 72 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 73 |
{
|
| 74 |
data1 = closure->data; |
| 75 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 76 |
} |
| 77 |
else
|
| 78 |
{
|
| 79 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 80 |
data2 = closure->data; |
| 81 |
} |
| 82 |
callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback); |
| 83 |
|
| 84 |
v_return = callback (data1, |
| 85 |
data2); |
| 86 |
|
| 87 |
g_value_set_boolean (return_value, v_return); |
| 88 |
} |
| 89 |
|
| 90 |
/* BOOLEAN:STRING (./genmarshal:2) */
|
| 91 |
void
|
| 92 |
gnt_closure_marshal_BOOLEAN__STRING (GClosure *closure, |
| 93 |
GValue *return_value G_GNUC_UNUSED, |
| 94 |
guint n_param_values, |
| 95 |
const GValue *param_values,
|
| 96 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 97 |
gpointer marshal_data) |
| 98 |
{
|
| 99 |
typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer data1,
|
| 100 |
gpointer arg_1, |
| 101 |
gpointer data2); |
| 102 |
register GMarshalFunc_BOOLEAN__STRING callback;
|
| 103 |
register GCClosure *cc = (GCClosure*) closure;
|
| 104 |
register gpointer data1, data2;
|
| 105 |
gboolean v_return; |
| 106 |
|
| 107 |
g_return_if_fail (return_value != NULL);
|
| 108 |
g_return_if_fail (n_param_values == 2);
|
| 109 |
|
| 110 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 111 |
{
|
| 112 |
data1 = closure->data; |
| 113 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 114 |
} |
| 115 |
else
|
| 116 |
{
|
| 117 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 118 |
data2 = closure->data; |
| 119 |
} |
| 120 |
callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback); |
| 121 |
|
| 122 |
v_return = callback (data1, |
| 123 |
g_marshal_value_peek_string (param_values + 1),
|
| 124 |
data2); |
| 125 |
|
| 126 |
g_value_set_boolean (return_value, v_return); |
| 127 |
} |
| 128 |
|
| 129 |
/* VOID:INT,INT,INT,INT (./genmarshal:3) */
|
| 130 |
void
|
| 131 |
gnt_closure_marshal_VOID__INT_INT_INT_INT (GClosure *closure, |
| 132 |
GValue *return_value G_GNUC_UNUSED, |
| 133 |
guint n_param_values, |
| 134 |
const GValue *param_values,
|
| 135 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 136 |
gpointer marshal_data) |
| 137 |
{
|
| 138 |
typedef void (*GMarshalFunc_VOID__INT_INT_INT_INT) (gpointer data1, |
| 139 |
gint arg_1, |
| 140 |
gint arg_2, |
| 141 |
gint arg_3, |
| 142 |
gint arg_4, |
| 143 |
gpointer data2); |
| 144 |
register GMarshalFunc_VOID__INT_INT_INT_INT callback;
|
| 145 |
register GCClosure *cc = (GCClosure*) closure;
|
| 146 |
register gpointer data1, data2;
|
| 147 |
|
| 148 |
g_return_if_fail (n_param_values == 5);
|
| 149 |
|
| 150 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 151 |
{
|
| 152 |
data1 = closure->data; |
| 153 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 154 |
} |
| 155 |
else
|
| 156 |
{
|
| 157 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 158 |
data2 = closure->data; |
| 159 |
} |
| 160 |
callback = (GMarshalFunc_VOID__INT_INT_INT_INT) (marshal_data ? marshal_data : cc->callback); |
| 161 |
|
| 162 |
callback (data1, |
| 163 |
g_marshal_value_peek_int (param_values + 1),
|
| 164 |
g_marshal_value_peek_int (param_values + 2),
|
| 165 |
g_marshal_value_peek_int (param_values + 3),
|
| 166 |
g_marshal_value_peek_int (param_values + 4),
|
| 167 |
data2); |
| 168 |
} |
| 169 |
|
| 170 |
/* VOID:INT,INT (./genmarshal:4) */
|
| 171 |
void
|
| 172 |
gnt_closure_marshal_VOID__INT_INT (GClosure *closure, |
| 173 |
GValue *return_value G_GNUC_UNUSED, |
| 174 |
guint n_param_values, |
| 175 |
const GValue *param_values,
|
| 176 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 177 |
gpointer marshal_data) |
| 178 |
{
|
| 179 |
typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer data1, |
| 180 |
gint arg_1, |
| 181 |
gint arg_2, |
| 182 |
gpointer data2); |
| 183 |
register GMarshalFunc_VOID__INT_INT callback;
|
| 184 |
register GCClosure *cc = (GCClosure*) closure;
|
| 185 |
register gpointer data1, data2;
|
| 186 |
|
| 187 |
g_return_if_fail (n_param_values == 3);
|
| 188 |
|
| 189 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 190 |
{
|
| 191 |
data1 = closure->data; |
| 192 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 193 |
} |
| 194 |
else
|
| 195 |
{
|
| 196 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 197 |
data2 = closure->data; |
| 198 |
} |
| 199 |
callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback); |
| 200 |
|
| 201 |
callback (data1, |
| 202 |
g_marshal_value_peek_int (param_values + 1),
|
| 203 |
g_marshal_value_peek_int (param_values + 2),
|
| 204 |
data2); |
| 205 |
} |
| 206 |
|
| 207 |
/* VOID:POINTER,POINTER (./genmarshal:5) */
|
| 208 |
void
|
| 209 |
gnt_closure_marshal_VOID__POINTER_POINTER (GClosure *closure, |
| 210 |
GValue *return_value G_GNUC_UNUSED, |
| 211 |
guint n_param_values, |
| 212 |
const GValue *param_values,
|
| 213 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 214 |
gpointer marshal_data) |
| 215 |
{
|
| 216 |
typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer data1, |
| 217 |
gpointer arg_1, |
| 218 |
gpointer arg_2, |
| 219 |
gpointer data2); |
| 220 |
register GMarshalFunc_VOID__POINTER_POINTER callback;
|
| 221 |
register GCClosure *cc = (GCClosure*) closure;
|
| 222 |
register gpointer data1, data2;
|
| 223 |
|
| 224 |
g_return_if_fail (n_param_values == 3);
|
| 225 |
|
| 226 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 227 |
{
|
| 228 |
data1 = closure->data; |
| 229 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 230 |
} |
| 231 |
else
|
| 232 |
{
|
| 233 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 234 |
data2 = closure->data; |
| 235 |
} |
| 236 |
callback = (GMarshalFunc_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback); |
| 237 |
|
| 238 |
callback (data1, |
| 239 |
g_marshal_value_peek_pointer (param_values + 1),
|
| 240 |
g_marshal_value_peek_pointer (param_values + 2),
|
| 241 |
data2); |
| 242 |
} |
| 243 |
|
| 244 |
/* BOOLEAN:INT,INT (./genmarshal:6) */
|
| 245 |
void
|
| 246 |
gnt_closure_marshal_BOOLEAN__INT_INT (GClosure *closure, |
| 247 |
GValue *return_value G_GNUC_UNUSED, |
| 248 |
guint n_param_values, |
| 249 |
const GValue *param_values,
|
| 250 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 251 |
gpointer marshal_data) |
| 252 |
{
|
| 253 |
typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer data1,
|
| 254 |
gint arg_1, |
| 255 |
gint arg_2, |
| 256 |
gpointer data2); |
| 257 |
register GMarshalFunc_BOOLEAN__INT_INT callback;
|
| 258 |
register GCClosure *cc = (GCClosure*) closure;
|
| 259 |
register gpointer data1, data2;
|
| 260 |
gboolean v_return; |
| 261 |
|
| 262 |
g_return_if_fail (return_value != NULL);
|
| 263 |
g_return_if_fail (n_param_values == 3);
|
| 264 |
|
| 265 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 266 |
{
|
| 267 |
data1 = closure->data; |
| 268 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 269 |
} |
| 270 |
else
|
| 271 |
{
|
| 272 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 273 |
data2 = closure->data; |
| 274 |
} |
| 275 |
callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback); |
| 276 |
|
| 277 |
v_return = callback (data1, |
| 278 |
g_marshal_value_peek_int (param_values + 1),
|
| 279 |
g_marshal_value_peek_int (param_values + 2),
|
| 280 |
data2); |
| 281 |
|
| 282 |
g_value_set_boolean (return_value, v_return); |
| 283 |
} |
| 284 |
|
| 285 |
/* BOOLEAN:INT,INT,INT (./genmarshal:7) */
|
| 286 |
void
|
| 287 |
gnt_closure_marshal_BOOLEAN__INT_INT_INT (GClosure *closure, |
| 288 |
GValue *return_value G_GNUC_UNUSED, |
| 289 |
guint n_param_values, |
| 290 |
const GValue *param_values,
|
| 291 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 292 |
gpointer marshal_data) |
| 293 |
{
|
| 294 |
typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT) (gpointer data1,
|
| 295 |
gint arg_1, |
| 296 |
gint arg_2, |
| 297 |
gint arg_3, |
| 298 |
gpointer data2); |
| 299 |
register GMarshalFunc_BOOLEAN__INT_INT_INT callback;
|
| 300 |
register GCClosure *cc = (GCClosure*) closure;
|
| 301 |
register gpointer data1, data2;
|
| 302 |
gboolean v_return; |
| 303 |
|
| 304 |
g_return_if_fail (return_value != NULL);
|
| 305 |
g_return_if_fail (n_param_values == 4);
|
| 306 |
|
| 307 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 308 |
{
|
| 309 |
data1 = closure->data; |
| 310 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 311 |
} |
| 312 |
else
|
| 313 |
{
|
| 314 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 315 |
data2 = closure->data; |
| 316 |
} |
| 317 |
callback = (GMarshalFunc_BOOLEAN__INT_INT_INT) (marshal_data ? marshal_data : cc->callback); |
| 318 |
|
| 319 |
v_return = callback (data1, |
| 320 |
g_marshal_value_peek_int (param_values + 1),
|
| 321 |
g_marshal_value_peek_int (param_values + 2),
|
| 322 |
g_marshal_value_peek_int (param_values + 3),
|
| 323 |
data2); |
| 324 |
|
| 325 |
g_value_set_boolean (return_value, v_return); |
| 326 |
} |
| 327 |
|
| 328 |
/* BOOLEAN:POINTER,POINTER,POINTER (./genmarshal:8) */
|
| 329 |
void
|
| 330 |
gnt_closure_marshal_BOOLEAN__POINTER_POINTER_POINTER (GClosure *closure, |
| 331 |
GValue *return_value G_GNUC_UNUSED, |
| 332 |
guint n_param_values, |
| 333 |
const GValue *param_values,
|
| 334 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 335 |
gpointer marshal_data) |
| 336 |
{
|
| 337 |
typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (gpointer data1,
|
| 338 |
gpointer arg_1, |
| 339 |
gpointer arg_2, |
| 340 |
gpointer arg_3, |
| 341 |
gpointer data2); |
| 342 |
register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER callback;
|
| 343 |
register GCClosure *cc = (GCClosure*) closure;
|
| 344 |
register gpointer data1, data2;
|
| 345 |
gboolean v_return; |
| 346 |
|
| 347 |
g_return_if_fail (return_value != NULL);
|
| 348 |
g_return_if_fail (n_param_values == 4);
|
| 349 |
|
| 350 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 351 |
{
|
| 352 |
data1 = closure->data; |
| 353 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 354 |
} |
| 355 |
else
|
| 356 |
{
|
| 357 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 358 |
data2 = closure->data; |
| 359 |
} |
| 360 |
callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback); |
| 361 |
|
| 362 |
v_return = callback (data1, |
| 363 |
g_marshal_value_peek_pointer (param_values + 1),
|
| 364 |
g_marshal_value_peek_pointer (param_values + 2),
|
| 365 |
g_marshal_value_peek_pointer (param_values + 3),
|
| 366 |
data2); |
| 367 |
|
| 368 |
g_value_set_boolean (return_value, v_return); |
| 369 |
} |
| 370 |
|
| 371 |
/* BOOLEAN:INT,INT,INT,POINTER (./genmarshal:9) */
|
| 372 |
void
|
| 373 |
gnt_closure_marshal_BOOLEAN__INT_INT_INT_POINTER (GClosure *closure, |
| 374 |
GValue *return_value G_GNUC_UNUSED, |
| 375 |
guint n_param_values, |
| 376 |
const GValue *param_values,
|
| 377 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 378 |
gpointer marshal_data) |
| 379 |
{
|
| 380 |
typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT_POINTER) (gpointer data1,
|
| 381 |
gint arg_1, |
| 382 |
gint arg_2, |
| 383 |
gint arg_3, |
| 384 |
gpointer arg_4, |
| 385 |
gpointer data2); |
| 386 |
register GMarshalFunc_BOOLEAN__INT_INT_INT_POINTER callback;
|
| 387 |
register GCClosure *cc = (GCClosure*) closure;
|
| 388 |
register gpointer data1, data2;
|
| 389 |
gboolean v_return; |
| 390 |
|
| 391 |
g_return_if_fail (return_value != NULL);
|
| 392 |
g_return_if_fail (n_param_values == 5);
|
| 393 |
|
| 394 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 395 |
{
|
| 396 |
data1 = closure->data; |
| 397 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 398 |
} |
| 399 |
else
|
| 400 |
{
|
| 401 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 402 |
data2 = closure->data; |
| 403 |
} |
| 404 |
callback = (GMarshalFunc_BOOLEAN__INT_INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback); |
| 405 |
|
| 406 |
v_return = callback (data1, |
| 407 |
g_marshal_value_peek_int (param_values + 1),
|
| 408 |
g_marshal_value_peek_int (param_values + 2),
|
| 409 |
g_marshal_value_peek_int (param_values + 3),
|
| 410 |
g_marshal_value_peek_pointer (param_values + 4),
|
| 411 |
data2); |
| 412 |
|
| 413 |
g_value_set_boolean (return_value, v_return); |
| 414 |
} |
| 415 |
|
| 416 |
/* VOID:STRING,STRING (./genmarshal:10) */
|
| 417 |
void
|
| 418 |
gnt_closure_marshal_VOID__STRING_STRING (GClosure *closure, |
| 419 |
GValue *return_value G_GNUC_UNUSED, |
| 420 |
guint n_param_values, |
| 421 |
const GValue *param_values,
|
| 422 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 423 |
gpointer marshal_data) |
| 424 |
{
|
| 425 |
typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1, |
| 426 |
gpointer arg_1, |
| 427 |
gpointer arg_2, |
| 428 |
gpointer data2); |
| 429 |
register GMarshalFunc_VOID__STRING_STRING callback;
|
| 430 |
register GCClosure *cc = (GCClosure*) closure;
|
| 431 |
register gpointer data1, data2;
|
| 432 |
|
| 433 |
g_return_if_fail (n_param_values == 3);
|
| 434 |
|
| 435 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 436 |
{
|
| 437 |
data1 = closure->data; |
| 438 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 439 |
} |
| 440 |
else
|
| 441 |
{
|
| 442 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 443 |
data2 = closure->data; |
| 444 |
} |
| 445 |
callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback); |
| 446 |
|
| 447 |
callback (data1, |
| 448 |
g_marshal_value_peek_string (param_values + 1),
|
| 449 |
g_marshal_value_peek_string (param_values + 2),
|
| 450 |
data2); |
| 451 |
} |
| 452 |
|
| 453 |
/* VOID:POINTER,BOOLEAN (./genmarshal:11) */
|
| 454 |
void
|
| 455 |
gnt_closure_marshal_VOID__POINTER_BOOLEAN (GClosure *closure, |
| 456 |
GValue *return_value G_GNUC_UNUSED, |
| 457 |
guint n_param_values, |
| 458 |
const GValue *param_values,
|
| 459 |
gpointer invocation_hint G_GNUC_UNUSED, |
| 460 |
gpointer marshal_data) |
| 461 |
{
|
| 462 |
typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer data1, |
| 463 |
gpointer arg_1, |
| 464 |
gboolean arg_2, |
| 465 |
gpointer data2); |
| 466 |
register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
|
| 467 |
register GCClosure *cc = (GCClosure*) closure;
|
| 468 |
register gpointer data1, data2;
|
| 469 |
|
| 470 |
g_return_if_fail (n_param_values == 3);
|
| 471 |
|
| 472 |
if (G_CCLOSURE_SWAP_DATA (closure))
|
| 473 |
{
|
| 474 |
data1 = closure->data; |
| 475 |
data2 = g_value_peek_pointer (param_values + 0);
|
| 476 |
} |
| 477 |
else
|
| 478 |
{
|
| 479 |
data1 = g_value_peek_pointer (param_values + 0);
|
| 480 |
data2 = closure->data; |
| 481 |
} |
| 482 |
callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback); |
| 483 |
|
| 484 |
callback (data1, |
| 485 |
g_marshal_value_peek_pointer (param_values + 1),
|
| 486 |
g_marshal_value_peek_boolean (param_values + 2),
|
| 487 |
data2); |
| 488 |
} |
| 489 |
|