gtkmarshal.c

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

Generated on Sat Apr 1 09:03:55 2006 for GXSM by  doxygen 1.4.6