src/gobject/CClosure.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  =
  26  * outPack = gobject
  27  * outFile = CClosure
  28  * strct   = GCClosure
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = CClosure
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - g_cclosure
  40  * omit structs:
  41  * omit prefixes:
  42  *      - g_closure_
  43  *      - g_source_set_closure
  44  * omit code:
  45  * imports:
  46  *      - gobject.Closure
  47  *      - gobject.ObjectG
  48  *      - gobject.Value
  49  * structWrap:
  50  *      - GClosure* -> Closure
  51  *      - GObject* -> ObjectG
  52  *      - GValue* -> Value
  53  * local aliases:
  54  */
  55
  56 module gobject.CClosure;
  57
  58 private import gobject.gobjecttypes;
  59
  60 private import lib.gobject;
  61
  62 private import gobject.Closure;
  63 private import gobject.ObjectG;
  64 private import gobject.Value;
  65
  66 /**
  67  * Description
  68  * A GClosure represents a callback supplied by the programmer. It will generally
  69  * comprise a function of some kind and a marshaller used to call it. It is the
  70  * reponsibility of the marshaller to convert the arguments for the invocation
  71  * from GValues into a suitable form, perform the callback on the
  72  * converted arguments, and transform the return value back into a GValue.
  73  * In the case of C programs, a closure usually just holds a pointer to a function
  74  * and maybe a data argument, and the marshaller converts between GValue
  75  * and native C types. The GObject library provides the GCClosure type for this
  76  * purpose. Bindings for other languages need marshallers which
  77  * convert between GValues and suitable representations in the runtime
  78  * of the language in order to use functions written in that languages as
  79  * callbacks.
  80  * Within GObject, closures play an important role in the implementation of
  81  * signals. When a signal is registered, the c_marshaller argument to
  82  * g_signal_new() specifies the default C marshaller for any closure which is
  83  * connected to this signal. GObject provides a number of C marshallers
  84  * for this purpose, see the g_cclosure_marshal_*() functions. Additional
  85  * C marshallers can be generated with the glib-genmarshal utility.
  86  * Closures can be explicitly connected to signals with
  87  * g_signal_connect_closure(), but it usually more convenient to let GObject
  88  * create a closure automatically by using one of the g_signal_connect_*()
  89  * functions which take a callback function/user data pair.
  90  * Using closures has a number of important advantages over a simple
  91  * callback function/data pointer combination:
  92  * Closures allow the callee to get the types of the callback parameters,
  93  * which means that language bindings don't have to write individual glue
  94  * for each callback type.
  95  * The reference counting of GClosure makes it easy to handle reentrancy
  96  * right; if a callback is removed while it is being invoked, the closure
  97  * and it's parameters won't be freed until the invocation finishes.
  98  * g_closure_invalidate() and invalidation notifiers allow callbacks to be
  99  * automatically removed when the objects they point to go away.
 100  */
 101 public class CClosure
 102 {
 103
 104         /** the main Gtk struct */
 105         protected GCClosure* gCClosure;
 106
 107
 108         public GCClosure* getCClosureStruct()
 109         {
 110                 return gCClosure;
 111         }
 112
 113
 114         /** the main Gtk struct as a void* */
 115         protected void* getStruct()
 116         {
 117                 return cast(void*)gCClosure;
 118         }
 119
 120         /**
 121          * Sets our main struct and passes it to the parent class
 122          */
 123         public this (GCClosure* gCClosure)
 124         {
 125                 this.gCClosure = gCClosure;
 126         }
 127
 128         /**
 129          */
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141         /**
 142          * Creates a new closure which invokes callback_func with user_data as
 143          * the last parameter.
 144          * callback_func:
 145          * the function to invoke
 146          * user_data:
 147          * user data to pass to callback_func
 148          * destroy_data:
 149          * destroy notify to be called when user_data is no longer used
 150          * Returns:
 151          * a new GCClosure
 152          */
 153         public static Closure _New(GCallback callbackFunc, void* userData, GClosureNotify destroyData)
 154         {
 155                 // GClosure* g_cclosure_new (GCallback callback_func,  gpointer user_data,  GClosureNotify destroy_data);
 156                 return new Closure( g_cclosure_new(callbackFunc, userData, destroyData) );
 157         }
 158
 159         /**
 160          * Creates a new closure which invokes callback_func with user_data as
 161          * the first parameter.
 162          * callback_func:
 163          * the function to invoke
 164          * user_data:
 165          * user data to pass to callback_func
 166          * destroy_data:
 167          * destroy notify to be called when user_data is no longer used
 168          * Returns:
 169          * a new GCClosure
 170          */
 171         public static Closure _NewSwap(GCallback callbackFunc, void* userData, GClosureNotify destroyData)
 172         {
 173                 // GClosure* g_cclosure_new_swap (GCallback callback_func,  gpointer user_data,  GClosureNotify destroy_data);
 174                 return new Closure( g_cclosure_new_swap(callbackFunc, userData, destroyData) );
 175         }
 176
 177         /**
 178          * A variant of g_cclosure_new() which uses object as user_data and calls
 179          * g_object_watch_closure() on object and the created closure. This function
 180          * is useful when you have a callback closely associated with a GObject,
 181          * and want the callback to no longer run after the object is is freed.
 182          * callback_func:
 183          * the function to invoke
 184          * object:
 185          * a GObject pointer to pass to callback_func
 186          * Returns:
 187          * a new GCClosure
 188          */
 189         public static Closure _NewObject(GCallback callbackFunc, ObjectG object)
 190         {
 191                 // GClosure* g_cclosure_new_object (GCallback callback_func,  GObject *object);
 192                 return new Closure( g_cclosure_new_object(callbackFunc, (object is null) ? null : object.getObjectGStruct()) );
 193         }
 194
 195         /**
 196          * A variant of g_cclosure_new_swap() which uses object as user_data and calls
 197          * g_object_watch_closure() on object and the created closure. This function
 198          * is useful when you have a callback closely associated with a GObject,
 199          * and want the callback to no longer run after the object is is freed.
 200          * callback_func:
 201          * the function to invoke
 202          * object:
 203          * a GObject pointer to pass to callback_func
 204          * Returns:
 205          * a new GCClosure
 206          */
 207         public static Closure _NewObjectSwap(GCallback callbackFunc, ObjectG object)
 208         {
 209                 // GClosure* g_cclosure_new_object_swap (GCallback callback_func,  GObject *object);
 210                 return new Closure( g_cclosure_new_object_swap(callbackFunc, (object is null) ? null : object.getObjectGStruct()) );
 211         }
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230         /**
 231          * A marshaller for a GCClosure with a callback of type
 232          * void (*callback) (gpointer instance, gpointer user_data).
 233          * closure:
 234          * the GClosure to which the marshaller belongs
 235          * return_value:
 236          * ignored
 237          * n_param_values:
 238          * 1
 239          * param_values:
 240          * a GValue array holding only the instance
 241          * invocation_hint:
 242          * the invocation hint given as the the last argument
 243          *  to g_closure_invoke()
 244          * marshal_data:
 245          * additional data specified when registering the marshaller
 246          */
 247         public static void _MarshalVOID__VOID(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 248         {
 249                 // void g_cclosure_marshal_VOID__VOID (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 250                 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);
 251         }
 252
 253         /**
 254          * A marshaller for a GCClosure with a callback of type
 255          * void (*callback) (gpointer instance, gboolean arg1, gpointer user_data).
 256          * closure:
 257          * the GClosure to which the marshaller belongs
 258          * return_value:
 259          * ignored
 260          * n_param_values:
 261          * 2
 262          * param_values:
 263          * a GValue array holding the instance and the gboolean parameter
 264          * invocation_hint:
 265          * the invocation hint given as the the last argument
 266          *  to g_closure_invoke()
 267          * marshal_data:
 268          * additional data specified when registering the marshaller
 269          */
 270         public static void _MarshalVOID__BOOLEAN(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 271         {
 272                 // void g_cclosure_marshal_VOID__BOOLEAN  (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 273                 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);
 274         }
 275
 276         /**
 277          * A marshaller for a GCClosure with a callback of type
 278          * void (*callback) (gpointer instance, gchar arg1, gpointer user_data).
 279          * closure:
 280          * the GClosure to which the marshaller belongs
 281          * return_value:
 282          * ignored
 283          * n_param_values:
 284          * 2
 285          * param_values:
 286          * a GValue array holding the instance and the gchar parameter
 287          * invocation_hint:
 288          * the invocation hint given as the the last argument
 289          *  to g_closure_invoke()
 290          * marshal_data:
 291          * additional data specified when registering the marshaller
 292          */
 293         public static void _MarshalVOID__CHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 294         {
 295                 // void g_cclosure_marshal_VOID__CHAR (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 296                 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);
 297         }
 298
 299         /**
 300          * A marshaller for a GCClosure with a callback of type
 301          * void (*callback) (gpointer instance, guchar arg1, gpointer user_data).
 302          * closure:
 303          * the GClosure to which the marshaller belongs
 304          * return_value:
 305          * ignored
 306          * n_param_values:
 307          * 2
 308          * param_values:
 309          * a GValue array holding the instance and the guchar parameter
 310          * invocation_hint:
 311          * the invocation hint given as the the last argument
 312          *  to g_closure_invoke()
 313          * marshal_data:
 314          * additional data specified when registering the marshaller
 315          */
 316         public static void _MarshalVOID__UCHAR(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 317         {
 318                 // void g_cclosure_marshal_VOID__UCHAR (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 319                 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);
 320         }
 321
 322         /**
 323          * A marshaller for a GCClosure with a callback of type
 324          * void (*callback) (gpointer instance, gint arg1, gpointer user_data).
 325          * closure:
 326          * the GClosure to which the marshaller belongs
 327          * return_value:
 328          * ignored
 329          * n_param_values:
 330          * 2
 331          * param_values:
 332          * a GValue array holding the instance and the gint parameter
 333          * invocation_hint:
 334          * the invocation hint given as the the last argument
 335          *  to g_closure_invoke()
 336          * marshal_data:
 337          * additional data specified when registering the marshaller
 338          */
 339         public static void _MarshalVOID__INT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 340         {
 341                 // void g_cclosure_marshal_VOID__INT (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 342                 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);
 343         }
 344
 345         /**
 346          * A marshaller for a GCClosure with a callback of type
 347          * void (*callback) (gpointer instance, guint arg1, gpointer user_data).
 348          * closure:
 349          * the GClosure to which the marshaller belongs
 350          * return_value:
 351          * ignored
 352          * n_param_values:
 353          * 2
 354          * param_values:
 355          * a GValue array holding the instance and the guint parameter
 356          * invocation_hint:
 357          * the invocation hint given as the the last argument
 358          *  to g_closure_invoke()
 359          * marshal_data:
 360          * additional data specified when registering the marshaller
 361          */
 362         public static void _MarshalVOID__UINT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 363         {
 364                 // void g_cclosure_marshal_VOID__UINT (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 365                 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);
 366         }
 367
 368         /**
 369          * A marshaller for a GCClosure with a callback of type
 370          * void (*callback) (gpointer instance, glong arg1, gpointer user_data).
 371          * closure:
 372          * the GClosure to which the marshaller belongs
 373          * return_value:
 374          * ignored
 375          * n_param_values:
 376          * 2
 377          * param_values:
 378          * a GValue array holding the instance and the glong parameter
 379          * invocation_hint:
 380          * the invocation hint given as the the last argument
 381          *  to g_closure_invoke()
 382          * marshal_data:
 383          * additional data specified when registering the marshaller
 384          */
 385         public static void _MarshalVOID__LONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 386         {
 387                 // void g_cclosure_marshal_VOID__LONG (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 388                 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);
 389         }
 390
 391         /**
 392          * A marshaller for a GCClosure with a callback of type
 393          * void (*callback) (gpointer instance, gulong arg1, gpointer user_data).
 394          * closure:
 395          * the GClosure to which the marshaller belongs
 396          * return_value:
 397          * ignored
 398          * n_param_values:
 399          * 2
 400          * param_values:
 401          * a GValue array holding the instance and the gulong parameter
 402          * invocation_hint:
 403          * the invocation hint given as the the last argument
 404          *  to g_closure_invoke()
 405          * marshal_data:
 406          * additional data specified when registering the marshaller
 407          */
 408         public static void _MarshalVOID__ULONG(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 409         {
 410                 // void g_cclosure_marshal_VOID__ULONG (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 411                 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);
 412         }
 413
 414         /**
 415          * A marshaller for a GCClosure with a callback of type
 416          * void (*callback) (gpointer instance, gint arg1, gpointer user_data) where the gint parameter denotes an enumeration type..
 417          * closure:
 418          * the GClosure to which the marshaller belongs
 419          * return_value:
 420          * ignored
 421          * n_param_values:
 422          * 2
 423          * param_values:
 424          * a GValue array holding the instance and the enumeration parameter
 425          * invocation_hint:
 426          * the invocation hint given as the the last argument
 427          *  to g_closure_invoke()
 428          * marshal_data:
 429          * additional data specified when registering the marshaller
 430          */
 431         public static void _MarshalVOID__ENUM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 432         {
 433                 // void g_cclosure_marshal_VOID__ENUM (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 434                 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);
 435         }
 436
 437         /**
 438          * A marshaller for a GCClosure with a callback of type
 439          * void (*callback) (gpointer instance, gint arg1, gpointer user_data) where the gint parameter denotes a flags type
 440          * denotes a flags type.
 441          * closure:
 442          * the GClosure to which the marshaller belongs
 443          * return_value:
 444          * ignored
 445          * n_param_values:
 446          * 2
 447          * param_values:
 448          * a GValue array holding the instance and the flags parameter
 449          * invocation_hint:
 450          * the invocation hint given as the the last argument
 451          *  to g_closure_invoke()
 452          * marshal_data:
 453          * additional data specified when registering the marshaller
 454          */
 455         public static void _MarshalVOID__FLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 456         {
 457                 // void g_cclosure_marshal_VOID__FLAGS (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 458                 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);
 459         }
 460
 461         /**
 462          * A marshaller for a GCClosure with a callback of type
 463          * void (*callback) (gpointer instance, gfloat arg1, gpointer user_data).
 464          * closure:
 465          * the GClosure to which the marshaller belongs
 466          * return_value:
 467          * ignored
 468          * n_param_values:
 469          * 2
 470          * param_values:
 471          * a GValue array holding the instance and the gfloat parameter
 472          * invocation_hint:
 473          * the invocation hint given as the the last argument
 474          *  to g_closure_invoke()
 475          * marshal_data:
 476          * additional data specified when registering the marshaller
 477          */
 478         public static void _MarshalVOID__FLOAT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 479         {
 480                 // void g_cclosure_marshal_VOID__FLOAT (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 481                 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);
 482         }
 483
 484         /**
 485          * A marshaller for a GCClosure with a callback of type
 486          * void (*callback) (gpointer instance, gdouble arg1, gpointer user_data).
 487          * closure:
 488          * the GClosure to which the marshaller belongs
 489          * return_value:
 490          * ignored
 491          * n_param_values:
 492          * 2
 493          * param_values:
 494          * a GValue array holding the instance and the gdouble parameter
 495          * invocation_hint:
 496          * the invocation hint given as the the last argument
 497          *  to g_closure_invoke()
 498          * marshal_data:
 499          * additional data specified when registering the marshaller
 500          */
 501         public static void _MarshalVOID__DOUBLE(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 502         {
 503                 // void g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 504                 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);
 505         }
 506
 507         /**
 508          * A marshaller for a GCClosure with a callback of type
 509          * void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data).
 510          * closure:
 511          * the GClosure to which the marshaller belongs
 512          * return_value:
 513          * ignored
 514          * n_param_values:
 515          * 2
 516          * param_values:
 517          * a GValue array holding the instance and the gchar* parameter
 518          * invocation_hint:
 519          * the invocation hint given as the the last argument
 520          *  to g_closure_invoke()
 521          * marshal_data:
 522          * additional data specified when registering the marshaller
 523          */
 524         public static void _MarshalVOID__STRING(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 525         {
 526                 // void g_cclosure_marshal_VOID__STRING (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 527                 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);
 528         }
 529
 530         /**
 531          * A marshaller for a GCClosure with a callback of type
 532          * void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data).
 533          * closure:
 534          * the GClosure to which the marshaller belongs
 535          * return_value:
 536          * ignored
 537          * n_param_values:
 538          * 2
 539          * param_values:
 540          * a GValue array holding the instance and the GParamSpec* parameter
 541          * invocation_hint:
 542          * the invocation hint given as the the last argument
 543          *  to g_closure_invoke()
 544          * marshal_data:
 545          * additional data specified when registering the marshaller
 546          */
 547         public static void _MarshalVOID__PARAM(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 548         {
 549                 // void g_cclosure_marshal_VOID__PARAM (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 550                 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);
 551         }
 552
 553         /**
 554          * A marshaller for a GCClosure with a callback of type
 555          * void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data).
 556          * closure:
 557          * the GClosure to which the marshaller belongs
 558          * return_value:
 559          * ignored
 560          * n_param_values:
 561          * 2
 562          * param_values:
 563          * a GValue array holding the instance and the GBoxed* parameter
 564          * invocation_hint:
 565          * the invocation hint given as the the last argument
 566          *  to g_closure_invoke()
 567          * marshal_data:
 568          * additional data specified when registering the marshaller
 569          */
 570         public static void _MarshalVOID__BOXED(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 571         {
 572                 // void g_cclosure_marshal_VOID__BOXED (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 573                 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);
 574         }
 575
 576         /**
 577          * A marshaller for a GCClosure with a callback of type
 578          * void (*callback) (gpointer instance, gpointer arg1, gpointer user_data).
 579          * closure:
 580          * the GClosure to which the marshaller belongs
 581          * return_value:
 582          * ignored
 583          * n_param_values:
 584          * 2
 585          * param_values:
 586          * a GValue array holding the instance and the gpointer parameter
 587          * invocation_hint:
 588          * the invocation hint given as the the last argument
 589          *  to g_closure_invoke()
 590          * marshal_data:
 591          * additional data specified when registering the marshaller
 592          */
 593         public static void _MarshalVOID__POINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 594         {
 595                 // void g_cclosure_marshal_VOID__POINTER  (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 596                 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);
 597         }
 598
 599         /**
 600          * A marshaller for a GCClosure with a callback of type
 601          * void (*callback) (gpointer instance, GOBject *arg1, gpointer user_data).
 602          * closure:
 603          * the GClosure to which the marshaller belongs
 604          * return_value:
 605          * ignored
 606          * n_param_values:
 607          * 2
 608          * param_values:
 609          * a GValue array holding the instance and the GObject* parameter
 610          * invocation_hint:
 611          * the invocation hint given as the the last argument
 612          *  to g_closure_invoke()
 613          * marshal_data:
 614          * additional data specified when registering the marshaller
 615          */
 616         public static void _MarshalVOID__OBJECT(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 617         {
 618                 // void g_cclosure_marshal_VOID__OBJECT (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 619                 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);
 620         }
 621
 622         /**
 623          * A marshaller for a GCClosure with a callback of type
 624          * void (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data).
 625          * closure:
 626          * the GClosure to which the marshaller belongs
 627          * return_value:
 628          * ignored
 629          * n_param_values:
 630          * 3
 631          * param_values:
 632          * a GValue array holding instance, arg1 and arg2
 633          * invocation_hint:
 634          * the invocation hint given as the the last argument
 635          *  to g_closure_invoke()
 636          * marshal_data:
 637          * additional data specified when registering the marshaller
 638          */
 639         public static void _MarshalSTRING__OBJECT_POINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 640         {
 641                 // void g_cclosure_marshal_STRING__OBJECT_POINTER  (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 642                 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);
 643         }
 644
 645         /**
 646          * A marshaller for a GCClosure with a callback of type
 647          * void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data).
 648          * closure:
 649          * the GClosure to which the marshaller belongs
 650          * return_value:
 651          * ignored
 652          * n_param_values:
 653          * 3
 654          * param_values:
 655          * a GValue array holding instance, arg1 and arg2
 656          * invocation_hint:
 657          * the invocation hint given as the the last argument
 658          *  to g_closure_invoke()
 659          * marshal_data:
 660          * additional data specified when registering the marshaller
 661          */
 662         public static void _MarshalVOID__UINT_POINTER(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 663         {
 664                 // void g_cclosure_marshal_VOID__UINT_POINTER  (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 665                 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);
 666         }
 667
 668         /**
 669          * A marshaller for a GCClosure with a callback of type
 670          * gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data) where the gint parameter
 671          * denotes a flags type.
 672          * closure:
 673          * the GClosure to which the marshaller belongs
 674          * return_value:
 675          * a GValue which can store the returned gboolean
 676          * n_param_values:
 677          * 2
 678          * param_values:
 679          * a GValue array holding instance and arg1
 680          * invocation_hint:
 681          * the invocation hint given as the the last argument
 682          *  to g_closure_invoke()
 683          * marshal_data:
 684          * additional data specified when registering the marshaller
 685          */
 686         public static void _MarshalBOOLEAN__FLAGS(Closure closure, Value returnValue, uint nParamValues, Value paramValues, void* invocationHint, void* marshalData)
 687         {
 688                 // void g_cclosure_marshal_BOOLEAN__FLAGS  (GClosure *closure,  GValue *return_value,  guint n_param_values,  const GValue *param_values,  gpointer invocation_hint,  gpointer marshal_data);
 689                 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);
 690         }
 691
 692 }