gxsm

gtkmarshalers.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 /* BOOLEAN:BOXED (./gtkmarshalers.list:24) */
00051 void
00052 _gtk_marshal_BOOLEAN__BOXED (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__BOXED) (gpointer     data1,
00060                                                    gpointer     arg_1,
00061                                                    gpointer     data2);
00062   register GMarshalFunc_BOOLEAN__BOXED callback;
00063   register GCClosure *cc = (GCClosure*) closure;
00064   register gpointer data1, data2;
00065   gboolean v_return;
00066 
00067   g_return_if_fail (return_value != NULL);
00068   g_return_if_fail (n_param_values == 2);
00069 
00070   if (G_CCLOSURE_SWAP_DATA (closure))
00071     {
00072       data1 = closure->data;
00073       data2 = g_value_peek_pointer (param_values + 0);
00074     }
00075   else
00076     {
00077       data1 = g_value_peek_pointer (param_values + 0);
00078       data2 = closure->data;
00079     }
00080   callback = (GMarshalFunc_BOOLEAN__BOXED) (marshal_data ? marshal_data : cc->callback);
00081 
00082   v_return = callback (data1,
00083                        g_marshal_value_peek_boxed (param_values + 1),
00084                        data2);
00085 
00086   g_value_set_boolean (return_value, v_return);
00087 }
00088 
00089 /* BOOLEAN:BOXED,BOXED (./gtkmarshalers.list:25) */
00090 void
00091 _gtk_marshal_BOOLEAN__BOXED_BOXED (GClosure     *closure,
00092                                    GValue       *return_value,
00093                                    guint         n_param_values,
00094                                    const GValue *param_values,
00095                                    gpointer      invocation_hint,
00096                                    gpointer      marshal_data)
00097 {
00098   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_BOXED) (gpointer     data1,
00099                                                          gpointer     arg_1,
00100                                                          gpointer     arg_2,
00101                                                          gpointer     data2);
00102   register GMarshalFunc_BOOLEAN__BOXED_BOXED callback;
00103   register GCClosure *cc = (GCClosure*) closure;
00104   register gpointer data1, data2;
00105   gboolean v_return;
00106 
00107   g_return_if_fail (return_value != NULL);
00108   g_return_if_fail (n_param_values == 3);
00109 
00110   if (G_CCLOSURE_SWAP_DATA (closure))
00111     {
00112       data1 = closure->data;
00113       data2 = g_value_peek_pointer (param_values + 0);
00114     }
00115   else
00116     {
00117       data1 = g_value_peek_pointer (param_values + 0);
00118       data2 = closure->data;
00119     }
00120   callback = (GMarshalFunc_BOOLEAN__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
00121 
00122   v_return = callback (data1,
00123                        g_marshal_value_peek_boxed (param_values + 1),
00124                        g_marshal_value_peek_boxed (param_values + 2),
00125                        data2);
00126 
00127   g_value_set_boolean (return_value, v_return);
00128 }
00129 
00130 /* BOOLEAN:ENUM (./gtkmarshalers.list:26) */
00131 void
00132 _gtk_marshal_BOOLEAN__ENUM (GClosure     *closure,
00133                             GValue       *return_value,
00134                             guint         n_param_values,
00135                             const GValue *param_values,
00136                             gpointer      invocation_hint,
00137                             gpointer      marshal_data)
00138 {
00139   typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM) (gpointer     data1,
00140                                                   gint         arg_1,
00141                                                   gpointer     data2);
00142   register GMarshalFunc_BOOLEAN__ENUM callback;
00143   register GCClosure *cc = (GCClosure*) closure;
00144   register gpointer data1, data2;
00145   gboolean v_return;
00146 
00147   g_return_if_fail (return_value != NULL);
00148   g_return_if_fail (n_param_values == 2);
00149 
00150   if (G_CCLOSURE_SWAP_DATA (closure))
00151     {
00152       data1 = closure->data;
00153       data2 = g_value_peek_pointer (param_values + 0);
00154     }
00155   else
00156     {
00157       data1 = g_value_peek_pointer (param_values + 0);
00158       data2 = closure->data;
00159     }
00160   callback = (GMarshalFunc_BOOLEAN__ENUM) (marshal_data ? marshal_data : cc->callback);
00161 
00162   v_return = callback (data1,
00163                        g_marshal_value_peek_enum (param_values + 1),
00164                        data2);
00165 
00166   g_value_set_boolean (return_value, v_return);
00167 }
00168 
00169 /* BOOLEAN:ENUM,INT (./gtkmarshalers.list:27) */
00170 void
00171 _gtk_marshal_BOOLEAN__ENUM_INT (GClosure     *closure,
00172                                 GValue       *return_value,
00173                                 guint         n_param_values,
00174                                 const GValue *param_values,
00175                                 gpointer      invocation_hint,
00176                                 gpointer      marshal_data)
00177 {
00178   typedef gboolean (*GMarshalFunc_BOOLEAN__ENUM_INT) (gpointer     data1,
00179                                                       gint         arg_1,
00180                                                       gint         arg_2,
00181                                                       gpointer     data2);
00182   register GMarshalFunc_BOOLEAN__ENUM_INT callback;
00183   register GCClosure *cc = (GCClosure*) closure;
00184   register gpointer data1, data2;
00185   gboolean v_return;
00186 
00187   g_return_if_fail (return_value != NULL);
00188   g_return_if_fail (n_param_values == 3);
00189 
00190   if (G_CCLOSURE_SWAP_DATA (closure))
00191     {
00192       data1 = closure->data;
00193       data2 = g_value_peek_pointer (param_values + 0);
00194     }
00195   else
00196     {
00197       data1 = g_value_peek_pointer (param_values + 0);
00198       data2 = closure->data;
00199     }
00200   callback = (GMarshalFunc_BOOLEAN__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
00201 
00202   v_return = callback (data1,
00203                        g_marshal_value_peek_enum (param_values + 1),
00204                        g_marshal_value_peek_int (param_values + 2),
00205                        data2);
00206 
00207   g_value_set_boolean (return_value, v_return);
00208 }
00209 
00210 /* BOOLEAN:OBJECT,UINT,FLAGS (./gtkmarshalers.list:28) */
00211 void
00212 _gtk_marshal_BOOLEAN__OBJECT_UINT_FLAGS (GClosure     *closure,
00213                                          GValue       *return_value,
00214                                          guint         n_param_values,
00215                                          const GValue *param_values,
00216                                          gpointer      invocation_hint,
00217                                          gpointer      marshal_data)
00218 {
00219   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (gpointer     data1,
00220                                                                gpointer     arg_1,
00221                                                                guint        arg_2,
00222                                                                guint        arg_3,
00223                                                                gpointer     data2);
00224   register GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS callback;
00225   register GCClosure *cc = (GCClosure*) closure;
00226   register gpointer data1, data2;
00227   gboolean v_return;
00228 
00229   g_return_if_fail (return_value != NULL);
00230   g_return_if_fail (n_param_values == 4);
00231 
00232   if (G_CCLOSURE_SWAP_DATA (closure))
00233     {
00234       data1 = closure->data;
00235       data2 = g_value_peek_pointer (param_values + 0);
00236     }
00237   else
00238     {
00239       data1 = g_value_peek_pointer (param_values + 0);
00240       data2 = closure->data;
00241     }
00242   callback = (GMarshalFunc_BOOLEAN__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
00243 
00244   v_return = callback (data1,
00245                        g_marshal_value_peek_object (param_values + 1),
00246                        g_marshal_value_peek_uint (param_values + 2),
00247                        g_marshal_value_peek_flags (param_values + 3),
00248                        data2);
00249 
00250   g_value_set_boolean (return_value, v_return);
00251 }
00252 
00253 /* BOOLEAN:OBJECT,INT,INT,UINT (./gtkmarshalers.list:29) */
00254 void
00255 _gtk_marshal_BOOLEAN__OBJECT_INT_INT_UINT (GClosure     *closure,
00256                                            GValue       *return_value,
00257                                            guint         n_param_values,
00258                                            const GValue *param_values,
00259                                            gpointer      invocation_hint,
00260                                            gpointer      marshal_data)
00261 {
00262   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (gpointer     data1,
00263                                                                  gpointer     arg_1,
00264                                                                  gint         arg_2,
00265                                                                  gint         arg_3,
00266                                                                  guint        arg_4,
00267                                                                  gpointer     data2);
00268   register GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT callback;
00269   register GCClosure *cc = (GCClosure*) closure;
00270   register gpointer data1, data2;
00271   gboolean v_return;
00272 
00273   g_return_if_fail (return_value != NULL);
00274   g_return_if_fail (n_param_values == 5);
00275 
00276   if (G_CCLOSURE_SWAP_DATA (closure))
00277     {
00278       data1 = closure->data;
00279       data2 = g_value_peek_pointer (param_values + 0);
00280     }
00281   else
00282     {
00283       data1 = g_value_peek_pointer (param_values + 0);
00284       data2 = closure->data;
00285     }
00286   callback = (GMarshalFunc_BOOLEAN__OBJECT_INT_INT_UINT) (marshal_data ? marshal_data : cc->callback);
00287 
00288   v_return = callback (data1,
00289                        g_marshal_value_peek_object (param_values + 1),
00290                        g_marshal_value_peek_int (param_values + 2),
00291                        g_marshal_value_peek_int (param_values + 3),
00292                        g_marshal_value_peek_uint (param_values + 4),
00293                        data2);
00294 
00295   g_value_set_boolean (return_value, v_return);
00296 }
00297 
00298 /* BOOLEAN:OBJECT,STRING,STRING,BOXED (./gtkmarshalers.list:30) */
00299 void
00300 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXED (GClosure     *closure,
00301                                                   GValue       *return_value,
00302                                                   guint         n_param_values,
00303                                                   const GValue *param_values,
00304                                                   gpointer      invocation_hint,
00305                                                   gpointer      marshal_data)
00306 {
00307   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (gpointer     data1,
00308                                                                         gpointer     arg_1,
00309                                                                         gpointer     arg_2,
00310                                                                         gpointer     arg_3,
00311                                                                         gpointer     arg_4,
00312                                                                         gpointer     data2);
00313   register GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED callback;
00314   register GCClosure *cc = (GCClosure*) closure;
00315   register gpointer data1, data2;
00316   gboolean v_return;
00317 
00318   g_return_if_fail (return_value != NULL);
00319   g_return_if_fail (n_param_values == 5);
00320 
00321   if (G_CCLOSURE_SWAP_DATA (closure))
00322     {
00323       data1 = closure->data;
00324       data2 = g_value_peek_pointer (param_values + 0);
00325     }
00326   else
00327     {
00328       data1 = g_value_peek_pointer (param_values + 0);
00329       data2 = closure->data;
00330     }
00331   callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING_BOXED) (marshal_data ? marshal_data : cc->callback);
00332 
00333   v_return = callback (data1,
00334                        g_marshal_value_peek_object (param_values + 1),
00335                        g_marshal_value_peek_string (param_values + 2),
00336                        g_marshal_value_peek_string (param_values + 3),
00337                        g_marshal_value_peek_boxed (param_values + 4),
00338                        data2);
00339 
00340   g_value_set_boolean (return_value, v_return);
00341 }
00342 
00343 /* BOOLEAN:OBJECT,BOXED (./gtkmarshalers.list:31) */
00344 void
00345 _gtk_marshal_BOOLEAN__OBJECT_BOXED (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 gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED) (gpointer     data1,
00353                                                           gpointer     arg_1,
00354                                                           gpointer     arg_2,
00355                                                           gpointer     data2);
00356   register GMarshalFunc_BOOLEAN__OBJECT_BOXED callback;
00357   register GCClosure *cc = (GCClosure*) closure;
00358   register gpointer data1, data2;
00359   gboolean v_return;
00360 
00361   g_return_if_fail (return_value != NULL);
00362   g_return_if_fail (n_param_values == 3);
00363 
00364   if (G_CCLOSURE_SWAP_DATA (closure))
00365     {
00366       data1 = closure->data;
00367       data2 = g_value_peek_pointer (param_values + 0);
00368     }
00369   else
00370     {
00371       data1 = g_value_peek_pointer (param_values + 0);
00372       data2 = closure->data;
00373     }
00374   callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED) (marshal_data ? marshal_data : cc->callback);
00375 
00376   v_return = callback (data1,
00377                        g_marshal_value_peek_object (param_values + 1),
00378                        g_marshal_value_peek_boxed (param_values + 2),
00379                        data2);
00380 
00381   g_value_set_boolean (return_value, v_return);
00382 }
00383 
00384 /* BOOLEAN:OBJECT,BOXED,BOXED (./gtkmarshalers.list:32) */
00385 void
00386 _gtk_marshal_BOOLEAN__OBJECT_BOXED_BOXED (GClosure     *closure,
00387                                           GValue       *return_value,
00388                                           guint         n_param_values,
00389                                           const GValue *param_values,
00390                                           gpointer      invocation_hint,
00391                                           gpointer      marshal_data)
00392 {
00393   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (gpointer     data1,
00394                                                                 gpointer     arg_1,
00395                                                                 gpointer     arg_2,
00396                                                                 gpointer     arg_3,
00397                                                                 gpointer     data2);
00398   register GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED callback;
00399   register GCClosure *cc = (GCClosure*) closure;
00400   register gpointer data1, data2;
00401   gboolean v_return;
00402 
00403   g_return_if_fail (return_value != NULL);
00404   g_return_if_fail (n_param_values == 4);
00405 
00406   if (G_CCLOSURE_SWAP_DATA (closure))
00407     {
00408       data1 = closure->data;
00409       data2 = g_value_peek_pointer (param_values + 0);
00410     }
00411   else
00412     {
00413       data1 = g_value_peek_pointer (param_values + 0);
00414       data2 = closure->data;
00415     }
00416   callback = (GMarshalFunc_BOOLEAN__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
00417 
00418   v_return = callback (data1,
00419                        g_marshal_value_peek_object (param_values + 1),
00420                        g_marshal_value_peek_boxed (param_values + 2),
00421                        g_marshal_value_peek_boxed (param_values + 3),
00422                        data2);
00423 
00424   g_value_set_boolean (return_value, v_return);
00425 }
00426 
00427 /* BOOLEAN:OBJECT,STRING,STRING (./gtkmarshalers.list:33) */
00428 void
00429 _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING (GClosure     *closure,
00430                                             GValue       *return_value,
00431                                             guint         n_param_values,
00432                                             const GValue *param_values,
00433                                             gpointer      invocation_hint,
00434                                             gpointer      marshal_data)
00435 {
00436   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (gpointer     data1,
00437                                                                   gpointer     arg_1,
00438                                                                   gpointer     arg_2,
00439                                                                   gpointer     arg_3,
00440                                                                   gpointer     data2);
00441   register GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING callback;
00442   register GCClosure *cc = (GCClosure*) closure;
00443   register gpointer data1, data2;
00444   gboolean v_return;
00445 
00446   g_return_if_fail (return_value != NULL);
00447   g_return_if_fail (n_param_values == 4);
00448 
00449   if (G_CCLOSURE_SWAP_DATA (closure))
00450     {
00451       data1 = closure->data;
00452       data2 = g_value_peek_pointer (param_values + 0);
00453     }
00454   else
00455     {
00456       data1 = g_value_peek_pointer (param_values + 0);
00457       data2 = closure->data;
00458     }
00459   callback = (GMarshalFunc_BOOLEAN__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
00460 
00461   v_return = callback (data1,
00462                        g_marshal_value_peek_object (param_values + 1),
00463                        g_marshal_value_peek_string (param_values + 2),
00464                        g_marshal_value_peek_string (param_values + 3),
00465                        data2);
00466 
00467   g_value_set_boolean (return_value, v_return);
00468 }
00469 
00470 /* BOOLEAN:INT,INT (./gtkmarshalers.list:34) */
00471 void
00472 _gtk_marshal_BOOLEAN__INT_INT (GClosure     *closure,
00473                                GValue       *return_value,
00474                                guint         n_param_values,
00475                                const GValue *param_values,
00476                                gpointer      invocation_hint,
00477                                gpointer      marshal_data)
00478 {
00479   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT) (gpointer     data1,
00480                                                      gint         arg_1,
00481                                                      gint         arg_2,
00482                                                      gpointer     data2);
00483   register GMarshalFunc_BOOLEAN__INT_INT callback;
00484   register GCClosure *cc = (GCClosure*) closure;
00485   register gpointer data1, data2;
00486   gboolean v_return;
00487 
00488   g_return_if_fail (return_value != NULL);
00489   g_return_if_fail (n_param_values == 3);
00490 
00491   if (G_CCLOSURE_SWAP_DATA (closure))
00492     {
00493       data1 = closure->data;
00494       data2 = g_value_peek_pointer (param_values + 0);
00495     }
00496   else
00497     {
00498       data1 = g_value_peek_pointer (param_values + 0);
00499       data2 = closure->data;
00500     }
00501   callback = (GMarshalFunc_BOOLEAN__INT_INT) (marshal_data ? marshal_data : cc->callback);
00502 
00503   v_return = callback (data1,
00504                        g_marshal_value_peek_int (param_values + 1),
00505                        g_marshal_value_peek_int (param_values + 2),
00506                        data2);
00507 
00508   g_value_set_boolean (return_value, v_return);
00509 }
00510 
00511 /* BOOLEAN:INT,INT,INT (./gtkmarshalers.list:35) */
00512 void
00513 _gtk_marshal_BOOLEAN__INT_INT_INT (GClosure     *closure,
00514                                    GValue       *return_value,
00515                                    guint         n_param_values,
00516                                    const GValue *param_values,
00517                                    gpointer      invocation_hint,
00518                                    gpointer      marshal_data)
00519 {
00520   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_INT) (gpointer     data1,
00521                                                          gint         arg_1,
00522                                                          gint         arg_2,
00523                                                          gint         arg_3,
00524                                                          gpointer     data2);
00525   register GMarshalFunc_BOOLEAN__INT_INT_INT callback;
00526   register GCClosure *cc = (GCClosure*) closure;
00527   register gpointer data1, data2;
00528   gboolean v_return;
00529 
00530   g_return_if_fail (return_value != NULL);
00531   g_return_if_fail (n_param_values == 4);
00532 
00533   if (G_CCLOSURE_SWAP_DATA (closure))
00534     {
00535       data1 = closure->data;
00536       data2 = g_value_peek_pointer (param_values + 0);
00537     }
00538   else
00539     {
00540       data1 = g_value_peek_pointer (param_values + 0);
00541       data2 = closure->data;
00542     }
00543   callback = (GMarshalFunc_BOOLEAN__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
00544 
00545   v_return = callback (data1,
00546                        g_marshal_value_peek_int (param_values + 1),
00547                        g_marshal_value_peek_int (param_values + 2),
00548                        g_marshal_value_peek_int (param_values + 3),
00549                        data2);
00550 
00551   g_value_set_boolean (return_value, v_return);
00552 }
00553 
00554 /* BOOLEAN:UINT (./gtkmarshalers.list:36) */
00555 void
00556 _gtk_marshal_BOOLEAN__UINT (GClosure     *closure,
00557                             GValue       *return_value,
00558                             guint         n_param_values,
00559                             const GValue *param_values,
00560                             gpointer      invocation_hint,
00561                             gpointer      marshal_data)
00562 {
00563   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT) (gpointer     data1,
00564                                                   guint        arg_1,
00565                                                   gpointer     data2);
00566   register GMarshalFunc_BOOLEAN__UINT callback;
00567   register GCClosure *cc = (GCClosure*) closure;
00568   register gpointer data1, data2;
00569   gboolean v_return;
00570 
00571   g_return_if_fail (return_value != NULL);
00572   g_return_if_fail (n_param_values == 2);
00573 
00574   if (G_CCLOSURE_SWAP_DATA (closure))
00575     {
00576       data1 = closure->data;
00577       data2 = g_value_peek_pointer (param_values + 0);
00578     }
00579   else
00580     {
00581       data1 = g_value_peek_pointer (param_values + 0);
00582       data2 = closure->data;
00583     }
00584   callback = (GMarshalFunc_BOOLEAN__UINT) (marshal_data ? marshal_data : cc->callback);
00585 
00586   v_return = callback (data1,
00587                        g_marshal_value_peek_uint (param_values + 1),
00588                        data2);
00589 
00590   g_value_set_boolean (return_value, v_return);
00591 }
00592 
00593 /* BOOLEAN:VOID (./gtkmarshalers.list:37) */
00594 void
00595 _gtk_marshal_BOOLEAN__VOID (GClosure     *closure,
00596                             GValue       *return_value,
00597                             guint         n_param_values,
00598                             const GValue *param_values,
00599                             gpointer      invocation_hint,
00600                             gpointer      marshal_data)
00601 {
00602   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
00603                                                   gpointer     data2);
00604   register GMarshalFunc_BOOLEAN__VOID callback;
00605   register GCClosure *cc = (GCClosure*) closure;
00606   register gpointer data1, data2;
00607   gboolean v_return;
00608 
00609   g_return_if_fail (return_value != NULL);
00610   g_return_if_fail (n_param_values == 1);
00611 
00612   if (G_CCLOSURE_SWAP_DATA (closure))
00613     {
00614       data1 = closure->data;
00615       data2 = g_value_peek_pointer (param_values + 0);
00616     }
00617   else
00618     {
00619       data1 = g_value_peek_pointer (param_values + 0);
00620       data2 = closure->data;
00621     }
00622   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
00623 
00624   v_return = callback (data1,
00625                        data2);
00626 
00627   g_value_set_boolean (return_value, v_return);
00628 }
00629 
00630 /* BOOLEAN:BOOLEAN (./gtkmarshalers.list:38) */
00631 void
00632 _gtk_marshal_BOOLEAN__BOOLEAN (GClosure     *closure,
00633                                GValue       *return_value,
00634                                guint         n_param_values,
00635                                const GValue *param_values,
00636                                gpointer      invocation_hint,
00637                                gpointer      marshal_data)
00638 {
00639   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN) (gpointer     data1,
00640                                                      gboolean     arg_1,
00641                                                      gpointer     data2);
00642   register GMarshalFunc_BOOLEAN__BOOLEAN callback;
00643   register GCClosure *cc = (GCClosure*) closure;
00644   register gpointer data1, data2;
00645   gboolean v_return;
00646 
00647   g_return_if_fail (return_value != NULL);
00648   g_return_if_fail (n_param_values == 2);
00649 
00650   if (G_CCLOSURE_SWAP_DATA (closure))
00651     {
00652       data1 = closure->data;
00653       data2 = g_value_peek_pointer (param_values + 0);
00654     }
00655   else
00656     {
00657       data1 = g_value_peek_pointer (param_values + 0);
00658       data2 = closure->data;
00659     }
00660   callback = (GMarshalFunc_BOOLEAN__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
00661 
00662   v_return = callback (data1,
00663                        g_marshal_value_peek_boolean (param_values + 1),
00664                        data2);
00665 
00666   g_value_set_boolean (return_value, v_return);
00667 }
00668 
00669 /* BOOLEAN:NONE (./gtkmarshalers.list:39) */
00670 
00671 /* BOOLEAN:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:40) */
00672 void
00673 _gtk_marshal_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
00674                                                GValue       *return_value,
00675                                                guint         n_param_values,
00676                                                const GValue *param_values,
00677                                                gpointer      invocation_hint,
00678                                                gpointer      marshal_data)
00679 {
00680   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer     data1,
00681                                                                      gboolean     arg_1,
00682                                                                      gboolean     arg_2,
00683                                                                      gboolean     arg_3,
00684                                                                      gpointer     data2);
00685   register GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN callback;
00686   register GCClosure *cc = (GCClosure*) closure;
00687   register gpointer data1, data2;
00688   gboolean v_return;
00689 
00690   g_return_if_fail (return_value != NULL);
00691   g_return_if_fail (n_param_values == 4);
00692 
00693   if (G_CCLOSURE_SWAP_DATA (closure))
00694     {
00695       data1 = closure->data;
00696       data2 = g_value_peek_pointer (param_values + 0);
00697     }
00698   else
00699     {
00700       data1 = g_value_peek_pointer (param_values + 0);
00701       data2 = closure->data;
00702     }
00703   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
00704 
00705   v_return = callback (data1,
00706                        g_marshal_value_peek_boolean (param_values + 1),
00707                        g_marshal_value_peek_boolean (param_values + 2),
00708                        g_marshal_value_peek_boolean (param_values + 3),
00709                        data2);
00710 
00711   g_value_set_boolean (return_value, v_return);
00712 }
00713 
00714 /* ENUM:ENUM (./gtkmarshalers.list:41) */
00715 void
00716 _gtk_marshal_ENUM__ENUM (GClosure     *closure,
00717                          GValue       *return_value,
00718                          guint         n_param_values,
00719                          const GValue *param_values,
00720                          gpointer      invocation_hint,
00721                          gpointer      marshal_data)
00722 {
00723   typedef gint (*GMarshalFunc_ENUM__ENUM) (gpointer     data1,
00724                                            gint         arg_1,
00725                                            gpointer     data2);
00726   register GMarshalFunc_ENUM__ENUM callback;
00727   register GCClosure *cc = (GCClosure*) closure;
00728   register gpointer data1, data2;
00729   gint v_return;
00730 
00731   g_return_if_fail (return_value != NULL);
00732   g_return_if_fail (n_param_values == 2);
00733 
00734   if (G_CCLOSURE_SWAP_DATA (closure))
00735     {
00736       data1 = closure->data;
00737       data2 = g_value_peek_pointer (param_values + 0);
00738     }
00739   else
00740     {
00741       data1 = g_value_peek_pointer (param_values + 0);
00742       data2 = closure->data;
00743     }
00744   callback = (GMarshalFunc_ENUM__ENUM) (marshal_data ? marshal_data : cc->callback);
00745 
00746   v_return = callback (data1,
00747                        g_marshal_value_peek_enum (param_values + 1),
00748                        data2);
00749 
00750   g_value_set_enum (return_value, v_return);
00751 }
00752 
00753 /* INT:POINTER (./gtkmarshalers.list:42) */
00754 void
00755 _gtk_marshal_INT__POINTER (GClosure     *closure,
00756                            GValue       *return_value,
00757                            guint         n_param_values,
00758                            const GValue *param_values,
00759                            gpointer      invocation_hint,
00760                            gpointer      marshal_data)
00761 {
00762   typedef gint (*GMarshalFunc_INT__POINTER) (gpointer     data1,
00763                                              gpointer     arg_1,
00764                                              gpointer     data2);
00765   register GMarshalFunc_INT__POINTER callback;
00766   register GCClosure *cc = (GCClosure*) closure;
00767   register gpointer data1, data2;
00768   gint v_return;
00769 
00770   g_return_if_fail (return_value != NULL);
00771   g_return_if_fail (n_param_values == 2);
00772 
00773   if (G_CCLOSURE_SWAP_DATA (closure))
00774     {
00775       data1 = closure->data;
00776       data2 = g_value_peek_pointer (param_values + 0);
00777     }
00778   else
00779     {
00780       data1 = g_value_peek_pointer (param_values + 0);
00781       data2 = closure->data;
00782     }
00783   callback = (GMarshalFunc_INT__POINTER) (marshal_data ? marshal_data : cc->callback);
00784 
00785   v_return = callback (data1,
00786                        g_marshal_value_peek_pointer (param_values + 1),
00787                        data2);
00788 
00789   g_value_set_int (return_value, v_return);
00790 }
00791 
00792 /* NONE:BOOLEAN (./gtkmarshalers.list:43) */
00793 
00794 /* NONE:ENUM (./gtkmarshalers.list:44) */
00795 
00796 /* NONE:INT (./gtkmarshalers.list:45) */
00797 
00798 /* NONE:INT,BOOL (./gtkmarshalers.list:46) */
00799 void
00800 _gtk_marshal_VOID__INT_BOOLEAN (GClosure     *closure,
00801                                 GValue       *return_value,
00802                                 guint         n_param_values,
00803                                 const GValue *param_values,
00804                                 gpointer      invocation_hint,
00805                                 gpointer      marshal_data)
00806 {
00807   typedef void (*GMarshalFunc_VOID__INT_BOOLEAN) (gpointer     data1,
00808                                                   gint         arg_1,
00809                                                   gboolean     arg_2,
00810                                                   gpointer     data2);
00811   register GMarshalFunc_VOID__INT_BOOLEAN callback;
00812   register GCClosure *cc = (GCClosure*) closure;
00813   register gpointer data1, data2;
00814 
00815   g_return_if_fail (n_param_values == 3);
00816 
00817   if (G_CCLOSURE_SWAP_DATA (closure))
00818     {
00819       data1 = closure->data;
00820       data2 = g_value_peek_pointer (param_values + 0);
00821     }
00822   else
00823     {
00824       data1 = g_value_peek_pointer (param_values + 0);
00825       data2 = closure->data;
00826     }
00827   callback = (GMarshalFunc_VOID__INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
00828 
00829   callback (data1,
00830             g_marshal_value_peek_int (param_values + 1),
00831             g_marshal_value_peek_boolean (param_values + 2),
00832             data2);
00833 }
00834 
00835 /* NONE:INT,INT (./gtkmarshalers.list:47) */
00836 void
00837 _gtk_marshal_VOID__INT_INT (GClosure     *closure,
00838                             GValue       *return_value,
00839                             guint         n_param_values,
00840                             const GValue *param_values,
00841                             gpointer      invocation_hint,
00842                             gpointer      marshal_data)
00843 {
00844   typedef void (*GMarshalFunc_VOID__INT_INT) (gpointer     data1,
00845                                               gint         arg_1,
00846                                               gint         arg_2,
00847                                               gpointer     data2);
00848   register GMarshalFunc_VOID__INT_INT callback;
00849   register GCClosure *cc = (GCClosure*) closure;
00850   register gpointer data1, data2;
00851 
00852   g_return_if_fail (n_param_values == 3);
00853 
00854   if (G_CCLOSURE_SWAP_DATA (closure))
00855     {
00856       data1 = closure->data;
00857       data2 = g_value_peek_pointer (param_values + 0);
00858     }
00859   else
00860     {
00861       data1 = g_value_peek_pointer (param_values + 0);
00862       data2 = closure->data;
00863     }
00864   callback = (GMarshalFunc_VOID__INT_INT) (marshal_data ? marshal_data : cc->callback);
00865 
00866   callback (data1,
00867             g_marshal_value_peek_int (param_values + 1),
00868             g_marshal_value_peek_int (param_values + 2),
00869             data2);
00870 }
00871 
00872 /* NONE:NONE (./gtkmarshalers.list:48) */
00873 
00874 /* NONE:STRING,INT,POINTER (./gtkmarshalers.list:49) */
00875 void
00876 _gtk_marshal_VOID__STRING_INT_POINTER (GClosure     *closure,
00877                                        GValue       *return_value,
00878                                        guint         n_param_values,
00879                                        const GValue *param_values,
00880                                        gpointer      invocation_hint,
00881                                        gpointer      marshal_data)
00882 {
00883   typedef void (*GMarshalFunc_VOID__STRING_INT_POINTER) (gpointer     data1,
00884                                                          gpointer     arg_1,
00885                                                          gint         arg_2,
00886                                                          gpointer     arg_3,
00887                                                          gpointer     data2);
00888   register GMarshalFunc_VOID__STRING_INT_POINTER callback;
00889   register GCClosure *cc = (GCClosure*) closure;
00890   register gpointer data1, data2;
00891 
00892   g_return_if_fail (n_param_values == 4);
00893 
00894   if (G_CCLOSURE_SWAP_DATA (closure))
00895     {
00896       data1 = closure->data;
00897       data2 = g_value_peek_pointer (param_values + 0);
00898     }
00899   else
00900     {
00901       data1 = g_value_peek_pointer (param_values + 0);
00902       data2 = closure->data;
00903     }
00904   callback = (GMarshalFunc_VOID__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00905 
00906   callback (data1,
00907             g_marshal_value_peek_string (param_values + 1),
00908             g_marshal_value_peek_int (param_values + 2),
00909             g_marshal_value_peek_pointer (param_values + 3),
00910             data2);
00911 }
00912 
00913 /* STRING:DOUBLE (./gtkmarshalers.list:50) */
00914 void
00915 _gtk_marshal_STRING__DOUBLE (GClosure     *closure,
00916                              GValue       *return_value,
00917                              guint         n_param_values,
00918                              const GValue *param_values,
00919                              gpointer      invocation_hint,
00920                              gpointer      marshal_data)
00921 {
00922   typedef gchar* (*GMarshalFunc_STRING__DOUBLE) (gpointer     data1,
00923                                                  gdouble      arg_1,
00924                                                  gpointer     data2);
00925   register GMarshalFunc_STRING__DOUBLE callback;
00926   register GCClosure *cc = (GCClosure*) closure;
00927   register gpointer data1, data2;
00928   gchar* v_return;
00929 
00930   g_return_if_fail (return_value != NULL);
00931   g_return_if_fail (n_param_values == 2);
00932 
00933   if (G_CCLOSURE_SWAP_DATA (closure))
00934     {
00935       data1 = closure->data;
00936       data2 = g_value_peek_pointer (param_values + 0);
00937     }
00938   else
00939     {
00940       data1 = g_value_peek_pointer (param_values + 0);
00941       data2 = closure->data;
00942     }
00943   callback = (GMarshalFunc_STRING__DOUBLE) (marshal_data ? marshal_data : cc->callback);
00944 
00945   v_return = callback (data1,
00946                        g_marshal_value_peek_double (param_values + 1),
00947                        data2);
00948 
00949   g_value_take_string (return_value, v_return);
00950 }
00951 
00952 /* VOID:DOUBLE (./gtkmarshalers.list:51) */
00953 
00954 /* VOID:BOOLEAN (./gtkmarshalers.list:52) */
00955 
00956 /* VOID:BOOLEAN,BOOLEAN,BOOLEAN (./gtkmarshalers.list:53) */
00957 void
00958 _gtk_marshal_VOID__BOOLEAN_BOOLEAN_BOOLEAN (GClosure     *closure,
00959                                             GValue       *return_value,
00960                                             guint         n_param_values,
00961                                             const GValue *param_values,
00962                                             gpointer      invocation_hint,
00963                                             gpointer      marshal_data)
00964 {
00965   typedef void (*GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (gpointer     data1,
00966                                                               gboolean     arg_1,
00967                                                               gboolean     arg_2,
00968                                                               gboolean     arg_3,
00969                                                               gpointer     data2);
00970   register GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN callback;
00971   register GCClosure *cc = (GCClosure*) closure;
00972   register gpointer data1, data2;
00973 
00974   g_return_if_fail (n_param_values == 4);
00975 
00976   if (G_CCLOSURE_SWAP_DATA (closure))
00977     {
00978       data1 = closure->data;
00979       data2 = g_value_peek_pointer (param_values + 0);
00980     }
00981   else
00982     {
00983       data1 = g_value_peek_pointer (param_values + 0);
00984       data2 = closure->data;
00985     }
00986   callback = (GMarshalFunc_VOID__BOOLEAN_BOOLEAN_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
00987 
00988   callback (data1,
00989             g_marshal_value_peek_boolean (param_values + 1),
00990             g_marshal_value_peek_boolean (param_values + 2),
00991             g_marshal_value_peek_boolean (param_values + 3),
00992             data2);
00993 }
00994 
00995 /* VOID:BOXED (./gtkmarshalers.list:54) */
00996 
00997 /* VOID:BOXED,BOXED (./gtkmarshalers.list:55) */
00998 void
00999 _gtk_marshal_VOID__BOXED_BOXED (GClosure     *closure,
01000                                 GValue       *return_value,
01001                                 guint         n_param_values,
01002                                 const GValue *param_values,
01003                                 gpointer      invocation_hint,
01004                                 gpointer      marshal_data)
01005 {
01006   typedef void (*GMarshalFunc_VOID__BOXED_BOXED) (gpointer     data1,
01007                                                   gpointer     arg_1,
01008                                                   gpointer     arg_2,
01009                                                   gpointer     data2);
01010   register GMarshalFunc_VOID__BOXED_BOXED callback;
01011   register GCClosure *cc = (GCClosure*) closure;
01012   register gpointer data1, data2;
01013 
01014   g_return_if_fail (n_param_values == 3);
01015 
01016   if (G_CCLOSURE_SWAP_DATA (closure))
01017     {
01018       data1 = closure->data;
01019       data2 = g_value_peek_pointer (param_values + 0);
01020     }
01021   else
01022     {
01023       data1 = g_value_peek_pointer (param_values + 0);
01024       data2 = closure->data;
01025     }
01026   callback = (GMarshalFunc_VOID__BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
01027 
01028   callback (data1,
01029             g_marshal_value_peek_boxed (param_values + 1),
01030             g_marshal_value_peek_boxed (param_values + 2),
01031             data2);
01032 }
01033 
01034 /* VOID:BOXED,BOXED,POINTER (./gtkmarshalers.list:56) */
01035 void
01036 _gtk_marshal_VOID__BOXED_BOXED_POINTER (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__BOXED_BOXED_POINTER) (gpointer     data1,
01044                                                           gpointer     arg_1,
01045                                                           gpointer     arg_2,
01046                                                           gpointer     arg_3,
01047                                                           gpointer     data2);
01048   register GMarshalFunc_VOID__BOXED_BOXED_POINTER callback;
01049   register GCClosure *cc = (GCClosure*) closure;
01050   register gpointer data1, data2;
01051 
01052   g_return_if_fail (n_param_values == 4);
01053 
01054   if (G_CCLOSURE_SWAP_DATA (closure))
01055     {
01056       data1 = closure->data;
01057       data2 = g_value_peek_pointer (param_values + 0);
01058     }
01059   else
01060     {
01061       data1 = g_value_peek_pointer (param_values + 0);
01062       data2 = closure->data;
01063     }
01064   callback = (GMarshalFunc_VOID__BOXED_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
01065 
01066   callback (data1,
01067             g_marshal_value_peek_boxed (param_values + 1),
01068             g_marshal_value_peek_boxed (param_values + 2),
01069             g_marshal_value_peek_pointer (param_values + 3),
01070             data2);
01071 }
01072 
01073 /* VOID:BOXED,OBJECT (./gtkmarshalers.list:57) */
01074 void
01075 _gtk_marshal_VOID__BOXED_OBJECT (GClosure     *closure,
01076                                  GValue       *return_value,
01077                                  guint         n_param_values,
01078                                  const GValue *param_values,
01079                                  gpointer      invocation_hint,
01080                                  gpointer      marshal_data)
01081 {
01082   typedef void (*GMarshalFunc_VOID__BOXED_OBJECT) (gpointer     data1,
01083                                                    gpointer     arg_1,
01084                                                    gpointer     arg_2,
01085                                                    gpointer     data2);
01086   register GMarshalFunc_VOID__BOXED_OBJECT callback;
01087   register GCClosure *cc = (GCClosure*) closure;
01088   register gpointer data1, data2;
01089 
01090   g_return_if_fail (n_param_values == 3);
01091 
01092   if (G_CCLOSURE_SWAP_DATA (closure))
01093     {
01094       data1 = closure->data;
01095       data2 = g_value_peek_pointer (param_values + 0);
01096     }
01097   else
01098     {
01099       data1 = g_value_peek_pointer (param_values + 0);
01100       data2 = closure->data;
01101     }
01102   callback = (GMarshalFunc_VOID__BOXED_OBJECT) (marshal_data ? marshal_data : cc->callback);
01103 
01104   callback (data1,
01105             g_marshal_value_peek_boxed (param_values + 1),
01106             g_marshal_value_peek_object (param_values + 2),
01107             data2);
01108 }
01109 
01110 /* VOID:BOXED,STRING,INT (./gtkmarshalers.list:58) */
01111 void
01112 _gtk_marshal_VOID__BOXED_STRING_INT (GClosure     *closure,
01113                                      GValue       *return_value,
01114                                      guint         n_param_values,
01115                                      const GValue *param_values,
01116                                      gpointer      invocation_hint,
01117                                      gpointer      marshal_data)
01118 {
01119   typedef void (*GMarshalFunc_VOID__BOXED_STRING_INT) (gpointer     data1,
01120                                                        gpointer     arg_1,
01121                                                        gpointer     arg_2,
01122                                                        gint         arg_3,
01123                                                        gpointer     data2);
01124   register GMarshalFunc_VOID__BOXED_STRING_INT callback;
01125   register GCClosure *cc = (GCClosure*) closure;
01126   register gpointer data1, data2;
01127 
01128   g_return_if_fail (n_param_values == 4);
01129 
01130   if (G_CCLOSURE_SWAP_DATA (closure))
01131     {
01132       data1 = closure->data;
01133       data2 = g_value_peek_pointer (param_values + 0);
01134     }
01135   else
01136     {
01137       data1 = g_value_peek_pointer (param_values + 0);
01138       data2 = closure->data;
01139     }
01140   callback = (GMarshalFunc_VOID__BOXED_STRING_INT) (marshal_data ? marshal_data : cc->callback);
01141 
01142   callback (data1,
01143             g_marshal_value_peek_boxed (param_values + 1),
01144             g_marshal_value_peek_string (param_values + 2),
01145             g_marshal_value_peek_int (param_values + 3),
01146             data2);
01147 }
01148 
01149 /* VOID:BOXED,UINT (./gtkmarshalers.list:59) */
01150 void
01151 _gtk_marshal_VOID__BOXED_UINT (GClosure     *closure,
01152                                GValue       *return_value,
01153                                guint         n_param_values,
01154                                const GValue *param_values,
01155                                gpointer      invocation_hint,
01156                                gpointer      marshal_data)
01157 {
01158   typedef void (*GMarshalFunc_VOID__BOXED_UINT) (gpointer     data1,
01159                                                  gpointer     arg_1,
01160                                                  guint        arg_2,
01161                                                  gpointer     data2);
01162   register GMarshalFunc_VOID__BOXED_UINT callback;
01163   register GCClosure *cc = (GCClosure*) closure;
01164   register gpointer data1, data2;
01165 
01166   g_return_if_fail (n_param_values == 3);
01167 
01168   if (G_CCLOSURE_SWAP_DATA (closure))
01169     {
01170       data1 = closure->data;
01171       data2 = g_value_peek_pointer (param_values + 0);
01172     }
01173   else
01174     {
01175       data1 = g_value_peek_pointer (param_values + 0);
01176       data2 = closure->data;
01177     }
01178   callback = (GMarshalFunc_VOID__BOXED_UINT) (marshal_data ? marshal_data : cc->callback);
01179 
01180   callback (data1,
01181             g_marshal_value_peek_boxed (param_values + 1),
01182             g_marshal_value_peek_uint (param_values + 2),
01183             data2);
01184 }
01185 
01186 /* VOID:BOXED,UINT,FLAGS (./gtkmarshalers.list:60) */
01187 void
01188 _gtk_marshal_VOID__BOXED_UINT_FLAGS (GClosure     *closure,
01189                                      GValue       *return_value,
01190                                      guint         n_param_values,
01191                                      const GValue *param_values,
01192                                      gpointer      invocation_hint,
01193                                      gpointer      marshal_data)
01194 {
01195   typedef void (*GMarshalFunc_VOID__BOXED_UINT_FLAGS) (gpointer     data1,
01196                                                        gpointer     arg_1,
01197                                                        guint        arg_2,
01198                                                        guint        arg_3,
01199                                                        gpointer     data2);
01200   register GMarshalFunc_VOID__BOXED_UINT_FLAGS callback;
01201   register GCClosure *cc = (GCClosure*) closure;
01202   register gpointer data1, data2;
01203 
01204   g_return_if_fail (n_param_values == 4);
01205 
01206   if (G_CCLOSURE_SWAP_DATA (closure))
01207     {
01208       data1 = closure->data;
01209       data2 = g_value_peek_pointer (param_values + 0);
01210     }
01211   else
01212     {
01213       data1 = g_value_peek_pointer (param_values + 0);
01214       data2 = closure->data;
01215     }
01216   callback = (GMarshalFunc_VOID__BOXED_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
01217 
01218   callback (data1,
01219             g_marshal_value_peek_boxed (param_values + 1),
01220             g_marshal_value_peek_uint (param_values + 2),
01221             g_marshal_value_peek_flags (param_values + 3),
01222             data2);
01223 }
01224 
01225 /* VOID:BOXED,UINT,UINT (./gtkmarshalers.list:61) */
01226 void
01227 _gtk_marshal_VOID__BOXED_UINT_UINT (GClosure     *closure,
01228                                     GValue       *return_value,
01229                                     guint         n_param_values,
01230                                     const GValue *param_values,
01231                                     gpointer      invocation_hint,
01232                                     gpointer      marshal_data)
01233 {
01234   typedef void (*GMarshalFunc_VOID__BOXED_UINT_UINT) (gpointer     data1,
01235                                                       gpointer     arg_1,
01236                                                       guint        arg_2,
01237                                                       guint        arg_3,
01238                                                       gpointer     data2);
01239   register GMarshalFunc_VOID__BOXED_UINT_UINT callback;
01240   register GCClosure *cc = (GCClosure*) closure;
01241   register gpointer data1, data2;
01242 
01243   g_return_if_fail (n_param_values == 4);
01244 
01245   if (G_CCLOSURE_SWAP_DATA (closure))
01246     {
01247       data1 = closure->data;
01248       data2 = g_value_peek_pointer (param_values + 0);
01249     }
01250   else
01251     {
01252       data1 = g_value_peek_pointer (param_values + 0);
01253       data2 = closure->data;
01254     }
01255   callback = (GMarshalFunc_VOID__BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
01256 
01257   callback (data1,
01258             g_marshal_value_peek_boxed (param_values + 1),
01259             g_marshal_value_peek_uint (param_values + 2),
01260             g_marshal_value_peek_uint (param_values + 3),
01261             data2);
01262 }
01263 
01264 /* VOID:ENUM (./gtkmarshalers.list:62) */
01265 
01266 /* VOID:ENUM,BOOLEAN (./gtkmarshalers.list:63) */
01267 void
01268 _gtk_marshal_VOID__ENUM_BOOLEAN (GClosure     *closure,
01269                                  GValue       *return_value,
01270                                  guint         n_param_values,
01271                                  const GValue *param_values,
01272                                  gpointer      invocation_hint,
01273                                  gpointer      marshal_data)
01274 {
01275   typedef void (*GMarshalFunc_VOID__ENUM_BOOLEAN) (gpointer     data1,
01276                                                    gint         arg_1,
01277                                                    gboolean     arg_2,
01278                                                    gpointer     data2);
01279   register GMarshalFunc_VOID__ENUM_BOOLEAN callback;
01280   register GCClosure *cc = (GCClosure*) closure;
01281   register gpointer data1, data2;
01282 
01283   g_return_if_fail (n_param_values == 3);
01284 
01285   if (G_CCLOSURE_SWAP_DATA (closure))
01286     {
01287       data1 = closure->data;
01288       data2 = g_value_peek_pointer (param_values + 0);
01289     }
01290   else
01291     {
01292       data1 = g_value_peek_pointer (param_values + 0);
01293       data2 = closure->data;
01294     }
01295   callback = (GMarshalFunc_VOID__ENUM_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
01296 
01297   callback (data1,
01298             g_marshal_value_peek_enum (param_values + 1),
01299             g_marshal_value_peek_boolean (param_values + 2),
01300             data2);
01301 }
01302 
01303 /* VOID:ENUM,ENUM (./gtkmarshalers.list:64) */
01304 void
01305 _gtk_marshal_VOID__ENUM_ENUM (GClosure     *closure,
01306                               GValue       *return_value,
01307                               guint         n_param_values,
01308                               const GValue *param_values,
01309                               gpointer      invocation_hint,
01310                               gpointer      marshal_data)
01311 {
01312   typedef void (*GMarshalFunc_VOID__ENUM_ENUM) (gpointer     data1,
01313                                                 gint         arg_1,
01314                                                 gint         arg_2,
01315                                                 gpointer     data2);
01316   register GMarshalFunc_VOID__ENUM_ENUM callback;
01317   register GCClosure *cc = (GCClosure*) closure;
01318   register gpointer data1, data2;
01319 
01320   g_return_if_fail (n_param_values == 3);
01321 
01322   if (G_CCLOSURE_SWAP_DATA (closure))
01323     {
01324       data1 = closure->data;
01325       data2 = g_value_peek_pointer (param_values + 0);
01326     }
01327   else
01328     {
01329       data1 = g_value_peek_pointer (param_values + 0);
01330       data2 = closure->data;
01331     }
01332   callback = (GMarshalFunc_VOID__ENUM_ENUM) (marshal_data ? marshal_data : cc->callback);
01333 
01334   callback (data1,
01335             g_marshal_value_peek_enum (param_values + 1),
01336             g_marshal_value_peek_enum (param_values + 2),
01337             data2);
01338 }
01339 
01340 /* VOID:ENUM,FLOAT (./gtkmarshalers.list:65) */
01341 void
01342 _gtk_marshal_VOID__ENUM_FLOAT (GClosure     *closure,
01343                                GValue       *return_value,
01344                                guint         n_param_values,
01345                                const GValue *param_values,
01346                                gpointer      invocation_hint,
01347                                gpointer      marshal_data)
01348 {
01349   typedef void (*GMarshalFunc_VOID__ENUM_FLOAT) (gpointer     data1,
01350                                                  gint         arg_1,
01351                                                  gfloat       arg_2,
01352                                                  gpointer     data2);
01353   register GMarshalFunc_VOID__ENUM_FLOAT callback;
01354   register GCClosure *cc = (GCClosure*) closure;
01355   register gpointer data1, data2;
01356 
01357   g_return_if_fail (n_param_values == 3);
01358 
01359   if (G_CCLOSURE_SWAP_DATA (closure))
01360     {
01361       data1 = closure->data;
01362       data2 = g_value_peek_pointer (param_values + 0);
01363     }
01364   else
01365     {
01366       data1 = g_value_peek_pointer (param_values + 0);
01367       data2 = closure->data;
01368     }
01369   callback = (GMarshalFunc_VOID__ENUM_FLOAT) (marshal_data ? marshal_data : cc->callback);
01370 
01371   callback (data1,
01372             g_marshal_value_peek_enum (param_values + 1),
01373             g_marshal_value_peek_float (param_values + 2),
01374             data2);
01375 }
01376 
01377 /* VOID:ENUM,FLOAT,BOOLEAN (./gtkmarshalers.list:66) */
01378 void
01379 _gtk_marshal_VOID__ENUM_FLOAT_BOOLEAN (GClosure     *closure,
01380                                        GValue       *return_value,
01381                                        guint         n_param_values,
01382                                        const GValue *param_values,
01383                                        gpointer      invocation_hint,
01384                                        gpointer      marshal_data)
01385 {
01386   typedef void (*GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (gpointer     data1,
01387                                                          gint         arg_1,
01388                                                          gfloat       arg_2,
01389                                                          gboolean     arg_3,
01390                                                          gpointer     data2);
01391   register GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN callback;
01392   register GCClosure *cc = (GCClosure*) closure;
01393   register gpointer data1, data2;
01394 
01395   g_return_if_fail (n_param_values == 4);
01396 
01397   if (G_CCLOSURE_SWAP_DATA (closure))
01398     {
01399       data1 = closure->data;
01400       data2 = g_value_peek_pointer (param_values + 0);
01401     }
01402   else
01403     {
01404       data1 = g_value_peek_pointer (param_values + 0);
01405       data2 = closure->data;
01406     }
01407   callback = (GMarshalFunc_VOID__ENUM_FLOAT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
01408 
01409   callback (data1,
01410             g_marshal_value_peek_enum (param_values + 1),
01411             g_marshal_value_peek_float (param_values + 2),
01412             g_marshal_value_peek_boolean (param_values + 3),
01413             data2);
01414 }
01415 
01416 /* VOID:ENUM,INT (./gtkmarshalers.list:67) */
01417 void
01418 _gtk_marshal_VOID__ENUM_INT (GClosure     *closure,
01419                              GValue       *return_value,
01420                              guint         n_param_values,
01421                              const GValue *param_values,
01422                              gpointer      invocation_hint,
01423                              gpointer      marshal_data)
01424 {
01425   typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer     data1,
01426                                                gint         arg_1,
01427                                                gint         arg_2,
01428                                                gpointer     data2);
01429   register GMarshalFunc_VOID__ENUM_INT callback;
01430   register GCClosure *cc = (GCClosure*) closure;
01431   register gpointer data1, data2;
01432 
01433   g_return_if_fail (n_param_values == 3);
01434 
01435   if (G_CCLOSURE_SWAP_DATA (closure))
01436     {
01437       data1 = closure->data;
01438       data2 = g_value_peek_pointer (param_values + 0);
01439     }
01440   else
01441     {
01442       data1 = g_value_peek_pointer (param_values + 0);
01443       data2 = closure->data;
01444     }
01445   callback = (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc->callback);
01446 
01447   callback (data1,
01448             g_marshal_value_peek_enum (param_values + 1),
01449             g_marshal_value_peek_int (param_values + 2),
01450             data2);
01451 }
01452 
01453 /* VOID:ENUM,INT,BOOLEAN (./gtkmarshalers.list:68) */
01454 void
01455 _gtk_marshal_VOID__ENUM_INT_BOOLEAN (GClosure     *closure,
01456                                      GValue       *return_value,
01457                                      guint         n_param_values,
01458                                      const GValue *param_values,
01459                                      gpointer      invocation_hint,
01460                                      gpointer      marshal_data)
01461 {
01462   typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer     data1,
01463                                                        gint         arg_1,
01464                                                        gint         arg_2,
01465                                                        gboolean     arg_3,
01466                                                        gpointer     data2);
01467   register GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback;
01468   register GCClosure *cc = (GCClosure*) closure;
01469   register gpointer data1, data2;
01470 
01471   g_return_if_fail (n_param_values == 4);
01472 
01473   if (G_CCLOSURE_SWAP_DATA (closure))
01474     {
01475       data1 = closure->data;
01476       data2 = g_value_peek_pointer (param_values + 0);
01477     }
01478   else
01479     {
01480       data1 = g_value_peek_pointer (param_values + 0);
01481       data2 = closure->data;
01482     }
01483   callback = (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
01484 
01485   callback (data1,
01486             g_marshal_value_peek_enum (param_values + 1),
01487             g_marshal_value_peek_int (param_values + 2),
01488             g_marshal_value_peek_boolean (param_values + 3),
01489             data2);
01490 }
01491 
01492 /* VOID:INT (./gtkmarshalers.list:69) */
01493 
01494 /* VOID:INT,INT (./gtkmarshalers.list:70) */
01495 
01496 /* VOID:INT,INT,BOXED (./gtkmarshalers.list:71) */
01497 void
01498 _gtk_marshal_VOID__INT_INT_BOXED (GClosure     *closure,
01499                                   GValue       *return_value,
01500                                   guint         n_param_values,
01501                                   const GValue *param_values,
01502                                   gpointer      invocation_hint,
01503                                   gpointer      marshal_data)
01504 {
01505   typedef void (*GMarshalFunc_VOID__INT_INT_BOXED) (gpointer     data1,
01506                                                     gint         arg_1,
01507                                                     gint         arg_2,
01508                                                     gpointer     arg_3,
01509                                                     gpointer     data2);
01510   register GMarshalFunc_VOID__INT_INT_BOXED callback;
01511   register GCClosure *cc = (GCClosure*) closure;
01512   register gpointer data1, data2;
01513 
01514   g_return_if_fail (n_param_values == 4);
01515 
01516   if (G_CCLOSURE_SWAP_DATA (closure))
01517     {
01518       data1 = closure->data;
01519       data2 = g_value_peek_pointer (param_values + 0);
01520     }
01521   else
01522     {
01523       data1 = g_value_peek_pointer (param_values + 0);
01524       data2 = closure->data;
01525     }
01526   callback = (GMarshalFunc_VOID__INT_INT_BOXED) (marshal_data ? marshal_data : cc->callback);
01527 
01528   callback (data1,
01529             g_marshal_value_peek_int (param_values + 1),
01530             g_marshal_value_peek_int (param_values + 2),
01531             g_marshal_value_peek_boxed (param_values + 3),
01532             data2);
01533 }
01534 
01535 /* VOID:INT,INT,INT (./gtkmarshalers.list:72) */
01536 void
01537 _gtk_marshal_VOID__INT_INT_INT (GClosure     *closure,
01538                                 GValue       *return_value,
01539                                 guint         n_param_values,
01540                                 const GValue *param_values,
01541                                 gpointer      invocation_hint,
01542                                 gpointer      marshal_data)
01543 {
01544   typedef void (*GMarshalFunc_VOID__INT_INT_INT) (gpointer     data1,
01545                                                   gint         arg_1,
01546                                                   gint         arg_2,
01547                                                   gint         arg_3,
01548                                                   gpointer     data2);
01549   register GMarshalFunc_VOID__INT_INT_INT callback;
01550   register GCClosure *cc = (GCClosure*) closure;
01551   register gpointer data1, data2;
01552 
01553   g_return_if_fail (n_param_values == 4);
01554 
01555   if (G_CCLOSURE_SWAP_DATA (closure))
01556     {
01557       data1 = closure->data;
01558       data2 = g_value_peek_pointer (param_values + 0);
01559     }
01560   else
01561     {
01562       data1 = g_value_peek_pointer (param_values + 0);
01563       data2 = closure->data;
01564     }
01565   callback = (GMarshalFunc_VOID__INT_INT_INT) (marshal_data ? marshal_data : cc->callback);
01566 
01567   callback (data1,
01568             g_marshal_value_peek_int (param_values + 1),
01569             g_marshal_value_peek_int (param_values + 2),
01570             g_marshal_value_peek_int (param_values + 3),
01571             data2);
01572 }
01573 
01574 /* VOID:OBJECT (./gtkmarshalers.list:73) */
01575 
01576 /* VOID:OBJECT,BOOLEAN (./gtkmarshalers.list:74) */
01577 void
01578 _gtk_marshal_VOID__OBJECT_BOOLEAN (GClosure     *closure,
01579                                    GValue       *return_value,
01580                                    guint         n_param_values,
01581                                    const GValue *param_values,
01582                                    gpointer      invocation_hint,
01583                                    gpointer      marshal_data)
01584 {
01585   typedef void (*GMarshalFunc_VOID__OBJECT_BOOLEAN) (gpointer     data1,
01586                                                      gpointer     arg_1,
01587                                                      gboolean     arg_2,
01588                                                      gpointer     data2);
01589   register GMarshalFunc_VOID__OBJECT_BOOLEAN callback;
01590   register GCClosure *cc = (GCClosure*) closure;
01591   register gpointer data1, data2;
01592 
01593   g_return_if_fail (n_param_values == 3);
01594 
01595   if (G_CCLOSURE_SWAP_DATA (closure))
01596     {
01597       data1 = closure->data;
01598       data2 = g_value_peek_pointer (param_values + 0);
01599     }
01600   else
01601     {
01602       data1 = g_value_peek_pointer (param_values + 0);
01603       data2 = closure->data;
01604     }
01605   callback = (GMarshalFunc_VOID__OBJECT_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
01606 
01607   callback (data1,
01608             g_marshal_value_peek_object (param_values + 1),
01609             g_marshal_value_peek_boolean (param_values + 2),
01610             data2);
01611 }
01612 
01613 /* VOID:OBJECT,BOXED,BOXED (./gtkmarshalers.list:75) */
01614 void
01615 _gtk_marshal_VOID__OBJECT_BOXED_BOXED (GClosure     *closure,
01616                                        GValue       *return_value,
01617                                        guint         n_param_values,
01618                                        const GValue *param_values,
01619                                        gpointer      invocation_hint,
01620                                        gpointer      marshal_data)
01621 {
01622   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (gpointer     data1,
01623                                                          gpointer     arg_1,
01624                                                          gpointer     arg_2,
01625                                                          gpointer     arg_3,
01626                                                          gpointer     data2);
01627   register GMarshalFunc_VOID__OBJECT_BOXED_BOXED callback;
01628   register GCClosure *cc = (GCClosure*) closure;
01629   register gpointer data1, data2;
01630 
01631   g_return_if_fail (n_param_values == 4);
01632 
01633   if (G_CCLOSURE_SWAP_DATA (closure))
01634     {
01635       data1 = closure->data;
01636       data2 = g_value_peek_pointer (param_values + 0);
01637     }
01638   else
01639     {
01640       data1 = g_value_peek_pointer (param_values + 0);
01641       data2 = closure->data;
01642     }
01643   callback = (GMarshalFunc_VOID__OBJECT_BOXED_BOXED) (marshal_data ? marshal_data : cc->callback);
01644 
01645   callback (data1,
01646             g_marshal_value_peek_object (param_values + 1),
01647             g_marshal_value_peek_boxed (param_values + 2),
01648             g_marshal_value_peek_boxed (param_values + 3),
01649             data2);
01650 }
01651 
01652 /* VOID:OBJECT,BOXED,UINT,UINT (./gtkmarshalers.list:76) */
01653 void
01654 _gtk_marshal_VOID__OBJECT_BOXED_UINT_UINT (GClosure     *closure,
01655                                            GValue       *return_value,
01656                                            guint         n_param_values,
01657                                            const GValue *param_values,
01658                                            gpointer      invocation_hint,
01659                                            gpointer      marshal_data)
01660 {
01661   typedef void (*GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (gpointer     data1,
01662                                                              gpointer     arg_1,
01663                                                              gpointer     arg_2,
01664                                                              guint        arg_3,
01665                                                              guint        arg_4,
01666                                                              gpointer     data2);
01667   register GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT callback;
01668   register GCClosure *cc = (GCClosure*) closure;
01669   register gpointer data1, data2;
01670 
01671   g_return_if_fail (n_param_values == 5);
01672 
01673   if (G_CCLOSURE_SWAP_DATA (closure))
01674     {
01675       data1 = closure->data;
01676       data2 = g_value_peek_pointer (param_values + 0);
01677     }
01678   else
01679     {
01680       data1 = g_value_peek_pointer (param_values + 0);
01681       data2 = closure->data;
01682     }
01683   callback = (GMarshalFunc_VOID__OBJECT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
01684 
01685   callback (data1,
01686             g_marshal_value_peek_object (param_values + 1),
01687             g_marshal_value_peek_boxed (param_values + 2),
01688             g_marshal_value_peek_uint (param_values + 3),
01689             g_marshal_value_peek_uint (param_values + 4),
01690             data2);
01691 }
01692 
01693 /* VOID:OBJECT,INT,INT (./gtkmarshalers.list:77) */
01694 void
01695 _gtk_marshal_VOID__OBJECT_INT_INT (GClosure     *closure,
01696                                    GValue       *return_value,
01697                                    guint         n_param_values,
01698                                    const GValue *param_values,
01699                                    gpointer      invocation_hint,
01700                                    gpointer      marshal_data)
01701 {
01702   typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT) (gpointer     data1,
01703                                                      gpointer     arg_1,
01704                                                      gint         arg_2,
01705                                                      gint         arg_3,
01706                                                      gpointer     data2);
01707   register GMarshalFunc_VOID__OBJECT_INT_INT callback;
01708   register GCClosure *cc = (GCClosure*) closure;
01709   register gpointer data1, data2;
01710 
01711   g_return_if_fail (n_param_values == 4);
01712 
01713   if (G_CCLOSURE_SWAP_DATA (closure))
01714     {
01715       data1 = closure->data;
01716       data2 = g_value_peek_pointer (param_values + 0);
01717     }
01718   else
01719     {
01720       data1 = g_value_peek_pointer (param_values + 0);
01721       data2 = closure->data;
01722     }
01723   callback = (GMarshalFunc_VOID__OBJECT_INT_INT) (marshal_data ? marshal_data : cc->callback);
01724 
01725   callback (data1,
01726             g_marshal_value_peek_object (param_values + 1),
01727             g_marshal_value_peek_int (param_values + 2),
01728             g_marshal_value_peek_int (param_values + 3),
01729             data2);
01730 }
01731 
01732 /* VOID:OBJECT,INT,INT,BOXED,UINT,UINT (./gtkmarshalers.list:78) */
01733 void
01734 _gtk_marshal_VOID__OBJECT_INT_INT_BOXED_UINT_UINT (GClosure     *closure,
01735                                                    GValue       *return_value,
01736                                                    guint         n_param_values,
01737                                                    const GValue *param_values,
01738                                                    gpointer      invocation_hint,
01739                                                    gpointer      marshal_data)
01740 {
01741   typedef void (*GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (gpointer     data1,
01742                                                                      gpointer     arg_1,
01743                                                                      gint         arg_2,
01744                                                                      gint         arg_3,
01745                                                                      gpointer     arg_4,
01746                                                                      guint        arg_5,
01747                                                                      guint        arg_6,
01748                                                                      gpointer     data2);
01749   register GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT callback;
01750   register GCClosure *cc = (GCClosure*) closure;
01751   register gpointer data1, data2;
01752 
01753   g_return_if_fail (n_param_values == 7);
01754 
01755   if (G_CCLOSURE_SWAP_DATA (closure))
01756     {
01757       data1 = closure->data;
01758       data2 = g_value_peek_pointer (param_values + 0);
01759     }
01760   else
01761     {
01762       data1 = g_value_peek_pointer (param_values + 0);
01763       data2 = closure->data;
01764     }
01765   callback = (GMarshalFunc_VOID__OBJECT_INT_INT_BOXED_UINT_UINT) (marshal_data ? marshal_data : cc->callback);
01766 
01767   callback (data1,
01768             g_marshal_value_peek_object (param_values + 1),
01769             g_marshal_value_peek_int (param_values + 2),
01770             g_marshal_value_peek_int (param_values + 3),
01771             g_marshal_value_peek_boxed (param_values + 4),
01772             g_marshal_value_peek_uint (param_values + 5),
01773             g_marshal_value_peek_uint (param_values + 6),
01774             data2);
01775 }
01776 
01777 /* VOID:OBJECT,OBJECT (./gtkmarshalers.list:79) */
01778 void
01779 _gtk_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
01780                                   GValue       *return_value,
01781                                   guint         n_param_values,
01782                                   const GValue *param_values,
01783                                   gpointer      invocation_hint,
01784                                   gpointer      marshal_data)
01785 {
01786   typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT) (gpointer     data1,
01787                                                     gpointer     arg_1,
01788                                                     gpointer     arg_2,
01789                                                     gpointer     data2);
01790   register GMarshalFunc_VOID__OBJECT_OBJECT callback;
01791   register GCClosure *cc = (GCClosure*) closure;
01792   register gpointer data1, data2;
01793 
01794   g_return_if_fail (n_param_values == 3);
01795 
01796   if (G_CCLOSURE_SWAP_DATA (closure))
01797     {
01798       data1 = closure->data;
01799       data2 = g_value_peek_pointer (param_values + 0);
01800     }
01801   else
01802     {
01803       data1 = g_value_peek_pointer (param_values + 0);
01804       data2 = closure->data;
01805     }
01806   callback = (GMarshalFunc_VOID__OBJECT_OBJECT) (marshal_data ? marshal_data : cc->callback);
01807 
01808   callback (data1,
01809             g_marshal_value_peek_object (param_values + 1),
01810             g_marshal_value_peek_object (param_values + 2),
01811             data2);
01812 }
01813 
01814 /* VOID:OBJECT,STRING,STRING (./gtkmarshalers.list:80) */
01815 void
01816 _gtk_marshal_VOID__OBJECT_STRING_STRING (GClosure     *closure,
01817                                          GValue       *return_value,
01818                                          guint         n_param_values,
01819                                          const GValue *param_values,
01820                                          gpointer      invocation_hint,
01821                                          gpointer      marshal_data)
01822 {
01823   typedef void (*GMarshalFunc_VOID__OBJECT_STRING_STRING) (gpointer     data1,
01824                                                            gpointer     arg_1,
01825                                                            gpointer     arg_2,
01826                                                            gpointer     arg_3,
01827                                                            gpointer     data2);
01828   register GMarshalFunc_VOID__OBJECT_STRING_STRING callback;
01829   register GCClosure *cc = (GCClosure*) closure;
01830   register gpointer data1, data2;
01831 
01832   g_return_if_fail (n_param_values == 4);
01833 
01834   if (G_CCLOSURE_SWAP_DATA (closure))
01835     {
01836       data1 = closure->data;
01837       data2 = g_value_peek_pointer (param_values + 0);
01838     }
01839   else
01840     {
01841       data1 = g_value_peek_pointer (param_values + 0);
01842       data2 = closure->data;
01843     }
01844   callback = (GMarshalFunc_VOID__OBJECT_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
01845 
01846   callback (data1,
01847             g_marshal_value_peek_object (param_values + 1),
01848             g_marshal_value_peek_string (param_values + 2),
01849             g_marshal_value_peek_string (param_values + 3),
01850             data2);
01851 }
01852 
01853 /* VOID:OBJECT,UINT (./gtkmarshalers.list:81) */
01854 void
01855 _gtk_marshal_VOID__OBJECT_UINT (GClosure     *closure,
01856                                 GValue       *return_value,
01857                                 guint         n_param_values,
01858                                 const GValue *param_values,
01859                                 gpointer      invocation_hint,
01860                                 gpointer      marshal_data)
01861 {
01862   typedef void (*GMarshalFunc_VOID__OBJECT_UINT) (gpointer     data1,
01863                                                   gpointer     arg_1,
01864                                                   guint        arg_2,
01865                                                   gpointer     data2);
01866   register GMarshalFunc_VOID__OBJECT_UINT callback;
01867   register GCClosure *cc = (GCClosure*) closure;
01868   register gpointer data1, data2;
01869 
01870   g_return_if_fail (n_param_values == 3);
01871 
01872   if (G_CCLOSURE_SWAP_DATA (closure))
01873     {
01874       data1 = closure->data;
01875       data2 = g_value_peek_pointer (param_values + 0);
01876     }
01877   else
01878     {
01879       data1 = g_value_peek_pointer (param_values + 0);
01880       data2 = closure->data;
01881     }
01882   callback = (GMarshalFunc_VOID__OBJECT_UINT) (marshal_data ? marshal_data : cc->callback);
01883 
01884   callback (data1,
01885             g_marshal_value_peek_object (param_values + 1),
01886             g_marshal_value_peek_uint (param_values + 2),
01887             data2);
01888 }
01889 
01890 /* VOID:OBJECT,UINT,FLAGS (./gtkmarshalers.list:82) */
01891 void
01892 _gtk_marshal_VOID__OBJECT_UINT_FLAGS (GClosure     *closure,
01893                                       GValue       *return_value,
01894                                       guint         n_param_values,
01895                                       const GValue *param_values,
01896                                       gpointer      invocation_hint,
01897                                       gpointer      marshal_data)
01898 {
01899   typedef void (*GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (gpointer     data1,
01900                                                         gpointer     arg_1,
01901                                                         guint        arg_2,
01902                                                         guint        arg_3,
01903                                                         gpointer     data2);
01904   register GMarshalFunc_VOID__OBJECT_UINT_FLAGS callback;
01905   register GCClosure *cc = (GCClosure*) closure;
01906   register gpointer data1, data2;
01907 
01908   g_return_if_fail (n_param_values == 4);
01909 
01910   if (G_CCLOSURE_SWAP_DATA (closure))
01911     {
01912       data1 = closure->data;
01913       data2 = g_value_peek_pointer (param_values + 0);
01914     }
01915   else
01916     {
01917       data1 = g_value_peek_pointer (param_values + 0);
01918       data2 = closure->data;
01919     }
01920   callback = (GMarshalFunc_VOID__OBJECT_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
01921 
01922   callback (data1,
01923             g_marshal_value_peek_object (param_values + 1),
01924             g_marshal_value_peek_uint (param_values + 2),
01925             g_marshal_value_peek_flags (param_values + 3),
01926             data2);
01927 }
01928 
01929 /* VOID:POINTER (./gtkmarshalers.list:83) */
01930 
01931 /* VOID:POINTER,INT (./gtkmarshalers.list:84) */
01932 void
01933 _gtk_marshal_VOID__POINTER_INT (GClosure     *closure,
01934                                 GValue       *return_value,
01935                                 guint         n_param_values,
01936                                 const GValue *param_values,
01937                                 gpointer      invocation_hint,
01938                                 gpointer      marshal_data)
01939 {
01940   typedef void (*GMarshalFunc_VOID__POINTER_INT) (gpointer     data1,
01941                                                   gpointer     arg_1,
01942                                                   gint         arg_2,
01943                                                   gpointer     data2);
01944   register GMarshalFunc_VOID__POINTER_INT callback;
01945   register GCClosure *cc = (GCClosure*) closure;
01946   register gpointer data1, data2;
01947 
01948   g_return_if_fail (n_param_values == 3);
01949 
01950   if (G_CCLOSURE_SWAP_DATA (closure))
01951     {
01952       data1 = closure->data;
01953       data2 = g_value_peek_pointer (param_values + 0);
01954     }
01955   else
01956     {
01957       data1 = g_value_peek_pointer (param_values + 0);
01958       data2 = closure->data;
01959     }
01960   callback = (GMarshalFunc_VOID__POINTER_INT) (marshal_data ? marshal_data : cc->callback);
01961 
01962   callback (data1,
01963             g_marshal_value_peek_pointer (param_values + 1),
01964             g_marshal_value_peek_int (param_values + 2),
01965             data2);
01966 }
01967 
01968 /* VOID:POINTER,BOOLEAN (./gtkmarshalers.list:85) */
01969 void
01970 _gtk_marshal_VOID__POINTER_BOOLEAN (GClosure     *closure,
01971                                     GValue       *return_value,
01972                                     guint         n_param_values,
01973                                     const GValue *param_values,
01974                                     gpointer      invocation_hint,
01975                                     gpointer      marshal_data)
01976 {
01977   typedef void (*GMarshalFunc_VOID__POINTER_BOOLEAN) (gpointer     data1,
01978                                                       gpointer     arg_1,
01979                                                       gboolean     arg_2,
01980                                                       gpointer     data2);
01981   register GMarshalFunc_VOID__POINTER_BOOLEAN callback;
01982   register GCClosure *cc = (GCClosure*) closure;
01983   register gpointer data1, data2;
01984 
01985   g_return_if_fail (n_param_values == 3);
01986 
01987   if (G_CCLOSURE_SWAP_DATA (closure))
01988     {
01989       data1 = closure->data;
01990       data2 = g_value_peek_pointer (param_values + 0);
01991     }
01992   else
01993     {
01994       data1 = g_value_peek_pointer (param_values + 0);
01995       data2 = closure->data;
01996     }
01997   callback = (GMarshalFunc_VOID__POINTER_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
01998 
01999   callback (data1,
02000             g_marshal_value_peek_pointer (param_values + 1),
02001             g_marshal_value_peek_boolean (param_values + 2),
02002             data2);
02003 }
02004 
02005 /* VOID:POINTER,POINTER,POINTER (./gtkmarshalers.list:86) */
02006 void
02007 _gtk_marshal_VOID__POINTER_POINTER_POINTER (GClosure     *closure,
02008                                             GValue       *return_value,
02009                                             guint         n_param_values,
02010                                             const GValue *param_values,
02011                                             gpointer      invocation_hint,
02012                                             gpointer      marshal_data)
02013 {
02014   typedef void (*GMarshalFunc_VOID__POINTER_POINTER_POINTER) (gpointer     data1,
02015                                                               gpointer     arg_1,
02016                                                               gpointer     arg_2,
02017                                                               gpointer     arg_3,
02018                                                               gpointer     data2);
02019   register GMarshalFunc_VOID__POINTER_POINTER_POINTER callback;
02020   register GCClosure *cc = (GCClosure*) closure;
02021   register gpointer data1, data2;
02022 
02023   g_return_if_fail (n_param_values == 4);
02024 
02025   if (G_CCLOSURE_SWAP_DATA (closure))
02026     {
02027       data1 = closure->data;
02028       data2 = g_value_peek_pointer (param_values + 0);
02029     }
02030   else
02031     {
02032       data1 = g_value_peek_pointer (param_values + 0);
02033       data2 = closure->data;
02034     }
02035   callback = (GMarshalFunc_VOID__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
02036 
02037   callback (data1,
02038             g_marshal_value_peek_pointer (param_values + 1),
02039             g_marshal_value_peek_pointer (param_values + 2),
02040             g_marshal_value_peek_pointer (param_values + 3),
02041             data2);
02042 }
02043 
02044 /* VOID:POINTER,UINT (./gtkmarshalers.list:87) */
02045 void
02046 _gtk_marshal_VOID__POINTER_UINT (GClosure     *closure,
02047                                  GValue       *return_value,
02048                                  guint         n_param_values,
02049                                  const GValue *param_values,
02050                                  gpointer      invocation_hint,
02051                                  gpointer      marshal_data)
02052 {
02053   typedef void (*GMarshalFunc_VOID__POINTER_UINT) (gpointer     data1,
02054                                                    gpointer     arg_1,
02055                                                    guint        arg_2,
02056                                                    gpointer     data2);
02057   register GMarshalFunc_VOID__POINTER_UINT callback;
02058   register GCClosure *cc = (GCClosure*) closure;
02059   register gpointer data1, data2;
02060 
02061   g_return_if_fail (n_param_values == 3);
02062 
02063   if (G_CCLOSURE_SWAP_DATA (closure))
02064     {
02065       data1 = closure->data;
02066       data2 = g_value_peek_pointer (param_values + 0);
02067     }
02068   else
02069     {
02070       data1 = g_value_peek_pointer (param_values + 0);
02071       data2 = closure->data;
02072     }
02073   callback = (GMarshalFunc_VOID__POINTER_UINT) (marshal_data ? marshal_data : cc->callback);
02074 
02075   callback (data1,
02076             g_marshal_value_peek_pointer (param_values + 1),
02077             g_marshal_value_peek_uint (param_values + 2),
02078             data2);
02079 }
02080 
02081 /* VOID:STRING (./gtkmarshalers.list:88) */
02082 
02083 /* VOID:STRING,STRING (./gtkmarshalers.list:89) */
02084 void
02085 _gtk_marshal_VOID__STRING_STRING (GClosure     *closure,
02086                                   GValue       *return_value,
02087                                   guint         n_param_values,
02088                                   const GValue *param_values,
02089                                   gpointer      invocation_hint,
02090                                   gpointer      marshal_data)
02091 {
02092   typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer     data1,
02093                                                     gpointer     arg_1,
02094                                                     gpointer     arg_2,
02095                                                     gpointer     data2);
02096   register GMarshalFunc_VOID__STRING_STRING callback;
02097   register GCClosure *cc = (GCClosure*) closure;
02098   register gpointer data1, data2;
02099 
02100   g_return_if_fail (n_param_values == 3);
02101 
02102   if (G_CCLOSURE_SWAP_DATA (closure))
02103     {
02104       data1 = closure->data;
02105       data2 = g_value_peek_pointer (param_values + 0);
02106     }
02107   else
02108     {
02109       data1 = g_value_peek_pointer (param_values + 0);
02110       data2 = closure->data;
02111     }
02112   callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
02113 
02114   callback (data1,
02115             g_marshal_value_peek_string (param_values + 1),
02116             g_marshal_value_peek_string (param_values + 2),
02117             data2);
02118 }
02119 
02120 /* VOID:STRING,INT,POINTER (./gtkmarshalers.list:90) */
02121 
02122 /* VOID:STRING,UINT,FLAGS (./gtkmarshalers.list:91) */
02123 void
02124 _gtk_marshal_VOID__STRING_UINT_FLAGS (GClosure     *closure,
02125                                       GValue       *return_value,
02126                                       guint         n_param_values,
02127                                       const GValue *param_values,
02128                                       gpointer      invocation_hint,
02129                                       gpointer      marshal_data)
02130 {
02131   typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS) (gpointer     data1,
02132                                                         gpointer     arg_1,
02133                                                         guint        arg_2,
02134                                                         guint        arg_3,
02135                                                         gpointer     data2);
02136   register GMarshalFunc_VOID__STRING_UINT_FLAGS callback;
02137   register GCClosure *cc = (GCClosure*) closure;
02138   register gpointer data1, data2;
02139 
02140   g_return_if_fail (n_param_values == 4);
02141 
02142   if (G_CCLOSURE_SWAP_DATA (closure))
02143     {
02144       data1 = closure->data;
02145       data2 = g_value_peek_pointer (param_values + 0);
02146     }
02147   else
02148     {
02149       data1 = g_value_peek_pointer (param_values + 0);
02150       data2 = closure->data;
02151     }
02152   callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS) (marshal_data ? marshal_data : cc->callback);
02153 
02154   callback (data1,
02155             g_marshal_value_peek_string (param_values + 1),
02156             g_marshal_value_peek_uint (param_values + 2),
02157             g_marshal_value_peek_flags (param_values + 3),
02158             data2);
02159 }
02160 
02161 /* VOID:UINT,FLAGS,BOXED (./gtkmarshalers.list:92) */
02162 void
02163 _gtk_marshal_VOID__UINT_FLAGS_BOXED (GClosure     *closure,
02164                                      GValue       *return_value,
02165                                      guint         n_param_values,
02166                                      const GValue *param_values,
02167                                      gpointer      invocation_hint,
02168                                      gpointer      marshal_data)
02169 {
02170   typedef void (*GMarshalFunc_VOID__UINT_FLAGS_BOXED) (gpointer     data1,
02171                                                        guint        arg_1,
02172                                                        guint        arg_2,
02173                                                        gpointer     arg_3,
02174                                                        gpointer     data2);
02175   register GMarshalFunc_VOID__UINT_FLAGS_BOXED callback;
02176   register GCClosure *cc = (GCClosure*) closure;
02177   register gpointer data1, data2;
02178 
02179   g_return_if_fail (n_param_values == 4);
02180 
02181   if (G_CCLOSURE_SWAP_DATA (closure))
02182     {
02183       data1 = closure->data;
02184       data2 = g_value_peek_pointer (param_values + 0);
02185     }
02186   else
02187     {
02188       data1 = g_value_peek_pointer (param_values + 0);
02189       data2 = closure->data;
02190     }
02191   callback = (GMarshalFunc_VOID__UINT_FLAGS_BOXED) (marshal_data ? marshal_data : cc->callback);
02192 
02193   callback (data1,
02194             g_marshal_value_peek_uint (param_values + 1),
02195             g_marshal_value_peek_flags (param_values + 2),
02196             g_marshal_value_peek_boxed (param_values + 3),
02197             data2);
02198 }
02199 
02200 /* VOID:UINT,UINT (./gtkmarshalers.list:93) */
02201 void
02202 _gtk_marshal_VOID__UINT_UINT (GClosure     *closure,
02203                               GValue       *return_value,
02204                               guint         n_param_values,
02205                               const GValue *param_values,
02206                               gpointer      invocation_hint,
02207                               gpointer      marshal_data)
02208 {
02209   typedef void (*GMarshalFunc_VOID__UINT_UINT) (gpointer     data1,
02210                                                 guint        arg_1,
02211                                                 guint        arg_2,
02212                                                 gpointer     data2);
02213   register GMarshalFunc_VOID__UINT_UINT callback;
02214   register GCClosure *cc = (GCClosure*) closure;
02215   register gpointer data1, data2;
02216 
02217   g_return_if_fail (n_param_values == 3);
02218 
02219   if (G_CCLOSURE_SWAP_DATA (closure))
02220     {
02221       data1 = closure->data;
02222       data2 = g_value_peek_pointer (param_values + 0);
02223     }
02224   else
02225     {
02226       data1 = g_value_peek_pointer (param_values + 0);
02227       data2 = closure->data;
02228     }
02229   callback = (GMarshalFunc_VOID__UINT_UINT) (marshal_data ? marshal_data : cc->callback);
02230 
02231   callback (data1,
02232             g_marshal_value_peek_uint (param_values + 1),
02233             g_marshal_value_peek_uint (param_values + 2),
02234             data2);
02235 }
02236 
02237 /* VOID:UINT,STRING (./gtkmarshalers.list:94) */
02238 void
02239 _gtk_marshal_VOID__UINT_STRING (GClosure     *closure,
02240                                 GValue       *return_value,
02241                                 guint         n_param_values,
02242                                 const GValue *param_values,
02243                                 gpointer      invocation_hint,
02244                                 gpointer      marshal_data)
02245 {
02246   typedef void (*GMarshalFunc_VOID__UINT_STRING) (gpointer     data1,
02247                                                   guint        arg_1,
02248                                                   gpointer     arg_2,
02249                                                   gpointer     data2);
02250   register GMarshalFunc_VOID__UINT_STRING callback;
02251   register GCClosure *cc = (GCClosure*) closure;
02252   register gpointer data1, data2;
02253 
02254   g_return_if_fail (n_param_values == 3);
02255 
02256   if (G_CCLOSURE_SWAP_DATA (closure))
02257     {
02258       data1 = closure->data;
02259       data2 = g_value_peek_pointer (param_values + 0);
02260     }
02261   else
02262     {
02263       data1 = g_value_peek_pointer (param_values + 0);
02264       data2 = closure->data;
02265     }
02266   callback = (GMarshalFunc_VOID__UINT_STRING) (marshal_data ? marshal_data : cc->callback);
02267 
02268   callback (data1,
02269             g_marshal_value_peek_uint (param_values + 1),
02270             g_marshal_value_peek_string (param_values + 2),
02271             data2);
02272 }
02273 
02274 /* VOID:UINT,BOXED,UINT,FLAGS,FLAGS (./gtkmarshalers.list:95) */
02275 void
02276 _gtk_marshal_VOID__UINT_BOXED_UINT_FLAGS_FLAGS (GClosure     *closure,
02277                                                 GValue       *return_value,
02278                                                 guint         n_param_values,
02279                                                 const GValue *param_values,
02280                                                 gpointer      invocation_hint,
02281                                                 gpointer      marshal_data)
02282 {
02283   typedef void (*GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (gpointer     data1,
02284                                                                   guint        arg_1,
02285                                                                   gpointer     arg_2,
02286                                                                   guint        arg_3,
02287                                                                   guint        arg_4,
02288                                                                   guint        arg_5,
02289                                                                   gpointer     data2);
02290   register GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS callback;
02291   register GCClosure *cc = (GCClosure*) closure;
02292   register gpointer data1, data2;
02293 
02294   g_return_if_fail (n_param_values == 6);
02295 
02296   if (G_CCLOSURE_SWAP_DATA (closure))
02297     {
02298       data1 = closure->data;
02299       data2 = g_value_peek_pointer (param_values + 0);
02300     }
02301   else
02302     {
02303       data1 = g_value_peek_pointer (param_values + 0);
02304       data2 = closure->data;
02305     }
02306   callback = (GMarshalFunc_VOID__UINT_BOXED_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
02307 
02308   callback (data1,
02309             g_marshal_value_peek_uint (param_values + 1),
02310             g_marshal_value_peek_boxed (param_values + 2),
02311             g_marshal_value_peek_uint (param_values + 3),
02312             g_marshal_value_peek_flags (param_values + 4),
02313             g_marshal_value_peek_flags (param_values + 5),
02314             data2);
02315 }
02316 
02317 /* VOID:UINT,OBJECT,UINT,FLAGS,FLAGS (./gtkmarshalers.list:96) */
02318 void
02319 _gtk_marshal_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS (GClosure     *closure,
02320                                                  GValue       *return_value,
02321                                                  guint         n_param_values,
02322                                                  const GValue *param_values,
02323                                                  gpointer      invocation_hint,
02324                                                  gpointer      marshal_data)
02325 {
02326   typedef void (*GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (gpointer     data1,
02327                                                                    guint        arg_1,
02328                                                                    gpointer     arg_2,
02329                                                                    guint        arg_3,
02330                                                                    guint        arg_4,
02331                                                                    guint        arg_5,
02332                                                                    gpointer     data2);
02333   register GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS callback;
02334   register GCClosure *cc = (GCClosure*) closure;
02335   register gpointer data1, data2;
02336 
02337   g_return_if_fail (n_param_values == 6);
02338 
02339   if (G_CCLOSURE_SWAP_DATA (closure))
02340     {
02341       data1 = closure->data;
02342       data2 = g_value_peek_pointer (param_values + 0);
02343     }
02344   else
02345     {
02346       data1 = g_value_peek_pointer (param_values + 0);
02347       data2 = closure->data;
02348     }
02349   callback = (GMarshalFunc_VOID__UINT_OBJECT_UINT_FLAGS_FLAGS) (marshal_data ? marshal_data : cc->callback);
02350 
02351   callback (data1,
02352             g_marshal_value_peek_uint (param_values + 1),
02353             g_marshal_value_peek_object (param_values + 2),
02354             g_marshal_value_peek_uint (param_values + 3),
02355             g_marshal_value_peek_flags (param_values + 4),
02356             g_marshal_value_peek_flags (param_values + 5),
02357             data2);
02358 }
02359 
02360 /* VOID:VOID (./gtkmarshalers.list:97) */
02361
Generated on Sat Apr 1 09:03:56 2006 for GXSM by  doxygen 1.4.6