1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gobject.CClosure; 26 27 private import glib.ConstructionException; 28 private import gobject.Closure; 29 private import gobject.ObjectG; 30 private import gobject.TypeInstance; 31 private import gobject.Value; 32 private import gtkc.gobject; 33 public import gtkc.gobjecttypes; 34 35 36 /** 37 * A #GCClosure is a specialization of #GClosure for C function callbacks. 38 */ 39 public class CClosure 40 { 41 /** the main Gtk struct */ 42 protected GCClosure* gCClosure; 43 protected bool ownedRef; 44 45 /** Get the main Gtk struct */ 46 public GCClosure* getCClosureStruct() 47 { 48 return gCClosure; 49 } 50 51 /** the main Gtk struct as a void* */ 52 protected void* getStruct() 53 { 54 return cast(void*)gCClosure; 55 } 56 57 /** 58 * Sets our main struct and passes it to the parent class. 59 */ 60 public this (GCClosure* gCClosure, bool ownedRef = false) 61 { 62 this.gCClosure = gCClosure; 63 this.ownedRef = ownedRef; 64 } 65 66 /** 67 * Creates a new closure which invokes callbackFunc with userData as 68 * the last parameter. 69 * 70 * Params: 71 * callbackFunc = the function to invoke 72 * userData = user data to pass to callbackFunc 73 * destroyData = destroy notify to be called when userData is no longer used 74 * swap = if true invoce with usrData as the first parameter 75 * 76 * Throws: ConstructionException GTK+ fails to create the object. 77 */ 78 public this(GCallback callbackFunc, void* userData, GClosureNotify destroyData, bool swap) 79 { 80 GClosure* p; 81 82 if ( swap ) 83 p = g_cclosure_new_swap(callbackFunc, userData, destroyData); 84 else 85 p = g_cclosure_new(callbackFunc, userData, destroyData); 86 87 if(p is null) 88 { 89 throw new ConstructionException("null returned by new"); 90 } 91 92 this(cast(GCClosure*) p); 93 } 94 95 /** 96 * A variant of this() which uses object as userData and 97 * calls ObjectG.watchClosure() on object and the created 98 * closure. This function is useful when you have a callback closely 99 * associated with a gobject.ObjectG, and want the callback to no longer run 100 * after the object is is freed. 101 * 102 * Params: 103 * callbackFunc = the function to invoke 104 * object = a gobject.ObjectG.ObjectG to pass to callbackFunc 105 * swap = if true invoce with usrData as the first parameter 106 * 107 * Throws: ConstructionException GTK+ fails to create the object. 108 */ 109 public this(GCallback callbackFunc, ObjectG object, bool swap) 110 { 111 GClosure* p; 112 113 if ( swap ) 114 p = g_cclosure_new_object_swap(callbackFunc, (object is null) ? null : object.getObjectGStruct()); 115 else 116 p = g_cclosure_new_object(callbackFunc, (object is null) ? null : object.getObjectGStruct()); 117 118 if(p is null) 119 { 120 throw new ConstructionException("null returned by new_object"); 121 } 122 123 this(cast(GCClosure*) p); 124 } 125 126 /** 127 */ 128 129 /** 130 * A #GClosureMarshal function for use with signals with handlers that 131 * take two boxed pointers as arguments and return a boolean. If you 132 * have such a signal, you will probably also need to use an 133 * accumulator, such as g_signal_accumulator_true_handled(). 134 * 135 * Params: 136 * closure = A #GClosure. 137 * returnValue = A #GValue to store the return value. May be %NULL 138 * if the callback of closure doesn't return a value. 139 * nParamValues = The length of the @param_values array. 140 * paramValues = An array of #GValues holding the arguments 141 * on which to invoke the callback of closure. 142 * invocationHint = The invocation hint given as the last argument to 143 * g_closure_invoke(). 144 * marshalData = Additional data specified when registering the 145 * marshaller, see g_closure_set_marshal() and 146 * g_closure_set_meta_marshal() 147 */ 148 public static void marshalBOOLEANBOXEDBOXED(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 149 { 150 g_cclosure_marshal_BOOLEAN__BOXED_BOXED((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 151 } 152 153 /** 154 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED(). 155 * 156 * Params: 157 * closure = the #GClosure to which the marshaller belongs 158 * returnValue = a #GValue to store the return 159 * value. May be %NULL if the callback of @closure doesn't return a 160 * value. 161 * instanc = the instance on which the closure is invoked. 162 * args = va_list of arguments to be passed to the closure. 163 * marshalData = additional data specified when 164 * registering the marshaller, see g_closure_set_marshal() and 165 * g_closure_set_meta_marshal() 166 * nParams = the length of the @param_types array 167 * paramTypes = the #GType of each argument from 168 * @args. 169 */ 170 public static void marshalBOOLEANBOXEDBOXEDv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 171 { 172 g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 173 } 174 175 /** 176 * A marshaller for a #GCClosure with a callback of type 177 * `gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter 178 * denotes a flags type. 179 * 180 * Params: 181 * closure = the #GClosure to which the marshaller belongs 182 * returnValue = a #GValue which can store the returned #gboolean 183 * nParamValues = 2 184 * paramValues = a #GValue array holding instance and arg1 185 * invocationHint = the invocation hint given as the last argument 186 * to g_closure_invoke() 187 * marshalData = additional data specified when registering the marshaller 188 */ 189 public static void marshalBOOLEANFLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 190 { 191 g_cclosure_marshal_BOOLEAN__FLAGS((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 192 } 193 194 /** 195 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS(). 196 * 197 * Params: 198 * closure = the #GClosure to which the marshaller belongs 199 * returnValue = a #GValue to store the return 200 * value. May be %NULL if the callback of @closure doesn't return a 201 * value. 202 * instanc = the instance on which the closure is invoked. 203 * args = va_list of arguments to be passed to the closure. 204 * marshalData = additional data specified when 205 * registering the marshaller, see g_closure_set_marshal() and 206 * g_closure_set_meta_marshal() 207 * nParams = the length of the @param_types array 208 * paramTypes = the #GType of each argument from 209 * @args. 210 */ 211 public static void marshalBOOLEANFLAGSv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 212 { 213 g_cclosure_marshal_BOOLEAN__FLAGSv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 214 } 215 216 /** 217 * A marshaller for a #GCClosure with a callback of type 218 * `gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)`. 219 * 220 * Params: 221 * closure = the #GClosure to which the marshaller belongs 222 * returnValue = a #GValue, which can store the returned string 223 * nParamValues = 3 224 * paramValues = a #GValue array holding instance, arg1 and arg2 225 * invocationHint = the invocation hint given as the last argument 226 * to g_closure_invoke() 227 * marshalData = additional data specified when registering the marshaller 228 */ 229 public static void marshalSTRINGOBJECTPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 230 { 231 g_cclosure_marshal_STRING__OBJECT_POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 232 } 233 234 /** 235 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER(). 236 * 237 * Params: 238 * closure = the #GClosure to which the marshaller belongs 239 * returnValue = a #GValue to store the return 240 * value. May be %NULL if the callback of @closure doesn't return a 241 * value. 242 * instanc = the instance on which the closure is invoked. 243 * args = va_list of arguments to be passed to the closure. 244 * marshalData = additional data specified when 245 * registering the marshaller, see g_closure_set_marshal() and 246 * g_closure_set_meta_marshal() 247 * nParams = the length of the @param_types array 248 * paramTypes = the #GType of each argument from 249 * @args. 250 */ 251 public static void marshalSTRINGOBJECTPOINTERv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 252 { 253 g_cclosure_marshal_STRING__OBJECT_POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 254 } 255 256 /** 257 * A marshaller for a #GCClosure with a callback of type 258 * `void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)`. 259 * 260 * Params: 261 * closure = the #GClosure to which the marshaller belongs 262 * returnValue = ignored 263 * nParamValues = 2 264 * paramValues = a #GValue array holding the instance and the #gboolean parameter 265 * invocationHint = the invocation hint given as the last argument 266 * to g_closure_invoke() 267 * marshalData = additional data specified when registering the marshaller 268 */ 269 public static void marshalVOIDBOOLEAN(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 270 { 271 g_cclosure_marshal_VOID__BOOLEAN((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 272 } 273 274 /** 275 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN(). 276 * 277 * Params: 278 * closure = the #GClosure to which the marshaller belongs 279 * returnValue = a #GValue to store the return 280 * value. May be %NULL if the callback of @closure doesn't return a 281 * value. 282 * instanc = the instance on which the closure is invoked. 283 * args = va_list of arguments to be passed to the closure. 284 * marshalData = additional data specified when 285 * registering the marshaller, see g_closure_set_marshal() and 286 * g_closure_set_meta_marshal() 287 * nParams = the length of the @param_types array 288 * paramTypes = the #GType of each argument from 289 * @args. 290 */ 291 public static void marshalVOIDBOOLEANv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 292 { 293 g_cclosure_marshal_VOID__BOOLEANv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 294 } 295 296 /** 297 * A marshaller for a #GCClosure with a callback of type 298 * `void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)`. 299 * 300 * Params: 301 * closure = the #GClosure to which the marshaller belongs 302 * returnValue = ignored 303 * nParamValues = 2 304 * paramValues = a #GValue array holding the instance and the #GBoxed* parameter 305 * invocationHint = the invocation hint given as the last argument 306 * to g_closure_invoke() 307 * marshalData = additional data specified when registering the marshaller 308 */ 309 public static void marshalVOIDBOXED(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 310 { 311 g_cclosure_marshal_VOID__BOXED((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 312 } 313 314 /** 315 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED(). 316 * 317 * Params: 318 * closure = the #GClosure to which the marshaller belongs 319 * returnValue = a #GValue to store the return 320 * value. May be %NULL if the callback of @closure doesn't return a 321 * value. 322 * instanc = the instance on which the closure is invoked. 323 * args = va_list of arguments to be passed to the closure. 324 * marshalData = additional data specified when 325 * registering the marshaller, see g_closure_set_marshal() and 326 * g_closure_set_meta_marshal() 327 * nParams = the length of the @param_types array 328 * paramTypes = the #GType of each argument from 329 * @args. 330 */ 331 public static void marshalVOIDBOXEDv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 332 { 333 g_cclosure_marshal_VOID__BOXEDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 334 } 335 336 /** 337 * A marshaller for a #GCClosure with a callback of type 338 * `void (*callback) (gpointer instance, gchar arg1, gpointer user_data)`. 339 * 340 * Params: 341 * closure = the #GClosure to which the marshaller belongs 342 * returnValue = ignored 343 * nParamValues = 2 344 * paramValues = a #GValue array holding the instance and the #gchar parameter 345 * invocationHint = the invocation hint given as the last argument 346 * to g_closure_invoke() 347 * marshalData = additional data specified when registering the marshaller 348 */ 349 public static void marshalVOIDCHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 350 { 351 g_cclosure_marshal_VOID__CHAR((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 352 } 353 354 /** 355 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR(). 356 * 357 * Params: 358 * closure = the #GClosure to which the marshaller belongs 359 * returnValue = a #GValue to store the return 360 * value. May be %NULL if the callback of @closure doesn't return a 361 * value. 362 * instanc = the instance on which the closure is invoked. 363 * args = va_list of arguments to be passed to the closure. 364 * marshalData = additional data specified when 365 * registering the marshaller, see g_closure_set_marshal() and 366 * g_closure_set_meta_marshal() 367 * nParams = the length of the @param_types array 368 * paramTypes = the #GType of each argument from 369 * @args. 370 */ 371 public static void marshalVOIDCHARv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 372 { 373 g_cclosure_marshal_VOID__CHARv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 374 } 375 376 /** 377 * A marshaller for a #GCClosure with a callback of type 378 * `void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)`. 379 * 380 * Params: 381 * closure = the #GClosure to which the marshaller belongs 382 * returnValue = ignored 383 * nParamValues = 2 384 * paramValues = a #GValue array holding the instance and the #gdouble parameter 385 * invocationHint = the invocation hint given as the last argument 386 * to g_closure_invoke() 387 * marshalData = additional data specified when registering the marshaller 388 */ 389 public static void marshalVOIDDOUBLE(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 390 { 391 g_cclosure_marshal_VOID__DOUBLE((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 392 } 393 394 /** 395 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE(). 396 * 397 * Params: 398 * closure = the #GClosure to which the marshaller belongs 399 * returnValue = a #GValue to store the return 400 * value. May be %NULL if the callback of @closure doesn't return a 401 * value. 402 * instanc = the instance on which the closure is invoked. 403 * args = va_list of arguments to be passed to the closure. 404 * marshalData = additional data specified when 405 * registering the marshaller, see g_closure_set_marshal() and 406 * g_closure_set_meta_marshal() 407 * nParams = the length of the @param_types array 408 * paramTypes = the #GType of each argument from 409 * @args. 410 */ 411 public static void marshalVOIDDOUBLEv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 412 { 413 g_cclosure_marshal_VOID__DOUBLEv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 414 } 415 416 /** 417 * A marshaller for a #GCClosure with a callback of type 418 * `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes an enumeration type.. 419 * 420 * Params: 421 * closure = the #GClosure to which the marshaller belongs 422 * returnValue = ignored 423 * nParamValues = 2 424 * paramValues = a #GValue array holding the instance and the enumeration parameter 425 * invocationHint = the invocation hint given as the last argument 426 * to g_closure_invoke() 427 * marshalData = additional data specified when registering the marshaller 428 */ 429 public static void marshalVOIDENUM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 430 { 431 g_cclosure_marshal_VOID__ENUM((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 432 } 433 434 /** 435 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM(). 436 * 437 * Params: 438 * closure = the #GClosure to which the marshaller belongs 439 * returnValue = a #GValue to store the return 440 * value. May be %NULL if the callback of @closure doesn't return a 441 * value. 442 * instanc = the instance on which the closure is invoked. 443 * args = va_list of arguments to be passed to the closure. 444 * marshalData = additional data specified when 445 * registering the marshaller, see g_closure_set_marshal() and 446 * g_closure_set_meta_marshal() 447 * nParams = the length of the @param_types array 448 * paramTypes = the #GType of each argument from 449 * @args. 450 */ 451 public static void marshalVOIDENUMv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 452 { 453 g_cclosure_marshal_VOID__ENUMv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 454 } 455 456 /** 457 * A marshaller for a #GCClosure with a callback of type 458 * `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type. 459 * 460 * Params: 461 * closure = the #GClosure to which the marshaller belongs 462 * returnValue = ignored 463 * nParamValues = 2 464 * paramValues = a #GValue array holding the instance and the flags parameter 465 * invocationHint = the invocation hint given as the last argument 466 * to g_closure_invoke() 467 * marshalData = additional data specified when registering the marshaller 468 */ 469 public static void marshalVOIDFLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 470 { 471 g_cclosure_marshal_VOID__FLAGS((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 472 } 473 474 /** 475 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS(). 476 * 477 * Params: 478 * closure = the #GClosure to which the marshaller belongs 479 * returnValue = a #GValue to store the return 480 * value. May be %NULL if the callback of @closure doesn't return a 481 * value. 482 * instanc = the instance on which the closure is invoked. 483 * args = va_list of arguments to be passed to the closure. 484 * marshalData = additional data specified when 485 * registering the marshaller, see g_closure_set_marshal() and 486 * g_closure_set_meta_marshal() 487 * nParams = the length of the @param_types array 488 * paramTypes = the #GType of each argument from 489 * @args. 490 */ 491 public static void marshalVOIDFLAGSv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 492 { 493 g_cclosure_marshal_VOID__FLAGSv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 494 } 495 496 /** 497 * A marshaller for a #GCClosure with a callback of type 498 * `void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)`. 499 * 500 * Params: 501 * closure = the #GClosure to which the marshaller belongs 502 * returnValue = ignored 503 * nParamValues = 2 504 * paramValues = a #GValue array holding the instance and the #gfloat parameter 505 * invocationHint = the invocation hint given as the last argument 506 * to g_closure_invoke() 507 * marshalData = additional data specified when registering the marshaller 508 */ 509 public static void marshalVOIDFLOAT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 510 { 511 g_cclosure_marshal_VOID__FLOAT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 512 } 513 514 /** 515 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT(). 516 * 517 * Params: 518 * closure = the #GClosure to which the marshaller belongs 519 * returnValue = a #GValue to store the return 520 * value. May be %NULL if the callback of @closure doesn't return a 521 * value. 522 * instanc = the instance on which the closure is invoked. 523 * args = va_list of arguments to be passed to the closure. 524 * marshalData = additional data specified when 525 * registering the marshaller, see g_closure_set_marshal() and 526 * g_closure_set_meta_marshal() 527 * nParams = the length of the @param_types array 528 * paramTypes = the #GType of each argument from 529 * @args. 530 */ 531 public static void marshalVOIDFLOATv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 532 { 533 g_cclosure_marshal_VOID__FLOATv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 534 } 535 536 /** 537 * A marshaller for a #GCClosure with a callback of type 538 * `void (*callback) (gpointer instance, gint arg1, gpointer user_data)`. 539 * 540 * Params: 541 * closure = the #GClosure to which the marshaller belongs 542 * returnValue = ignored 543 * nParamValues = 2 544 * paramValues = a #GValue array holding the instance and the #gint parameter 545 * invocationHint = the invocation hint given as the last argument 546 * to g_closure_invoke() 547 * marshalData = additional data specified when registering the marshaller 548 */ 549 public static void marshalVOIDINT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 550 { 551 g_cclosure_marshal_VOID__INT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 552 } 553 554 /** 555 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT(). 556 * 557 * Params: 558 * closure = the #GClosure to which the marshaller belongs 559 * returnValue = a #GValue to store the return 560 * value. May be %NULL if the callback of @closure doesn't return a 561 * value. 562 * instanc = the instance on which the closure is invoked. 563 * args = va_list of arguments to be passed to the closure. 564 * marshalData = additional data specified when 565 * registering the marshaller, see g_closure_set_marshal() and 566 * g_closure_set_meta_marshal() 567 * nParams = the length of the @param_types array 568 * paramTypes = the #GType of each argument from 569 * @args. 570 */ 571 public static void marshalVOIDINTv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 572 { 573 g_cclosure_marshal_VOID__INTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 574 } 575 576 /** 577 * A marshaller for a #GCClosure with a callback of type 578 * `void (*callback) (gpointer instance, glong arg1, gpointer user_data)`. 579 * 580 * Params: 581 * closure = the #GClosure to which the marshaller belongs 582 * returnValue = ignored 583 * nParamValues = 2 584 * paramValues = a #GValue array holding the instance and the #glong parameter 585 * invocationHint = the invocation hint given as the last argument 586 * to g_closure_invoke() 587 * marshalData = additional data specified when registering the marshaller 588 */ 589 public static void marshalVOIDLONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 590 { 591 g_cclosure_marshal_VOID__LONG((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 592 } 593 594 /** 595 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG(). 596 * 597 * Params: 598 * closure = the #GClosure to which the marshaller belongs 599 * returnValue = a #GValue to store the return 600 * value. May be %NULL if the callback of @closure doesn't return a 601 * value. 602 * instanc = the instance on which the closure is invoked. 603 * args = va_list of arguments to be passed to the closure. 604 * marshalData = additional data specified when 605 * registering the marshaller, see g_closure_set_marshal() and 606 * g_closure_set_meta_marshal() 607 * nParams = the length of the @param_types array 608 * paramTypes = the #GType of each argument from 609 * @args. 610 */ 611 public static void marshalVOIDLONGv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 612 { 613 g_cclosure_marshal_VOID__LONGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 614 } 615 616 /** 617 * A marshaller for a #GCClosure with a callback of type 618 * `void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)`. 619 * 620 * Params: 621 * closure = the #GClosure to which the marshaller belongs 622 * returnValue = ignored 623 * nParamValues = 2 624 * paramValues = a #GValue array holding the instance and the #GObject* parameter 625 * invocationHint = the invocation hint given as the last argument 626 * to g_closure_invoke() 627 * marshalData = additional data specified when registering the marshaller 628 */ 629 public static void marshalVOIDOBJECT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 630 { 631 g_cclosure_marshal_VOID__OBJECT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 632 } 633 634 /** 635 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT(). 636 * 637 * Params: 638 * closure = the #GClosure to which the marshaller belongs 639 * returnValue = a #GValue to store the return 640 * value. May be %NULL if the callback of @closure doesn't return a 641 * value. 642 * instanc = the instance on which the closure is invoked. 643 * args = va_list of arguments to be passed to the closure. 644 * marshalData = additional data specified when 645 * registering the marshaller, see g_closure_set_marshal() and 646 * g_closure_set_meta_marshal() 647 * nParams = the length of the @param_types array 648 * paramTypes = the #GType of each argument from 649 * @args. 650 */ 651 public static void marshalVOIDOBJECTv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 652 { 653 g_cclosure_marshal_VOID__OBJECTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 654 } 655 656 /** 657 * A marshaller for a #GCClosure with a callback of type 658 * `void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)`. 659 * 660 * Params: 661 * closure = the #GClosure to which the marshaller belongs 662 * returnValue = ignored 663 * nParamValues = 2 664 * paramValues = a #GValue array holding the instance and the #GParamSpec* parameter 665 * invocationHint = the invocation hint given as the last argument 666 * to g_closure_invoke() 667 * marshalData = additional data specified when registering the marshaller 668 */ 669 public static void marshalVOIDPARAM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 670 { 671 g_cclosure_marshal_VOID__PARAM((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 672 } 673 674 /** 675 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM(). 676 * 677 * Params: 678 * closure = the #GClosure to which the marshaller belongs 679 * returnValue = a #GValue to store the return 680 * value. May be %NULL if the callback of @closure doesn't return a 681 * value. 682 * instanc = the instance on which the closure is invoked. 683 * args = va_list of arguments to be passed to the closure. 684 * marshalData = additional data specified when 685 * registering the marshaller, see g_closure_set_marshal() and 686 * g_closure_set_meta_marshal() 687 * nParams = the length of the @param_types array 688 * paramTypes = the #GType of each argument from 689 * @args. 690 */ 691 public static void marshalVOIDPARAMv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 692 { 693 g_cclosure_marshal_VOID__PARAMv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 694 } 695 696 /** 697 * A marshaller for a #GCClosure with a callback of type 698 * `void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)`. 699 * 700 * Params: 701 * closure = the #GClosure to which the marshaller belongs 702 * returnValue = ignored 703 * nParamValues = 2 704 * paramValues = a #GValue array holding the instance and the #gpointer parameter 705 * invocationHint = the invocation hint given as the last argument 706 * to g_closure_invoke() 707 * marshalData = additional data specified when registering the marshaller 708 */ 709 public static void marshalVOIDPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 710 { 711 g_cclosure_marshal_VOID__POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 712 } 713 714 /** 715 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER(). 716 * 717 * Params: 718 * closure = the #GClosure to which the marshaller belongs 719 * returnValue = a #GValue to store the return 720 * value. May be %NULL if the callback of @closure doesn't return a 721 * value. 722 * instanc = the instance on which the closure is invoked. 723 * args = va_list of arguments to be passed to the closure. 724 * marshalData = additional data specified when 725 * registering the marshaller, see g_closure_set_marshal() and 726 * g_closure_set_meta_marshal() 727 * nParams = the length of the @param_types array 728 * paramTypes = the #GType of each argument from 729 * @args. 730 */ 731 public static void marshalVOIDPOINTERv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 732 { 733 g_cclosure_marshal_VOID__POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 734 } 735 736 /** 737 * A marshaller for a #GCClosure with a callback of type 738 * `void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)`. 739 * 740 * Params: 741 * closure = the #GClosure to which the marshaller belongs 742 * returnValue = ignored 743 * nParamValues = 2 744 * paramValues = a #GValue array holding the instance and the #gchar* parameter 745 * invocationHint = the invocation hint given as the last argument 746 * to g_closure_invoke() 747 * marshalData = additional data specified when registering the marshaller 748 */ 749 public static void marshalVOIDSTRING(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 750 { 751 g_cclosure_marshal_VOID__STRING((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 752 } 753 754 /** 755 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING(). 756 * 757 * Params: 758 * closure = the #GClosure to which the marshaller belongs 759 * returnValue = a #GValue to store the return 760 * value. May be %NULL if the callback of @closure doesn't return a 761 * value. 762 * instanc = the instance on which the closure is invoked. 763 * args = va_list of arguments to be passed to the closure. 764 * marshalData = additional data specified when 765 * registering the marshaller, see g_closure_set_marshal() and 766 * g_closure_set_meta_marshal() 767 * nParams = the length of the @param_types array 768 * paramTypes = the #GType of each argument from 769 * @args. 770 */ 771 public static void marshalVOIDSTRINGv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 772 { 773 g_cclosure_marshal_VOID__STRINGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 774 } 775 776 /** 777 * A marshaller for a #GCClosure with a callback of type 778 * `void (*callback) (gpointer instance, guchar arg1, gpointer user_data)`. 779 * 780 * Params: 781 * closure = the #GClosure to which the marshaller belongs 782 * returnValue = ignored 783 * nParamValues = 2 784 * paramValues = a #GValue array holding the instance and the #guchar parameter 785 * invocationHint = the invocation hint given as the last argument 786 * to g_closure_invoke() 787 * marshalData = additional data specified when registering the marshaller 788 */ 789 public static void marshalVOIDUCHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 790 { 791 g_cclosure_marshal_VOID__UCHAR((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 792 } 793 794 /** 795 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR(). 796 * 797 * Params: 798 * closure = the #GClosure to which the marshaller belongs 799 * returnValue = a #GValue to store the return 800 * value. May be %NULL if the callback of @closure doesn't return a 801 * value. 802 * instanc = the instance on which the closure is invoked. 803 * args = va_list of arguments to be passed to the closure. 804 * marshalData = additional data specified when 805 * registering the marshaller, see g_closure_set_marshal() and 806 * g_closure_set_meta_marshal() 807 * nParams = the length of the @param_types array 808 * paramTypes = the #GType of each argument from 809 * @args. 810 */ 811 public static void marshalVOIDUCHARv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 812 { 813 g_cclosure_marshal_VOID__UCHARv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 814 } 815 816 /** 817 * A marshaller for a #GCClosure with a callback of type 818 * `void (*callback) (gpointer instance, guint arg1, gpointer user_data)`. 819 * 820 * Params: 821 * closure = the #GClosure to which the marshaller belongs 822 * returnValue = ignored 823 * nParamValues = 2 824 * paramValues = a #GValue array holding the instance and the #guint parameter 825 * invocationHint = the invocation hint given as the last argument 826 * to g_closure_invoke() 827 * marshalData = additional data specified when registering the marshaller 828 */ 829 public static void marshalVOIDUINT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 830 { 831 g_cclosure_marshal_VOID__UINT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 832 } 833 834 /** 835 * A marshaller for a #GCClosure with a callback of type 836 * `void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)`. 837 * 838 * Params: 839 * closure = the #GClosure to which the marshaller belongs 840 * returnValue = ignored 841 * nParamValues = 3 842 * paramValues = a #GValue array holding instance, arg1 and arg2 843 * invocationHint = the invocation hint given as the last argument 844 * to g_closure_invoke() 845 * marshalData = additional data specified when registering the marshaller 846 */ 847 public static void marshalVOIDUINTPOINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 848 { 849 g_cclosure_marshal_VOID__UINT_POINTER((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 850 } 851 852 /** 853 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER(). 854 * 855 * Params: 856 * closure = the #GClosure to which the marshaller belongs 857 * returnValue = a #GValue to store the return 858 * value. May be %NULL if the callback of @closure doesn't return a 859 * value. 860 * instanc = the instance on which the closure is invoked. 861 * args = va_list of arguments to be passed to the closure. 862 * marshalData = additional data specified when 863 * registering the marshaller, see g_closure_set_marshal() and 864 * g_closure_set_meta_marshal() 865 * nParams = the length of the @param_types array 866 * paramTypes = the #GType of each argument from 867 * @args. 868 */ 869 public static void marshalVOIDUINTPOINTERv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 870 { 871 g_cclosure_marshal_VOID__UINT_POINTERv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 872 } 873 874 /** 875 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT(). 876 * 877 * Params: 878 * closure = the #GClosure to which the marshaller belongs 879 * returnValue = a #GValue to store the return 880 * value. May be %NULL if the callback of @closure doesn't return a 881 * value. 882 * instanc = the instance on which the closure is invoked. 883 * args = va_list of arguments to be passed to the closure. 884 * marshalData = additional data specified when 885 * registering the marshaller, see g_closure_set_marshal() and 886 * g_closure_set_meta_marshal() 887 * nParams = the length of the @param_types array 888 * paramTypes = the #GType of each argument from 889 * @args. 890 */ 891 public static void marshalVOIDUINTv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 892 { 893 g_cclosure_marshal_VOID__UINTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 894 } 895 896 /** 897 * A marshaller for a #GCClosure with a callback of type 898 * `void (*callback) (gpointer instance, gulong arg1, gpointer user_data)`. 899 * 900 * Params: 901 * closure = the #GClosure to which the marshaller belongs 902 * returnValue = ignored 903 * nParamValues = 2 904 * paramValues = a #GValue array holding the instance and the #gulong parameter 905 * invocationHint = the invocation hint given as the last argument 906 * to g_closure_invoke() 907 * marshalData = additional data specified when registering the marshaller 908 */ 909 public static void marshalVOIDULONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 910 { 911 g_cclosure_marshal_VOID__ULONG((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 912 } 913 914 /** 915 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG(). 916 * 917 * Params: 918 * closure = the #GClosure to which the marshaller belongs 919 * returnValue = a #GValue to store the return 920 * value. May be %NULL if the callback of @closure doesn't return a 921 * value. 922 * instanc = the instance on which the closure is invoked. 923 * args = va_list of arguments to be passed to the closure. 924 * marshalData = additional data specified when 925 * registering the marshaller, see g_closure_set_marshal() and 926 * g_closure_set_meta_marshal() 927 * nParams = the length of the @param_types array 928 * paramTypes = the #GType of each argument from 929 * @args. 930 */ 931 public static void marshalVOIDULONGv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 932 { 933 g_cclosure_marshal_VOID__ULONGv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 934 } 935 936 /** 937 * A marshaller for a #GCClosure with a callback of type 938 * `void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)`. 939 * 940 * Params: 941 * closure = the #GClosure to which the marshaller belongs 942 * returnValue = ignored 943 * nParamValues = 2 944 * paramValues = a #GValue array holding the instance and the #GVariant* parameter 945 * invocationHint = the invocation hint given as the last argument 946 * to g_closure_invoke() 947 * marshalData = additional data specified when registering the marshaller 948 * 949 * Since: 2.26 950 */ 951 public static void marshalVOIDVARIANT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 952 { 953 g_cclosure_marshal_VOID__VARIANT((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 954 } 955 956 /** 957 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT(). 958 * 959 * Params: 960 * closure = the #GClosure to which the marshaller belongs 961 * returnValue = a #GValue to store the return 962 * value. May be %NULL if the callback of @closure doesn't return a 963 * value. 964 * instanc = the instance on which the closure is invoked. 965 * args = va_list of arguments to be passed to the closure. 966 * marshalData = additional data specified when 967 * registering the marshaller, see g_closure_set_marshal() and 968 * g_closure_set_meta_marshal() 969 * nParams = the length of the @param_types array 970 * paramTypes = the #GType of each argument from 971 * @args. 972 */ 973 public static void marshalVOIDVARIANTv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 974 { 975 g_cclosure_marshal_VOID__VARIANTv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 976 } 977 978 /** 979 * A marshaller for a #GCClosure with a callback of type 980 * `void (*callback) (gpointer instance, gpointer user_data)`. 981 * 982 * Params: 983 * closure = the #GClosure to which the marshaller belongs 984 * returnValue = ignored 985 * nParamValues = 1 986 * paramValues = a #GValue array holding only the instance 987 * invocationHint = the invocation hint given as the last argument 988 * to g_closure_invoke() 989 * marshalData = additional data specified when registering the marshaller 990 */ 991 public static void marshalVOIDVOID(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 992 { 993 g_cclosure_marshal_VOID__VOID((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 994 } 995 996 /** 997 * The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID(). 998 * 999 * Params: 1000 * closure = the #GClosure to which the marshaller belongs 1001 * returnValue = a #GValue to store the return 1002 * value. May be %NULL if the callback of @closure doesn't return a 1003 * value. 1004 * instanc = the instance on which the closure is invoked. 1005 * args = va_list of arguments to be passed to the closure. 1006 * marshalData = additional data specified when 1007 * registering the marshaller, see g_closure_set_marshal() and 1008 * g_closure_set_meta_marshal() 1009 * nParams = the length of the @param_types array 1010 * paramTypes = the #GType of each argument from 1011 * @args. 1012 */ 1013 public static void marshalVOIDVOIDv(Closure closure, Value returnValue, TypeInstance instanc, void* args, void* marshalData, GType[] paramTypes) 1014 { 1015 g_cclosure_marshal_VOID__VOIDv((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), args, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 1016 } 1017 1018 /** 1019 * A generic marshaller function implemented via 1020 * [libffi](http://sourceware.org/libffi/). 1021 * 1022 * Normally this function is not passed explicitly to g_signal_new(), 1023 * but used automatically by GLib when specifying a %NULL marshaller. 1024 * 1025 * Params: 1026 * closure = A #GClosure. 1027 * returnGvalue = A #GValue to store the return value. May be %NULL 1028 * if the callback of closure doesn't return a value. 1029 * nParamValues = The length of the @param_values array. 1030 * paramValues = An array of #GValues holding the arguments 1031 * on which to invoke the callback of closure. 1032 * invocationHint = The invocation hint given as the last argument to 1033 * g_closure_invoke(). 1034 * marshalData = Additional data specified when registering the 1035 * marshaller, see g_closure_set_marshal() and 1036 * g_closure_set_meta_marshal() 1037 * 1038 * Since: 2.30 1039 */ 1040 public static void marshalGeneric(Closure closure, Value returnGvalue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData) 1041 { 1042 g_cclosure_marshal_generic((closure is null) ? null : closure.getClosureStruct(), (returnGvalue is null) ? null : returnGvalue.getValueStruct(), nParamValues, (paramValues is null) ? null : paramValues.getValueStruct(), invocationHint, marshalData); 1043 } 1044 1045 /** 1046 * A generic #GVaClosureMarshal function implemented via 1047 * [libffi](http://sourceware.org/libffi/). 1048 * 1049 * Params: 1050 * closure = the #GClosure to which the marshaller belongs 1051 * returnValue = a #GValue to store the return 1052 * value. May be %NULL if the callback of @closure doesn't return a 1053 * value. 1054 * instanc = the instance on which the closure is 1055 * invoked. 1056 * argsList = va_list of arguments to be passed to the closure. 1057 * marshalData = additional data specified when 1058 * registering the marshaller, see g_closure_set_marshal() and 1059 * g_closure_set_meta_marshal() 1060 * nParams = the length of the @param_types array 1061 * paramTypes = the #GType of each argument from 1062 * @args_list. 1063 * 1064 * Since: 2.30 1065 */ 1066 public static void marshalGenericVa(Closure closure, Value returnValue, TypeInstance instanc, void* argsList, void* marshalData, GType[] paramTypes) 1067 { 1068 g_cclosure_marshal_generic_va((closure is null) ? null : closure.getClosureStruct(), (returnValue is null) ? null : returnValue.getValueStruct(), (instanc is null) ? null : instanc.getTypeInstanceStruct(), argsList, marshalData, cast(int)paramTypes.length, paramTypes.ptr); 1069 } 1070 }