Back to index

lightdm  1.3.2
ldm-marshal.c
Go to the documentation of this file.
00001 
00002 #ifndef __ldm_marshal_MARSHAL_H__
00003 #define __ldm_marshal_MARSHAL_H__
00004 
00005 #include      <glib-object.h>
00006 
00007 G_BEGIN_DECLS
00008 
00009 #ifdef G_ENABLE_DEBUG
00010 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
00011 #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
00012 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
00013 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
00014 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
00015 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
00016 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
00017 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
00018 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
00019 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
00020 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
00021 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
00022 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
00023 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
00024 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
00025 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
00026 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
00027 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
00028 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
00029 #else /* !G_ENABLE_DEBUG */
00030 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
00031  *          Do not access GValues directly in your code. Instead, use the
00032  *          g_value_get_*() functions
00033  */
00034 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
00035 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
00036 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
00037 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
00038 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
00039 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
00040 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
00041 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
00042 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
00043 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
00044 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
00045 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
00046 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
00047 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
00048 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
00049 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
00050 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
00051 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
00052 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
00053 #endif /* !G_ENABLE_DEBUG */
00054 
00055 
00056 /* VOID:INT,POINTER (./ldm-marshal.list:1) */
00057 extern void ldm_marshal_VOID__INT_POINTER (GClosure     *closure,
00058                                            GValue       *return_value,
00059                                            guint         n_param_values,
00060                                            const GValue *param_values,
00061                                            gpointer      invocation_hint,
00062                                            gpointer      marshal_data);
00063 void
00064 ldm_marshal_VOID__INT_POINTER (GClosure     *closure,
00065                                GValue       *return_value G_GNUC_UNUSED,
00066                                guint         n_param_values,
00067                                const GValue *param_values,
00068                                gpointer      invocation_hint G_GNUC_UNUSED,
00069                                gpointer      marshal_data)
00070 {
00071   typedef void (*GMarshalFunc_VOID__INT_POINTER) (gpointer     data1,
00072                                                   gint         arg_1,
00073                                                   gpointer     arg_2,
00074                                                   gpointer     data2);
00075   register GMarshalFunc_VOID__INT_POINTER callback;
00076   register GCClosure *cc = (GCClosure*) closure;
00077   register gpointer data1, data2;
00078 
00079   g_return_if_fail (n_param_values == 3);
00080 
00081   if (G_CCLOSURE_SWAP_DATA (closure))
00082     {
00083       data1 = closure->data;
00084       data2 = g_value_peek_pointer (param_values + 0);
00085     }
00086   else
00087     {
00088       data1 = g_value_peek_pointer (param_values + 0);
00089       data2 = closure->data;
00090     }
00091   callback = (GMarshalFunc_VOID__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00092 
00093   callback (data1,
00094             g_marshal_value_peek_int (param_values + 1),
00095             g_marshal_value_peek_pointer (param_values + 2),
00096             data2);
00097 }
00098 
00099 /* BOOLEAN:VOID (./ldm-marshal.list:2) */
00100 extern void ldm_marshal_BOOLEAN__VOID (GClosure     *closure,
00101                                        GValue       *return_value,
00102                                        guint         n_param_values,
00103                                        const GValue *param_values,
00104                                        gpointer      invocation_hint,
00105                                        gpointer      marshal_data);
00106 void
00107 ldm_marshal_BOOLEAN__VOID (GClosure     *closure,
00108                            GValue       *return_value G_GNUC_UNUSED,
00109                            guint         n_param_values,
00110                            const GValue *param_values,
00111                            gpointer      invocation_hint G_GNUC_UNUSED,
00112                            gpointer      marshal_data)
00113 {
00114   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
00115                                                   gpointer     data2);
00116   register GMarshalFunc_BOOLEAN__VOID callback;
00117   register GCClosure *cc = (GCClosure*) closure;
00118   register gpointer data1, data2;
00119   gboolean v_return;
00120 
00121   g_return_if_fail (return_value != NULL);
00122   g_return_if_fail (n_param_values == 1);
00123 
00124   if (G_CCLOSURE_SWAP_DATA (closure))
00125     {
00126       data1 = closure->data;
00127       data2 = g_value_peek_pointer (param_values + 0);
00128     }
00129   else
00130     {
00131       data1 = g_value_peek_pointer (param_values + 0);
00132       data2 = closure->data;
00133     }
00134   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
00135 
00136   v_return = callback (data1,
00137                        data2);
00138 
00139   g_value_set_boolean (return_value, v_return);
00140 }
00141 
00142 /* BOOLEAN:STRING (./ldm-marshal.list:3) */
00143 extern void ldm_marshal_BOOLEAN__STRING (GClosure     *closure,
00144                                          GValue       *return_value,
00145                                          guint         n_param_values,
00146                                          const GValue *param_values,
00147                                          gpointer      invocation_hint,
00148                                          gpointer      marshal_data);
00149 void
00150 ldm_marshal_BOOLEAN__STRING (GClosure     *closure,
00151                              GValue       *return_value G_GNUC_UNUSED,
00152                              guint         n_param_values,
00153                              const GValue *param_values,
00154                              gpointer      invocation_hint G_GNUC_UNUSED,
00155                              gpointer      marshal_data)
00156 {
00157   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer     data1,
00158                                                     gpointer     arg_1,
00159                                                     gpointer     data2);
00160   register GMarshalFunc_BOOLEAN__STRING callback;
00161   register GCClosure *cc = (GCClosure*) closure;
00162   register gpointer data1, data2;
00163   gboolean v_return;
00164 
00165   g_return_if_fail (return_value != NULL);
00166   g_return_if_fail (n_param_values == 2);
00167 
00168   if (G_CCLOSURE_SWAP_DATA (closure))
00169     {
00170       data1 = closure->data;
00171       data2 = g_value_peek_pointer (param_values + 0);
00172     }
00173   else
00174     {
00175       data1 = g_value_peek_pointer (param_values + 0);
00176       data2 = closure->data;
00177     }
00178   callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
00179 
00180   v_return = callback (data1,
00181                        g_marshal_value_peek_string (param_values + 1),
00182                        data2);
00183 
00184   g_value_set_boolean (return_value, v_return);
00185 }
00186 
00187 /* BOOLEAN:OBJECT (./ldm-marshal.list:4) */
00188 extern void ldm_marshal_BOOLEAN__OBJECT (GClosure     *closure,
00189                                          GValue       *return_value,
00190                                          guint         n_param_values,
00191                                          const GValue *param_values,
00192                                          gpointer      invocation_hint,
00193                                          gpointer      marshal_data);
00194 void
00195 ldm_marshal_BOOLEAN__OBJECT (GClosure     *closure,
00196                              GValue       *return_value G_GNUC_UNUSED,
00197                              guint         n_param_values,
00198                              const GValue *param_values,
00199                              gpointer      invocation_hint G_GNUC_UNUSED,
00200                              gpointer      marshal_data)
00201 {
00202   typedef gboolean (*GMarshalFunc_BOOLEAN__OBJECT) (gpointer     data1,
00203                                                     gpointer     arg_1,
00204                                                     gpointer     data2);
00205   register GMarshalFunc_BOOLEAN__OBJECT callback;
00206   register GCClosure *cc = (GCClosure*) closure;
00207   register gpointer data1, data2;
00208   gboolean v_return;
00209 
00210   g_return_if_fail (return_value != NULL);
00211   g_return_if_fail (n_param_values == 2);
00212 
00213   if (G_CCLOSURE_SWAP_DATA (closure))
00214     {
00215       data1 = closure->data;
00216       data2 = g_value_peek_pointer (param_values + 0);
00217     }
00218   else
00219     {
00220       data1 = g_value_peek_pointer (param_values + 0);
00221       data2 = closure->data;
00222     }
00223   callback = (GMarshalFunc_BOOLEAN__OBJECT) (marshal_data ? marshal_data : cc->callback);
00224 
00225   v_return = callback (data1,
00226                        g_marshal_value_peek_object (param_values + 1),
00227                        data2);
00228 
00229   g_value_set_boolean (return_value, v_return);
00230 }
00231 
00232 /* STRING:VOID (./ldm-marshal.list:5) */
00233 extern void ldm_marshal_STRING__VOID (GClosure     *closure,
00234                                       GValue       *return_value,
00235                                       guint         n_param_values,
00236                                       const GValue *param_values,
00237                                       gpointer      invocation_hint,
00238                                       gpointer      marshal_data);
00239 void
00240 ldm_marshal_STRING__VOID (GClosure     *closure,
00241                           GValue       *return_value G_GNUC_UNUSED,
00242                           guint         n_param_values,
00243                           const GValue *param_values,
00244                           gpointer      invocation_hint G_GNUC_UNUSED,
00245                           gpointer      marshal_data)
00246 {
00247   typedef gchar* (*GMarshalFunc_STRING__VOID) (gpointer     data1,
00248                                                gpointer     data2);
00249   register GMarshalFunc_STRING__VOID callback;
00250   register GCClosure *cc = (GCClosure*) closure;
00251   register gpointer data1, data2;
00252   gchar* v_return;
00253 
00254   g_return_if_fail (return_value != NULL);
00255   g_return_if_fail (n_param_values == 1);
00256 
00257   if (G_CCLOSURE_SWAP_DATA (closure))
00258     {
00259       data1 = closure->data;
00260       data2 = g_value_peek_pointer (param_values + 0);
00261     }
00262   else
00263     {
00264       data1 = g_value_peek_pointer (param_values + 0);
00265       data2 = closure->data;
00266     }
00267   callback = (GMarshalFunc_STRING__VOID) (marshal_data ? marshal_data : cc->callback);
00268 
00269   v_return = callback (data1,
00270                        data2);
00271 
00272   g_value_take_string (return_value, v_return);
00273 }
00274 
00275 /* OBJECT:VOID (./ldm-marshal.list:6) */
00276 extern void ldm_marshal_OBJECT__VOID (GClosure     *closure,
00277                                       GValue       *return_value,
00278                                       guint         n_param_values,
00279                                       const GValue *param_values,
00280                                       gpointer      invocation_hint,
00281                                       gpointer      marshal_data);
00282 void
00283 ldm_marshal_OBJECT__VOID (GClosure     *closure,
00284                           GValue       *return_value G_GNUC_UNUSED,
00285                           guint         n_param_values,
00286                           const GValue *param_values,
00287                           gpointer      invocation_hint G_GNUC_UNUSED,
00288                           gpointer      marshal_data)
00289 {
00290   typedef GObject* (*GMarshalFunc_OBJECT__VOID) (gpointer     data1,
00291                                                  gpointer     data2);
00292   register GMarshalFunc_OBJECT__VOID callback;
00293   register GCClosure *cc = (GCClosure*) closure;
00294   register gpointer data1, data2;
00295   GObject* v_return;
00296 
00297   g_return_if_fail (return_value != NULL);
00298   g_return_if_fail (n_param_values == 1);
00299 
00300   if (G_CCLOSURE_SWAP_DATA (closure))
00301     {
00302       data1 = closure->data;
00303       data2 = g_value_peek_pointer (param_values + 0);
00304     }
00305   else
00306     {
00307       data1 = g_value_peek_pointer (param_values + 0);
00308       data2 = closure->data;
00309     }
00310   callback = (GMarshalFunc_OBJECT__VOID) (marshal_data ? marshal_data : cc->callback);
00311 
00312   v_return = callback (data1,
00313                        data2);
00314 
00315   g_value_take_object (return_value, v_return);
00316 }
00317 
00318 /* OBJECT:STRING (./ldm-marshal.list:7) */
00319 extern void ldm_marshal_OBJECT__STRING (GClosure     *closure,
00320                                         GValue       *return_value,
00321                                         guint         n_param_values,
00322                                         const GValue *param_values,
00323                                         gpointer      invocation_hint,
00324                                         gpointer      marshal_data);
00325 void
00326 ldm_marshal_OBJECT__STRING (GClosure     *closure,
00327                             GValue       *return_value G_GNUC_UNUSED,
00328                             guint         n_param_values,
00329                             const GValue *param_values,
00330                             gpointer      invocation_hint G_GNUC_UNUSED,
00331                             gpointer      marshal_data)
00332 {
00333   typedef GObject* (*GMarshalFunc_OBJECT__STRING) (gpointer     data1,
00334                                                    gpointer     arg_1,
00335                                                    gpointer     data2);
00336   register GMarshalFunc_OBJECT__STRING callback;
00337   register GCClosure *cc = (GCClosure*) closure;
00338   register gpointer data1, data2;
00339   GObject* v_return;
00340 
00341   g_return_if_fail (return_value != NULL);
00342   g_return_if_fail (n_param_values == 2);
00343 
00344   if (G_CCLOSURE_SWAP_DATA (closure))
00345     {
00346       data1 = closure->data;
00347       data2 = g_value_peek_pointer (param_values + 0);
00348     }
00349   else
00350     {
00351       data1 = g_value_peek_pointer (param_values + 0);
00352       data2 = closure->data;
00353     }
00354   callback = (GMarshalFunc_OBJECT__STRING) (marshal_data ? marshal_data : cc->callback);
00355 
00356   v_return = callback (data1,
00357                        g_marshal_value_peek_string (param_values + 1),
00358                        data2);
00359 
00360   g_value_take_object (return_value, v_return);
00361 }
00362 
00363 G_END_DECLS
00364 
00365 #endif /* __ldm_marshal_MARSHAL_H__ */
00366