# magnifier-client.h

Go to the documentation of this file.

    00001 /* Generated by dbus-binding-tool; do not edit! */
    00002
    00003 #include <glib.h>
    00004 #include <dbus/dbus-glib.h>
    00005
    00006 G_BEGIN_DECLS
    00007
    00008 #ifndef _DBUS_GLIB_ASYNC_DATA_FREE
    00009 #define _DBUS_GLIB_ASYNC_DATA_FREE
    00010 static
    00011 #ifdef G_HAVE_INLINE
    00012 inline
    00013 #endif
    00014 void
    00015 _dbus_glib_async_data_free (gpointer stuff)
    00016 {
    00017         g_slice_free (DBusGAsyncData, stuff);
    00018 }
    00019 #endif
    00020
    00021 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_gnome_Magnifier
    00022 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_gnome_Magnifier
    00023
    00024 static
    00025 #ifdef G_HAVE_INLINE
    00026 inline
    00027 #endif
    00028 gboolean
    00029 org_freedesktop_gnome_Magnifier_full_screen_capable (DBusGProxy *proxy, gboolean* OUT_b-ret, GError **error)
    00030
    00031 {
    00032   return dbus_g_proxy_call (proxy, "fullScreenCapable", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_b-ret, G_TYPE_INVALID);
    00033 }
    00034
    00035 typedef void (*org_freedesktop_gnome_Magnifier_full_screen_capable_reply) (DBusGProxy *proxy, gboolean OUT_b-ret, GError *error, gpointer userdata);
    00036
    00037 static void
    00038 org_freedesktop_gnome_Magnifier_full_screen_capable_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00039 {
    00040   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00041   GError *error = NULL;
    00042   gboolean OUT_b-ret;
    00043   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_b-ret, G_TYPE_INVALID);
    00044   (*(org_freedesktop_gnome_Magnifier_full_screen_capable_reply)data->cb) (proxy, OUT_b-ret, error, data->userdata);
    00045   return;
    00046 }
    00047
    00048 static
    00049 #ifdef G_HAVE_INLINE
    00050 inline
    00051 #endif
    00052 DBusGProxyCall*
    00053 org_freedesktop_gnome_Magnifier_full_screen_capable_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_full_screen_capable_reply callback, gpointer userdata)
    00054
    00055 {
    00056   DBusGAsyncData *stuff;
    00057   stuff = g_slice_new (DBusGAsyncData);
    00058   stuff->cb = G_CALLBACK (callback);
    00059   stuff->userdata = userdata;
    00060   return dbus_g_proxy_begin_call (proxy, "fullScreenCapable", org_freedesktop_gnome_Magnifier_full_screen_capable_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00061 }
    00062 static
    00063 #ifdef G_HAVE_INLINE
    00064 inline
    00065 #endif
    00066 gboolean
    00067 org_freedesktop_gnome_Magnifier_hide_cursor (DBusGProxy *proxy, GError **error)
    00068
    00069 {
    00070   return dbus_g_proxy_call (proxy, "hideCursor", error, G_TYPE_INVALID, G_TYPE_INVALID);
    00071 }
    00072
    00073 typedef void (*org_freedesktop_gnome_Magnifier_hide_cursor_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00074
    00075 static void
    00076 org_freedesktop_gnome_Magnifier_hide_cursor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00077 {
    00078   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00079   GError *error = NULL;
    00080   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00081   (*(org_freedesktop_gnome_Magnifier_hide_cursor_reply)data->cb) (proxy, error, data->userdata);
    00082   return;
    00083 }
    00084
    00085 static
    00086 #ifdef G_HAVE_INLINE
    00087 inline
    00088 #endif
    00089 DBusGProxyCall*
    00090 org_freedesktop_gnome_Magnifier_hide_cursor_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_hide_cursor_reply callback, gpointer userdata)
    00091
    00092 {
    00093   DBusGAsyncData *stuff;
    00094   stuff = g_slice_new (DBusGAsyncData);
    00095   stuff->cb = G_CALLBACK (callback);
    00096   stuff->userdata = userdata;
    00097   return dbus_g_proxy_begin_call (proxy, "hideCursor", org_freedesktop_gnome_Magnifier_hide_cursor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00098 }
    00099 static
    00100 #ifdef G_HAVE_INLINE
    00101 inline
    00102 #endif
    00103 gboolean
    00104 org_freedesktop_gnome_Magnifier_show_cursor (DBusGProxy *proxy, GError **error)
    00105
    00106 {
    00107   return dbus_g_proxy_call (proxy, "showCursor", error, G_TYPE_INVALID, G_TYPE_INVALID);
    00108 }
    00109
    00110 typedef void (*org_freedesktop_gnome_Magnifier_show_cursor_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00111
    00112 static void
    00113 org_freedesktop_gnome_Magnifier_show_cursor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00114 {
    00115   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00116   GError *error = NULL;
    00117   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00118   (*(org_freedesktop_gnome_Magnifier_show_cursor_reply)data->cb) (proxy, error, data->userdata);
    00119   return;
    00120 }
    00121
    00122 static
    00123 #ifdef G_HAVE_INLINE
    00124 inline
    00125 #endif
    00126 DBusGProxyCall*
    00127 org_freedesktop_gnome_Magnifier_show_cursor_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_show_cursor_reply callback, gpointer userdata)
    00128
    00129 {
    00130   DBusGAsyncData *stuff;
    00131   stuff = g_slice_new (DBusGAsyncData);
    00132   stuff->cb = G_CALLBACK (callback);
    00133   stuff->userdata = userdata;
    00134   return dbus_g_proxy_begin_call (proxy, "showCursor", org_freedesktop_gnome_Magnifier_show_cursor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00135 }
    00136 static
    00137 #ifdef G_HAVE_INLINE
    00138 inline
    00139 #endif
    00140 gboolean
    00141 org_freedesktop_gnome_Magnifier_support_colorblind_filters (DBusGProxy *proxy, gboolean* OUT_b-ret, GError **error)
    00142
    00143 {
    00144   return dbus_g_proxy_call (proxy, "supportColorblindFilters", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_b-ret, G_TYPE_INVALID);
    00145 }
    00146
    00147 typedef void (*org_freedesktop_gnome_Magnifier_support_colorblind_filters_reply) (DBusGProxy *proxy, gboolean OUT_b-ret, GError *error, gpointer userdata);
    00148
    00149 static void
    00150 org_freedesktop_gnome_Magnifier_support_colorblind_filters_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00151 {
    00152   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00153   GError *error = NULL;
    00154   gboolean OUT_b-ret;
    00155   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_b-ret, G_TYPE_INVALID);
    00156   (*(org_freedesktop_gnome_Magnifier_support_colorblind_filters_reply)data->cb) (proxy, OUT_b-ret, error, data->userdata);
    00157   return;
    00158 }
    00159
    00160 static
    00161 #ifdef G_HAVE_INLINE
    00162 inline
    00163 #endif
    00164 DBusGProxyCall*
    00165 org_freedesktop_gnome_Magnifier_support_colorblind_filters_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_support_colorblind_filters_reply callback, gpointer userdata)
    00166
    00167 {
    00168   DBusGAsyncData *stuff;
    00169   stuff = g_slice_new (DBusGAsyncData);
    00170   stuff->cb = G_CALLBACK (callback);
    00171   stuff->userdata = userdata;
    00172   return dbus_g_proxy_begin_call (proxy, "supportColorblindFilters", org_freedesktop_gnome_Magnifier_support_colorblind_filters_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00173 }
    00174 static
    00175 #ifdef G_HAVE_INLINE
    00176 inline
    00177 #endif
    00178 gboolean
    00179 org_freedesktop_gnome_Magnifier_create_zoom_region (DBusGProxy *proxy, const gdouble IN_zx, const gdouble IN_zy, const GArray* IN_ROI, const GArray* IN_viewPort, char** OUT_zoomRegion-ret, GError **error)
    00180
    00181 {
    00182   return dbus_g_proxy_call (proxy, "createZoomRegion", error, G_TYPE_DOUBLE, IN_zx, G_TYPE_DOUBLE, IN_zy, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_ROI, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_viewPort, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_zoomRegion-ret, G_TYPE_INVALID);
    00183 }
    00184
    00185 typedef void (*org_freedesktop_gnome_Magnifier_create_zoom_region_reply) (DBusGProxy *proxy, char *OUT_zoomRegion-ret, GError *error, gpointer userdata);
    00186
    00187 static void
    00188 org_freedesktop_gnome_Magnifier_create_zoom_region_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00189 {
    00190   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00191   GError *error = NULL;
    00192   char* OUT_zoomRegion-ret;
    00193   dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_zoomRegion-ret, G_TYPE_INVALID);
    00194   (*(org_freedesktop_gnome_Magnifier_create_zoom_region_reply)data->cb) (proxy, OUT_zoomRegion-ret, error, data->userdata);
    00195   return;
    00196 }
    00197
    00198 static
    00199 #ifdef G_HAVE_INLINE
    00200 inline
    00201 #endif
    00202 DBusGProxyCall*
    00203 org_freedesktop_gnome_Magnifier_create_zoom_region_async (DBusGProxy *proxy, const gdouble IN_zx, const gdouble IN_zy, const GArray* IN_ROI, const GArray* IN_viewPort, org_freedesktop_gnome_Magnifier_create_zoom_region_reply callback, gpointer userdata)
    00204
    00205 {
    00206   DBusGAsyncData *stuff;
    00207   stuff = g_slice_new (DBusGAsyncData);
    00208   stuff->cb = G_CALLBACK (callback);
    00209   stuff->userdata = userdata;
    00210   return dbus_g_proxy_begin_call (proxy, "createZoomRegion", org_freedesktop_gnome_Magnifier_create_zoom_region_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_zx, G_TYPE_DOUBLE, IN_zy, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_ROI, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_viewPort, G_TYPE_INVALID);
    00211 }
    00212 static
    00213 #ifdef G_HAVE_INLINE
    00214 inline
    00215 #endif
    00216 gboolean
    00217 org_freedesktop_gnome_Magnifier_get_zoom_regions (DBusGProxy *proxy, char *** OUT_zoomRegionList-ret, GError **error)
    00218
    00219 {
    00220   return dbus_g_proxy_call (proxy, "getZoomRegions", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_zoomRegionList-ret, G_TYPE_INVALID);
    00221 }
    00222
    00223 typedef void (*org_freedesktop_gnome_Magnifier_get_zoom_regions_reply) (DBusGProxy *proxy, char * *OUT_zoomRegionList-ret, GError *error, gpointer userdata);
    00224
    00225 static void
    00226 org_freedesktop_gnome_Magnifier_get_zoom_regions_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00227 {
    00228   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00229   GError *error = NULL;
    00230   char ** OUT_zoomRegionList-ret;
    00231   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_zoomRegionList-ret, G_TYPE_INVALID);
    00232   (*(org_freedesktop_gnome_Magnifier_get_zoom_regions_reply)data->cb) (proxy, OUT_zoomRegionList-ret, error, data->userdata);
    00233   return;
    00234 }
    00235
    00236 static
    00237 #ifdef G_HAVE_INLINE
    00238 inline
    00239 #endif
    00240 DBusGProxyCall*
    00241 org_freedesktop_gnome_Magnifier_get_zoom_regions_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_zoom_regions_reply callback, gpointer userdata)
    00242
    00243 {
    00244   DBusGAsyncData *stuff;
    00245   stuff = g_slice_new (DBusGAsyncData);
    00246   stuff->cb = G_CALLBACK (callback);
    00247   stuff->userdata = userdata;
    00248   return dbus_g_proxy_begin_call (proxy, "getZoomRegions", org_freedesktop_gnome_Magnifier_get_zoom_regions_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00249 }
    00250 static
    00251 #ifdef G_HAVE_INLINE
    00252 inline
    00253 #endif
    00254 gboolean
    00255 org_freedesktop_gnome_Magnifier_add_zoom_region (DBusGProxy *proxy, const char* IN_region, gboolean* OUT_b-ret, GError **error)
    00256
    00257 {
    00258   return dbus_g_proxy_call (proxy, "addZoomRegion", error, DBUS_TYPE_G_OBJECT_PATH, IN_region, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_b-ret, G_TYPE_INVALID);
    00259 }
    00260
    00261 typedef void (*org_freedesktop_gnome_Magnifier_add_zoom_region_reply) (DBusGProxy *proxy, gboolean OUT_b-ret, GError *error, gpointer userdata);
    00262
    00263 static void
    00264 org_freedesktop_gnome_Magnifier_add_zoom_region_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00265 {
    00266   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00267   GError *error = NULL;
    00268   gboolean OUT_b-ret;
    00269   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_b-ret, G_TYPE_INVALID);
    00270   (*(org_freedesktop_gnome_Magnifier_add_zoom_region_reply)data->cb) (proxy, OUT_b-ret, error, data->userdata);
    00271   return;
    00272 }
    00273
    00274 static
    00275 #ifdef G_HAVE_INLINE
    00276 inline
    00277 #endif
    00278 DBusGProxyCall*
    00279 org_freedesktop_gnome_Magnifier_add_zoom_region_async (DBusGProxy *proxy, const char* IN_region, org_freedesktop_gnome_Magnifier_add_zoom_region_reply callback, gpointer userdata)
    00280
    00281 {
    00282   DBusGAsyncData *stuff;
    00283   stuff = g_slice_new (DBusGAsyncData);
    00284   stuff->cb = G_CALLBACK (callback);
    00285   stuff->userdata = userdata;
    00286   return dbus_g_proxy_begin_call (proxy, "addZoomRegion", org_freedesktop_gnome_Magnifier_add_zoom_region_async_callback, stuff, _dbus_glib_async_data_free, DBUS_TYPE_G_OBJECT_PATH, IN_region, G_TYPE_INVALID);
    00287 }
    00288 static
    00289 #ifdef G_HAVE_INLINE
    00290 inline
    00291 #endif
    00292 gboolean
    00293 org_freedesktop_gnome_Magnifier_clear_all_zoom_regions (DBusGProxy *proxy, GError **error)
    00294
    00295 {
    00296   return dbus_g_proxy_call (proxy, "clearAllZoomRegions", error, G_TYPE_INVALID, G_TYPE_INVALID);
    00297 }
    00298
    00299 typedef void (*org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00300
    00301 static void
    00302 org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00303 {
    00304   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00305   GError *error = NULL;
    00306   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00307   (*(org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_reply)data->cb) (proxy, error, data->userdata);
    00308   return;
    00309 }
    00310
    00311 static
    00312 #ifdef G_HAVE_INLINE
    00313 inline
    00314 #endif
    00315 DBusGProxyCall*
    00316 org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_reply callback, gpointer userdata)
    00317
    00318 {
    00319   DBusGAsyncData *stuff;
    00320   stuff = g_slice_new (DBusGAsyncData);
    00321   stuff->cb = G_CALLBACK (callback);
    00322   stuff->userdata = userdata;
    00323   return dbus_g_proxy_begin_call (proxy, "clearAllZoomRegions", org_freedesktop_gnome_Magnifier_clear_all_zoom_regions_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00324 }
    00325 static
    00326 #ifdef G_HAVE_INLINE
    00327 inline
    00328 #endif
    00329 gboolean
    00330 org_freedesktop_gnome_Magnifier_dispose (DBusGProxy *proxy, GError **error)
    00331
    00332 {
    00333   return dbus_g_proxy_call (proxy, "dispose", error, G_TYPE_INVALID, G_TYPE_INVALID);
    00334 }
    00335
    00336 typedef void (*org_freedesktop_gnome_Magnifier_dispose_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00337
    00338 static void
    00339 org_freedesktop_gnome_Magnifier_dispose_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00340 {
    00341   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00342   GError *error = NULL;
    00343   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00344   (*(org_freedesktop_gnome_Magnifier_dispose_reply)data->cb) (proxy, error, data->userdata);
    00345   return;
    00346 }
    00347
    00348 static
    00349 #ifdef G_HAVE_INLINE
    00350 inline
    00351 #endif
    00352 DBusGProxyCall*
    00353 org_freedesktop_gnome_Magnifier_dispose_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_dispose_reply callback, gpointer userdata)
    00354
    00355 {
    00356   DBusGAsyncData *stuff;
    00357   stuff = g_slice_new (DBusGAsyncData);
    00358   stuff->cb = G_CALLBACK (callback);
    00359   stuff->userdata = userdata;
    00360   return dbus_g_proxy_begin_call (proxy, "dispose", org_freedesktop_gnome_Magnifier_dispose_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00361 }
    00362 static
    00363 #ifdef G_HAVE_INLINE
    00364 inline
    00365 #endif
    00366 gboolean
    00367 org_freedesktop_gnome_Magnifier_set_source_display (DBusGProxy *proxy, const char * IN_source_display, GError **error)
    00368
    00369 {
    00370   return dbus_g_proxy_call (proxy, "setSourceDisplay", error, G_TYPE_STRING, IN_source_display, G_TYPE_INVALID, G_TYPE_INVALID);
    00371 }
    00372
    00373 typedef void (*org_freedesktop_gnome_Magnifier_set_source_display_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00374
    00375 static void
    00376 org_freedesktop_gnome_Magnifier_set_source_display_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00377 {
    00378   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00379   GError *error = NULL;
    00380   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00381   (*(org_freedesktop_gnome_Magnifier_set_source_display_reply)data->cb) (proxy, error, data->userdata);
    00382   return;
    00383 }
    00384
    00385 static
    00386 #ifdef G_HAVE_INLINE
    00387 inline
    00388 #endif
    00389 DBusGProxyCall*
    00390 org_freedesktop_gnome_Magnifier_set_source_display_async (DBusGProxy *proxy, const char * IN_source_display, org_freedesktop_gnome_Magnifier_set_source_display_reply callback, gpointer userdata)
    00391
    00392 {
    00393   DBusGAsyncData *stuff;
    00394   stuff = g_slice_new (DBusGAsyncData);
    00395   stuff->cb = G_CALLBACK (callback);
    00396   stuff->userdata = userdata;
    00397   return dbus_g_proxy_begin_call (proxy, "setSourceDisplay", org_freedesktop_gnome_Magnifier_set_source_display_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_source_display, G_TYPE_INVALID);
    00398 }
    00399 static
    00400 #ifdef G_HAVE_INLINE
    00401 inline
    00402 #endif
    00403 gboolean
    00404 org_freedesktop_gnome_Magnifier_get_source_display (DBusGProxy *proxy, char ** OUT_source_display, GError **error)
    00405
    00406 {
    00407   return dbus_g_proxy_call (proxy, "getSourceDisplay", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_source_display, G_TYPE_INVALID);
    00408 }
    00409
    00410 typedef void (*org_freedesktop_gnome_Magnifier_get_source_display_reply) (DBusGProxy *proxy, char * OUT_source_display, GError *error, gpointer userdata);
    00411
    00412 static void
    00413 org_freedesktop_gnome_Magnifier_get_source_display_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00414 {
    00415   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00416   GError *error = NULL;
    00417   char * OUT_source_display;
    00418   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_source_display, G_TYPE_INVALID);
    00419   (*(org_freedesktop_gnome_Magnifier_get_source_display_reply)data->cb) (proxy, OUT_source_display, error, data->userdata);
    00420   return;
    00421 }
    00422
    00423 static
    00424 #ifdef G_HAVE_INLINE
    00425 inline
    00426 #endif
    00427 DBusGProxyCall*
    00428 org_freedesktop_gnome_Magnifier_get_source_display_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_source_display_reply callback, gpointer userdata)
    00429
    00430 {
    00431   DBusGAsyncData *stuff;
    00432   stuff = g_slice_new (DBusGAsyncData);
    00433   stuff->cb = G_CALLBACK (callback);
    00434   stuff->userdata = userdata;
    00435   return dbus_g_proxy_begin_call (proxy, "getSourceDisplay", org_freedesktop_gnome_Magnifier_get_source_display_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00436 }
    00437 static
    00438 #ifdef G_HAVE_INLINE
    00439 inline
    00440 #endif
    00441 gboolean
    00442 org_freedesktop_gnome_Magnifier_set_target_display (DBusGProxy *proxy, const char * IN_target_display, GError **error)
    00443
    00444 {
    00445   return dbus_g_proxy_call (proxy, "setTargetDisplay", error, G_TYPE_STRING, IN_target_display, G_TYPE_INVALID, G_TYPE_INVALID);
    00446 }
    00447
    00448 typedef void (*org_freedesktop_gnome_Magnifier_set_target_display_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00449
    00450 static void
    00451 org_freedesktop_gnome_Magnifier_set_target_display_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00452 {
    00453   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00454   GError *error = NULL;
    00455   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00456   (*(org_freedesktop_gnome_Magnifier_set_target_display_reply)data->cb) (proxy, error, data->userdata);
    00457   return;
    00458 }
    00459
    00460 static
    00461 #ifdef G_HAVE_INLINE
    00462 inline
    00463 #endif
    00464 DBusGProxyCall*
    00465 org_freedesktop_gnome_Magnifier_set_target_display_async (DBusGProxy *proxy, const char * IN_target_display, org_freedesktop_gnome_Magnifier_set_target_display_reply callback, gpointer userdata)
    00466
    00467 {
    00468   DBusGAsyncData *stuff;
    00469   stuff = g_slice_new (DBusGAsyncData);
    00470   stuff->cb = G_CALLBACK (callback);
    00471   stuff->userdata = userdata;
    00472   return dbus_g_proxy_begin_call (proxy, "setTargetDisplay", org_freedesktop_gnome_Magnifier_set_target_display_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_target_display, G_TYPE_INVALID);
    00473 }
    00474 static
    00475 #ifdef G_HAVE_INLINE
    00476 inline
    00477 #endif
    00478 gboolean
    00479 org_freedesktop_gnome_Magnifier_get_target_display (DBusGProxy *proxy, char ** OUT_target_display, GError **error)
    00480
    00481 {
    00482   return dbus_g_proxy_call (proxy, "getTargetDisplay", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_target_display, G_TYPE_INVALID);
    00483 }
    00484
    00485 typedef void (*org_freedesktop_gnome_Magnifier_get_target_display_reply) (DBusGProxy *proxy, char * OUT_target_display, GError *error, gpointer userdata);
    00486
    00487 static void
    00488 org_freedesktop_gnome_Magnifier_get_target_display_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00489 {
    00490   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00491   GError *error = NULL;
    00492   char * OUT_target_display;
    00493   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_target_display, G_TYPE_INVALID);
    00494   (*(org_freedesktop_gnome_Magnifier_get_target_display_reply)data->cb) (proxy, OUT_target_display, error, data->userdata);
    00495   return;
    00496 }
    00497
    00498 static
    00499 #ifdef G_HAVE_INLINE
    00500 inline
    00501 #endif
    00502 DBusGProxyCall*
    00503 org_freedesktop_gnome_Magnifier_get_target_display_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_target_display_reply callback, gpointer userdata)
    00504
    00505 {
    00506   DBusGAsyncData *stuff;
    00507   stuff = g_slice_new (DBusGAsyncData);
    00508   stuff->cb = G_CALLBACK (callback);
    00509   stuff->userdata = userdata;
    00510   return dbus_g_proxy_begin_call (proxy, "getTargetDisplay", org_freedesktop_gnome_Magnifier_get_target_display_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00511 }
    00512 static
    00513 #ifdef G_HAVE_INLINE
    00514 inline
    00515 #endif
    00516 gboolean
    00517 org_freedesktop_gnome_Magnifier_set_source_size (DBusGProxy *proxy, const GArray* IN_source_bounds, GError **error)
    00518
    00519 {
    00520   return dbus_g_proxy_call (proxy, "setSourceSize", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_source_bounds, G_TYPE_INVALID, G_TYPE_INVALID);
    00521 }
    00522
    00523 typedef void (*org_freedesktop_gnome_Magnifier_set_source_size_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00524
    00525 static void
    00526 org_freedesktop_gnome_Magnifier_set_source_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00527 {
    00528   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00529   GError *error = NULL;
    00530   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00531   (*(org_freedesktop_gnome_Magnifier_set_source_size_reply)data->cb) (proxy, error, data->userdata);
    00532   return;
    00533 }
    00534
    00535 static
    00536 #ifdef G_HAVE_INLINE
    00537 inline
    00538 #endif
    00539 DBusGProxyCall*
    00540 org_freedesktop_gnome_Magnifier_set_source_size_async (DBusGProxy *proxy, const GArray* IN_source_bounds, org_freedesktop_gnome_Magnifier_set_source_size_reply callback, gpointer userdata)
    00541
    00542 {
    00543   DBusGAsyncData *stuff;
    00544   stuff = g_slice_new (DBusGAsyncData);
    00545   stuff->cb = G_CALLBACK (callback);
    00546   stuff->userdata = userdata;
    00547   return dbus_g_proxy_begin_call (proxy, "setSourceSize", org_freedesktop_gnome_Magnifier_set_source_size_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_source_bounds, G_TYPE_INVALID);
    00548 }
    00549 static
    00550 #ifdef G_HAVE_INLINE
    00551 inline
    00552 #endif
    00553 gboolean
    00554 org_freedesktop_gnome_Magnifier_get_source_size (DBusGProxy *proxy, GArray** OUT_source_bounds, GError **error)
    00555
    00556 {
    00557   return dbus_g_proxy_call (proxy, "getSourceSize", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_source_bounds, G_TYPE_INVALID);
    00558 }
    00559
    00560 typedef void (*org_freedesktop_gnome_Magnifier_get_source_size_reply) (DBusGProxy *proxy, GArray *OUT_source_bounds, GError *error, gpointer userdata);
    00561
    00562 static void
    00563 org_freedesktop_gnome_Magnifier_get_source_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00564 {
    00565   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00566   GError *error = NULL;
    00567   GArray* OUT_source_bounds;
    00568   dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_source_bounds, G_TYPE_INVALID);
    00569   (*(org_freedesktop_gnome_Magnifier_get_source_size_reply)data->cb) (proxy, OUT_source_bounds, error, data->userdata);
    00570   return;
    00571 }
    00572
    00573 static
    00574 #ifdef G_HAVE_INLINE
    00575 inline
    00576 #endif
    00577 DBusGProxyCall*
    00578 org_freedesktop_gnome_Magnifier_get_source_size_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_source_size_reply callback, gpointer userdata)
    00579
    00580 {
    00581   DBusGAsyncData *stuff;
    00582   stuff = g_slice_new (DBusGAsyncData);
    00583   stuff->cb = G_CALLBACK (callback);
    00584   stuff->userdata = userdata;
    00585   return dbus_g_proxy_begin_call (proxy, "getSourceSize", org_freedesktop_gnome_Magnifier_get_source_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00586 }
    00587 static
    00588 #ifdef G_HAVE_INLINE
    00589 inline
    00590 #endif
    00591 gboolean
    00592 org_freedesktop_gnome_Magnifier_set_target_size (DBusGProxy *proxy, const GArray* IN_target_bounds, GError **error)
    00593
    00594 {
    00595   return dbus_g_proxy_call (proxy, "setTargetSize", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_target_bounds, G_TYPE_INVALID, G_TYPE_INVALID);
    00596 }
    00597
    00598 typedef void (*org_freedesktop_gnome_Magnifier_set_target_size_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00599
    00600 static void
    00601 org_freedesktop_gnome_Magnifier_set_target_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00602 {
    00603   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00604   GError *error = NULL;
    00605   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00606   (*(org_freedesktop_gnome_Magnifier_set_target_size_reply)data->cb) (proxy, error, data->userdata);
    00607   return;
    00608 }
    00609
    00610 static
    00611 #ifdef G_HAVE_INLINE
    00612 inline
    00613 #endif
    00614 DBusGProxyCall*
    00615 org_freedesktop_gnome_Magnifier_set_target_size_async (DBusGProxy *proxy, const GArray* IN_target_bounds, org_freedesktop_gnome_Magnifier_set_target_size_reply callback, gpointer userdata)
    00616
    00617 {
    00618   DBusGAsyncData *stuff;
    00619   stuff = g_slice_new (DBusGAsyncData);
    00620   stuff->cb = G_CALLBACK (callback);
    00621   stuff->userdata = userdata;
    00622   return dbus_g_proxy_begin_call (proxy, "setTargetSize", org_freedesktop_gnome_Magnifier_set_target_size_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_target_bounds, G_TYPE_INVALID);
    00623 }
    00624 static
    00625 #ifdef G_HAVE_INLINE
    00626 inline
    00627 #endif
    00628 gboolean
    00629 org_freedesktop_gnome_Magnifier_get_target_size (DBusGProxy *proxy, GArray** OUT_target_bounds, GError **error)
    00630
    00631 {
    00632   return dbus_g_proxy_call (proxy, "getTargetSize", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_target_bounds, G_TYPE_INVALID);
    00633 }
    00634
    00635 typedef void (*org_freedesktop_gnome_Magnifier_get_target_size_reply) (DBusGProxy *proxy, GArray *OUT_target_bounds, GError *error, gpointer userdata);
    00636
    00637 static void
    00638 org_freedesktop_gnome_Magnifier_get_target_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00639 {
    00640   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00641   GError *error = NULL;
    00642   GArray* OUT_target_bounds;
    00643   dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_target_bounds, G_TYPE_INVALID);
    00644   (*(org_freedesktop_gnome_Magnifier_get_target_size_reply)data->cb) (proxy, OUT_target_bounds, error, data->userdata);
    00645   return;
    00646 }
    00647
    00648 static
    00649 #ifdef G_HAVE_INLINE
    00650 inline
    00651 #endif
    00652 DBusGProxyCall*
    00653 org_freedesktop_gnome_Magnifier_get_target_size_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_target_size_reply callback, gpointer userdata)
    00654
    00655 {
    00656   DBusGAsyncData *stuff;
    00657   stuff = g_slice_new (DBusGAsyncData);
    00658   stuff->cb = G_CALLBACK (callback);
    00659   stuff->userdata = userdata;
    00660   return dbus_g_proxy_begin_call (proxy, "getTargetSize", org_freedesktop_gnome_Magnifier_get_target_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00661 }
    00662 static
    00663 #ifdef G_HAVE_INLINE
    00664 inline
    00665 #endif
    00666 gboolean
    00667 org_freedesktop_gnome_Magnifier_set_cursor_set (DBusGProxy *proxy, const char * IN_cursor_set, GError **error)
    00668
    00669 {
    00670   return dbus_g_proxy_call (proxy, "setCursorSet", error, G_TYPE_STRING, IN_cursor_set, G_TYPE_INVALID, G_TYPE_INVALID);
    00671 }
    00672
    00673 typedef void (*org_freedesktop_gnome_Magnifier_set_cursor_set_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00674
    00675 static void
    00676 org_freedesktop_gnome_Magnifier_set_cursor_set_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00677 {
    00678   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00679   GError *error = NULL;
    00680   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00681   (*(org_freedesktop_gnome_Magnifier_set_cursor_set_reply)data->cb) (proxy, error, data->userdata);
    00682   return;
    00683 }
    00684
    00685 static
    00686 #ifdef G_HAVE_INLINE
    00687 inline
    00688 #endif
    00689 DBusGProxyCall*
    00690 org_freedesktop_gnome_Magnifier_set_cursor_set_async (DBusGProxy *proxy, const char * IN_cursor_set, org_freedesktop_gnome_Magnifier_set_cursor_set_reply callback, gpointer userdata)
    00691
    00692 {
    00693   DBusGAsyncData *stuff;
    00694   stuff = g_slice_new (DBusGAsyncData);
    00695   stuff->cb = G_CALLBACK (callback);
    00696   stuff->userdata = userdata;
    00697   return dbus_g_proxy_begin_call (proxy, "setCursorSet", org_freedesktop_gnome_Magnifier_set_cursor_set_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_cursor_set, G_TYPE_INVALID);
    00698 }
    00699 static
    00700 #ifdef G_HAVE_INLINE
    00701 inline
    00702 #endif
    00703 gboolean
    00704 org_freedesktop_gnome_Magnifier_get_cursor_set (DBusGProxy *proxy, char ** OUT_cursor_set, GError **error)
    00705
    00706 {
    00707   return dbus_g_proxy_call (proxy, "getCursorSet", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_cursor_set, G_TYPE_INVALID);
    00708 }
    00709
    00710 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_set_reply) (DBusGProxy *proxy, char * OUT_cursor_set, GError *error, gpointer userdata);
    00711
    00712 static void
    00713 org_freedesktop_gnome_Magnifier_get_cursor_set_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00714 {
    00715   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00716   GError *error = NULL;
    00717   char * OUT_cursor_set;
    00718   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_cursor_set, G_TYPE_INVALID);
    00719   (*(org_freedesktop_gnome_Magnifier_get_cursor_set_reply)data->cb) (proxy, OUT_cursor_set, error, data->userdata);
    00720   return;
    00721 }
    00722
    00723 static
    00724 #ifdef G_HAVE_INLINE
    00725 inline
    00726 #endif
    00727 DBusGProxyCall*
    00728 org_freedesktop_gnome_Magnifier_get_cursor_set_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_set_reply callback, gpointer userdata)
    00729
    00730 {
    00731   DBusGAsyncData *stuff;
    00732   stuff = g_slice_new (DBusGAsyncData);
    00733   stuff->cb = G_CALLBACK (callback);
    00734   stuff->userdata = userdata;
    00735   return dbus_g_proxy_begin_call (proxy, "getCursorSet", org_freedesktop_gnome_Magnifier_get_cursor_set_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00736 }
    00737 static
    00738 #ifdef G_HAVE_INLINE
    00739 inline
    00740 #endif
    00741 gboolean
    00742 org_freedesktop_gnome_Magnifier_set_cursor_size (DBusGProxy *proxy, const gint IN_x, const gint IN_y, GError **error)
    00743
    00744 {
    00745   return dbus_g_proxy_call (proxy, "setCursorSize", error, G_TYPE_INT, IN_x, G_TYPE_INT, IN_y, G_TYPE_INVALID, G_TYPE_INVALID);
    00746 }
    00747
    00748 typedef void (*org_freedesktop_gnome_Magnifier_set_cursor_size_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00749
    00750 static void
    00751 org_freedesktop_gnome_Magnifier_set_cursor_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00752 {
    00753   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00754   GError *error = NULL;
    00755   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00756   (*(org_freedesktop_gnome_Magnifier_set_cursor_size_reply)data->cb) (proxy, error, data->userdata);
    00757   return;
    00758 }
    00759
    00760 static
    00761 #ifdef G_HAVE_INLINE
    00762 inline
    00763 #endif
    00764 DBusGProxyCall*
    00765 org_freedesktop_gnome_Magnifier_set_cursor_size_async (DBusGProxy *proxy, const gint IN_x, const gint IN_y, org_freedesktop_gnome_Magnifier_set_cursor_size_reply callback, gpointer userdata)
    00766
    00767 {
    00768   DBusGAsyncData *stuff;
    00769   stuff = g_slice_new (DBusGAsyncData);
    00770   stuff->cb = G_CALLBACK (callback);
    00771   stuff->userdata = userdata;
    00772   return dbus_g_proxy_begin_call (proxy, "setCursorSize", org_freedesktop_gnome_Magnifier_set_cursor_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_x, G_TYPE_INT, IN_y, G_TYPE_INVALID);
    00773 }
    00774 static
    00775 #ifdef G_HAVE_INLINE
    00776 inline
    00777 #endif
    00778 gboolean
    00779 org_freedesktop_gnome_Magnifier_get_cursor_size (DBusGProxy *proxy, GArray** OUT_x, GError **error)
    00780
    00781 {
    00782   return dbus_g_proxy_call (proxy, "getCursorSize", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_x, G_TYPE_INVALID);
    00783 }
    00784
    00785 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_size_reply) (DBusGProxy *proxy, GArray *OUT_x, GError *error, gpointer userdata);
    00786
    00787 static void
    00788 org_freedesktop_gnome_Magnifier_get_cursor_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00789 {
    00790   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00791   GError *error = NULL;
    00792   GArray* OUT_x;
    00793   dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_x, G_TYPE_INVALID);
    00794   (*(org_freedesktop_gnome_Magnifier_get_cursor_size_reply)data->cb) (proxy, OUT_x, error, data->userdata);
    00795   return;
    00796 }
    00797
    00798 static
    00799 #ifdef G_HAVE_INLINE
    00800 inline
    00801 #endif
    00802 DBusGProxyCall*
    00803 org_freedesktop_gnome_Magnifier_get_cursor_size_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_size_reply callback, gpointer userdata)
    00804
    00805 {
    00806   DBusGAsyncData *stuff;
    00807   stuff = g_slice_new (DBusGAsyncData);
    00808   stuff->cb = G_CALLBACK (callback);
    00809   stuff->userdata = userdata;
    00810   return dbus_g_proxy_begin_call (proxy, "getCursorSize", org_freedesktop_gnome_Magnifier_get_cursor_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00811 }
    00812 static
    00813 #ifdef G_HAVE_INLINE
    00814 inline
    00815 #endif
    00816 gboolean
    00817 org_freedesktop_gnome_Magnifier_set_cursor_zoom (DBusGProxy *proxy, const gdouble IN_factor, GError **error)
    00818
    00819 {
    00820   return dbus_g_proxy_call (proxy, "setCursorZoom", error, G_TYPE_DOUBLE, IN_factor, G_TYPE_INVALID, G_TYPE_INVALID);
    00821 }
    00822
    00823 typedef void (*org_freedesktop_gnome_Magnifier_set_cursor_zoom_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00824
    00825 static void
    00826 org_freedesktop_gnome_Magnifier_set_cursor_zoom_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00827 {
    00828   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00829   GError *error = NULL;
    00830   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00831   (*(org_freedesktop_gnome_Magnifier_set_cursor_zoom_reply)data->cb) (proxy, error, data->userdata);
    00832   return;
    00833 }
    00834
    00835 static
    00836 #ifdef G_HAVE_INLINE
    00837 inline
    00838 #endif
    00839 DBusGProxyCall*
    00840 org_freedesktop_gnome_Magnifier_set_cursor_zoom_async (DBusGProxy *proxy, const gdouble IN_factor, org_freedesktop_gnome_Magnifier_set_cursor_zoom_reply callback, gpointer userdata)
    00841
    00842 {
    00843   DBusGAsyncData *stuff;
    00844   stuff = g_slice_new (DBusGAsyncData);
    00845   stuff->cb = G_CALLBACK (callback);
    00846   stuff->userdata = userdata;
    00847   return dbus_g_proxy_begin_call (proxy, "setCursorZoom", org_freedesktop_gnome_Magnifier_set_cursor_zoom_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_factor, G_TYPE_INVALID);
    00848 }
    00849 static
    00850 #ifdef G_HAVE_INLINE
    00851 inline
    00852 #endif
    00853 gboolean
    00854 org_freedesktop_gnome_Magnifier_get_cursor_zoom (DBusGProxy *proxy, gdouble* OUT_factor, GError **error)
    00855
    00856 {
    00857   return dbus_g_proxy_call (proxy, "getCursorZoom", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_factor, G_TYPE_INVALID);
    00858 }
    00859
    00860 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_zoom_reply) (DBusGProxy *proxy, gdouble OUT_factor, GError *error, gpointer userdata);
    00861
    00862 static void
    00863 org_freedesktop_gnome_Magnifier_get_cursor_zoom_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00864 {
    00865   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00866   GError *error = NULL;
    00867   gdouble OUT_factor;
    00868   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_factor, G_TYPE_INVALID);
    00869   (*(org_freedesktop_gnome_Magnifier_get_cursor_zoom_reply)data->cb) (proxy, OUT_factor, error, data->userdata);
    00870   return;
    00871 }
    00872
    00873 static
    00874 #ifdef G_HAVE_INLINE
    00875 inline
    00876 #endif
    00877 DBusGProxyCall*
    00878 org_freedesktop_gnome_Magnifier_get_cursor_zoom_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_zoom_reply callback, gpointer userdata)
    00879
    00880 {
    00881   DBusGAsyncData *stuff;
    00882   stuff = g_slice_new (DBusGAsyncData);
    00883   stuff->cb = G_CALLBACK (callback);
    00884   stuff->userdata = userdata;
    00885   return dbus_g_proxy_begin_call (proxy, "getCursorZoom", org_freedesktop_gnome_Magnifier_get_cursor_zoom_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00886 }
    00887 static
    00888 #ifdef G_HAVE_INLINE
    00889 inline
    00890 #endif
    00891 gboolean
    00892 org_freedesktop_gnome_Magnifier_set_cursor_color (DBusGProxy *proxy, const guint IN_color, GError **error)
    00893
    00894 {
    00895   return dbus_g_proxy_call (proxy, "setCursorColor", error, G_TYPE_UINT, IN_color, G_TYPE_INVALID, G_TYPE_INVALID);
    00896 }
    00897
    00898 typedef void (*org_freedesktop_gnome_Magnifier_set_cursor_color_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00899
    00900 static void
    00901 org_freedesktop_gnome_Magnifier_set_cursor_color_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00902 {
    00903   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00904   GError *error = NULL;
    00905   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00906   (*(org_freedesktop_gnome_Magnifier_set_cursor_color_reply)data->cb) (proxy, error, data->userdata);
    00907   return;
    00908 }
    00909
    00910 static
    00911 #ifdef G_HAVE_INLINE
    00912 inline
    00913 #endif
    00914 DBusGProxyCall*
    00915 org_freedesktop_gnome_Magnifier_set_cursor_color_async (DBusGProxy *proxy, const guint IN_color, org_freedesktop_gnome_Magnifier_set_cursor_color_reply callback, gpointer userdata)
    00916
    00917 {
    00918   DBusGAsyncData *stuff;
    00919   stuff = g_slice_new (DBusGAsyncData);
    00920   stuff->cb = G_CALLBACK (callback);
    00921   stuff->userdata = userdata;
    00922   return dbus_g_proxy_begin_call (proxy, "setCursorColor", org_freedesktop_gnome_Magnifier_set_cursor_color_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_color, G_TYPE_INVALID);
    00923 }
    00924 static
    00925 #ifdef G_HAVE_INLINE
    00926 inline
    00927 #endif
    00928 gboolean
    00929 org_freedesktop_gnome_Magnifier_get_cursor_color (DBusGProxy *proxy, guint* OUT_color, GError **error)
    00930
    00931 {
    00932   return dbus_g_proxy_call (proxy, "getCursorColor", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_color, G_TYPE_INVALID);
    00933 }
    00934
    00935 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_color_reply) (DBusGProxy *proxy, guint OUT_color, GError *error, gpointer userdata);
    00936
    00937 static void
    00938 org_freedesktop_gnome_Magnifier_get_cursor_color_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00939 {
    00940   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00941   GError *error = NULL;
    00942   guint OUT_color;
    00943   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_color, G_TYPE_INVALID);
    00944   (*(org_freedesktop_gnome_Magnifier_get_cursor_color_reply)data->cb) (proxy, OUT_color, error, data->userdata);
    00945   return;
    00946 }
    00947
    00948 static
    00949 #ifdef G_HAVE_INLINE
    00950 inline
    00951 #endif
    00952 DBusGProxyCall*
    00953 org_freedesktop_gnome_Magnifier_get_cursor_color_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_color_reply callback, gpointer userdata)
    00954
    00955 {
    00956   DBusGAsyncData *stuff;
    00957   stuff = g_slice_new (DBusGAsyncData);
    00958   stuff->cb = G_CALLBACK (callback);
    00959   stuff->userdata = userdata;
    00960   return dbus_g_proxy_begin_call (proxy, "getCursorColor", org_freedesktop_gnome_Magnifier_get_cursor_color_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    00961 }
    00962 static
    00963 #ifdef G_HAVE_INLINE
    00964 inline
    00965 #endif
    00966 gboolean
    00967 org_freedesktop_gnome_Magnifier_set_cursor_hotspot (DBusGProxy *proxy, const gint IN_x, const gint IN_y, GError **error)
    00968
    00969 {
    00970   return dbus_g_proxy_call (proxy, "setCursorHotspot", error, G_TYPE_INT, IN_x, G_TYPE_INT, IN_y, G_TYPE_INVALID, G_TYPE_INVALID);
    00971 }
    00972
    00973 typedef void (*org_freedesktop_gnome_Magnifier_set_cursor_hotspot_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    00974
    00975 static void
    00976 org_freedesktop_gnome_Magnifier_set_cursor_hotspot_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    00977 {
    00978   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    00979   GError *error = NULL;
    00980   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    00981   (*(org_freedesktop_gnome_Magnifier_set_cursor_hotspot_reply)data->cb) (proxy, error, data->userdata);
    00982   return;
    00983 }
    00984
    00985 static
    00986 #ifdef G_HAVE_INLINE
    00987 inline
    00988 #endif
    00989 DBusGProxyCall*
    00990 org_freedesktop_gnome_Magnifier_set_cursor_hotspot_async (DBusGProxy *proxy, const gint IN_x, const gint IN_y, org_freedesktop_gnome_Magnifier_set_cursor_hotspot_reply callback, gpointer userdata)
    00991
    00992 {
    00993   DBusGAsyncData *stuff;
    00994   stuff = g_slice_new (DBusGAsyncData);
    00995   stuff->cb = G_CALLBACK (callback);
    00996   stuff->userdata = userdata;
    00997   return dbus_g_proxy_begin_call (proxy, "setCursorHotspot", org_freedesktop_gnome_Magnifier_set_cursor_hotspot_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_x, G_TYPE_INT, IN_y, G_TYPE_INVALID);
    00998 }
    00999 static
    01000 #ifdef G_HAVE_INLINE
    01001 inline
    01002 #endif
    01003 gboolean
    01004 org_freedesktop_gnome_Magnifier_get_cursor_hotspot (DBusGProxy *proxy, GArray** OUT_hotspot, GError **error)
    01005
    01006 {
    01007   return dbus_g_proxy_call (proxy, "getCursorHotspot", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_hotspot, G_TYPE_INVALID);
    01008 }
    01009
    01010 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_hotspot_reply) (DBusGProxy *proxy, GArray *OUT_hotspot, GError *error, gpointer userdata);
    01011
    01012 static void
    01013 org_freedesktop_gnome_Magnifier_get_cursor_hotspot_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01014 {
    01015   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01016   GError *error = NULL;
    01017   GArray* OUT_hotspot;
    01018   dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_hotspot, G_TYPE_INVALID);
    01019   (*(org_freedesktop_gnome_Magnifier_get_cursor_hotspot_reply)data->cb) (proxy, OUT_hotspot, error, data->userdata);
    01020   return;
    01021 }
    01022
    01023 static
    01024 #ifdef G_HAVE_INLINE
    01025 inline
    01026 #endif
    01027 DBusGProxyCall*
    01028 org_freedesktop_gnome_Magnifier_get_cursor_hotspot_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_hotspot_reply callback, gpointer userdata)
    01029
    01030 {
    01031   DBusGAsyncData *stuff;
    01032   stuff = g_slice_new (DBusGAsyncData);
    01033   stuff->cb = G_CALLBACK (callback);
    01034   stuff->userdata = userdata;
    01035   return dbus_g_proxy_begin_call (proxy, "getCursorHotspot", org_freedesktop_gnome_Magnifier_get_cursor_hotspot_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01036 }
    01037 static
    01038 #ifdef G_HAVE_INLINE
    01039 inline
    01040 #endif
    01041 gboolean
    01042 org_freedesktop_gnome_Magnifier_get_cursor_default_size (DBusGProxy *proxy, gint* OUT_size, GError **error)
    01043
    01044 {
    01045   return dbus_g_proxy_call (proxy, "getCursorDefaultSize", error, G_TYPE_INVALID, G_TYPE_INT, OUT_size, G_TYPE_INVALID);
    01046 }
    01047
    01048 typedef void (*org_freedesktop_gnome_Magnifier_get_cursor_default_size_reply) (DBusGProxy *proxy, gint OUT_size, GError *error, gpointer userdata);
    01049
    01050 static void
    01051 org_freedesktop_gnome_Magnifier_get_cursor_default_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01052 {
    01053   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01054   GError *error = NULL;
    01055   gint OUT_size;
    01056   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_size, G_TYPE_INVALID);
    01057   (*(org_freedesktop_gnome_Magnifier_get_cursor_default_size_reply)data->cb) (proxy, OUT_size, error, data->userdata);
    01058   return;
    01059 }
    01060
    01061 static
    01062 #ifdef G_HAVE_INLINE
    01063 inline
    01064 #endif
    01065 DBusGProxyCall*
    01066 org_freedesktop_gnome_Magnifier_get_cursor_default_size_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_cursor_default_size_reply callback, gpointer userdata)
    01067
    01068 {
    01069   DBusGAsyncData *stuff;
    01070   stuff = g_slice_new (DBusGAsyncData);
    01071   stuff->cb = G_CALLBACK (callback);
    01072   stuff->userdata = userdata;
    01073   return dbus_g_proxy_begin_call (proxy, "getCursorDefaultSize", org_freedesktop_gnome_Magnifier_get_cursor_default_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01074 }
    01075 static
    01076 #ifdef G_HAVE_INLINE
    01077 inline
    01078 #endif
    01079 gboolean
    01080 org_freedesktop_gnome_Magnifier_set_crosswire_size (DBusGProxy *proxy, const gint IN_size, GError **error)
    01081
    01082 {
    01083   return dbus_g_proxy_call (proxy, "setCrosswireSize", error, G_TYPE_INT, IN_size, G_TYPE_INVALID, G_TYPE_INVALID);
    01084 }
    01085
    01086 typedef void (*org_freedesktop_gnome_Magnifier_set_crosswire_size_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    01087
    01088 static void
    01089 org_freedesktop_gnome_Magnifier_set_crosswire_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01090 {
    01091   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01092   GError *error = NULL;
    01093   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    01094   (*(org_freedesktop_gnome_Magnifier_set_crosswire_size_reply)data->cb) (proxy, error, data->userdata);
    01095   return;
    01096 }
    01097
    01098 static
    01099 #ifdef G_HAVE_INLINE
    01100 inline
    01101 #endif
    01102 DBusGProxyCall*
    01103 org_freedesktop_gnome_Magnifier_set_crosswire_size_async (DBusGProxy *proxy, const gint IN_size, org_freedesktop_gnome_Magnifier_set_crosswire_size_reply callback, gpointer userdata)
    01104
    01105 {
    01106   DBusGAsyncData *stuff;
    01107   stuff = g_slice_new (DBusGAsyncData);
    01108   stuff->cb = G_CALLBACK (callback);
    01109   stuff->userdata = userdata;
    01110   return dbus_g_proxy_begin_call (proxy, "setCrosswireSize", org_freedesktop_gnome_Magnifier_set_crosswire_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_size, G_TYPE_INVALID);
    01111 }
    01112 static
    01113 #ifdef G_HAVE_INLINE
    01114 inline
    01115 #endif
    01116 gboolean
    01117 org_freedesktop_gnome_Magnifier_get_crosswire_size (DBusGProxy *proxy, gint* OUT_size, GError **error)
    01118
    01119 {
    01120   return dbus_g_proxy_call (proxy, "getCrosswireSize", error, G_TYPE_INVALID, G_TYPE_INT, OUT_size, G_TYPE_INVALID);
    01121 }
    01122
    01123 typedef void (*org_freedesktop_gnome_Magnifier_get_crosswire_size_reply) (DBusGProxy *proxy, gint OUT_size, GError *error, gpointer userdata);
    01124
    01125 static void
    01126 org_freedesktop_gnome_Magnifier_get_crosswire_size_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01127 {
    01128   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01129   GError *error = NULL;
    01130   gint OUT_size;
    01131   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_size, G_TYPE_INVALID);
    01132   (*(org_freedesktop_gnome_Magnifier_get_crosswire_size_reply)data->cb) (proxy, OUT_size, error, data->userdata);
    01133   return;
    01134 }
    01135
    01136 static
    01137 #ifdef G_HAVE_INLINE
    01138 inline
    01139 #endif
    01140 DBusGProxyCall*
    01141 org_freedesktop_gnome_Magnifier_get_crosswire_size_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_crosswire_size_reply callback, gpointer userdata)
    01142
    01143 {
    01144   DBusGAsyncData *stuff;
    01145   stuff = g_slice_new (DBusGAsyncData);
    01146   stuff->cb = G_CALLBACK (callback);
    01147   stuff->userdata = userdata;
    01148   return dbus_g_proxy_begin_call (proxy, "getCrosswireSize", org_freedesktop_gnome_Magnifier_get_crosswire_size_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01149 }
    01150 static
    01151 #ifdef G_HAVE_INLINE
    01152 inline
    01153 #endif
    01154 gboolean
    01155 org_freedesktop_gnome_Magnifier_set_crosswire_length (DBusGProxy *proxy, const gint IN_length, GError **error)
    01156
    01157 {
    01158   return dbus_g_proxy_call (proxy, "setCrosswireLength", error, G_TYPE_INT, IN_length, G_TYPE_INVALID, G_TYPE_INVALID);
    01159 }
    01160
    01161 typedef void (*org_freedesktop_gnome_Magnifier_set_crosswire_length_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    01162
    01163 static void
    01164 org_freedesktop_gnome_Magnifier_set_crosswire_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01165 {
    01166   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01167   GError *error = NULL;
    01168   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    01169   (*(org_freedesktop_gnome_Magnifier_set_crosswire_length_reply)data->cb) (proxy, error, data->userdata);
    01170   return;
    01171 }
    01172
    01173 static
    01174 #ifdef G_HAVE_INLINE
    01175 inline
    01176 #endif
    01177 DBusGProxyCall*
    01178 org_freedesktop_gnome_Magnifier_set_crosswire_length_async (DBusGProxy *proxy, const gint IN_length, org_freedesktop_gnome_Magnifier_set_crosswire_length_reply callback, gpointer userdata)
    01179
    01180 {
    01181   DBusGAsyncData *stuff;
    01182   stuff = g_slice_new (DBusGAsyncData);
    01183   stuff->cb = G_CALLBACK (callback);
    01184   stuff->userdata = userdata;
    01185   return dbus_g_proxy_begin_call (proxy, "setCrosswireLength", org_freedesktop_gnome_Magnifier_set_crosswire_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_length, G_TYPE_INVALID);
    01186 }
    01187 static
    01188 #ifdef G_HAVE_INLINE
    01189 inline
    01190 #endif
    01191 gboolean
    01192 org_freedesktop_gnome_Magnifier_get_crosswire_length (DBusGProxy *proxy, gint* OUT_length, GError **error)
    01193
    01194 {
    01195   return dbus_g_proxy_call (proxy, "getCrosswireLength", error, G_TYPE_INVALID, G_TYPE_INT, OUT_length, G_TYPE_INVALID);
    01196 }
    01197
    01198 typedef void (*org_freedesktop_gnome_Magnifier_get_crosswire_length_reply) (DBusGProxy *proxy, gint OUT_length, GError *error, gpointer userdata);
    01199
    01200 static void
    01201 org_freedesktop_gnome_Magnifier_get_crosswire_length_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01202 {
    01203   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01204   GError *error = NULL;
    01205   gint OUT_length;
    01206   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_length, G_TYPE_INVALID);
    01207   (*(org_freedesktop_gnome_Magnifier_get_crosswire_length_reply)data->cb) (proxy, OUT_length, error, data->userdata);
    01208   return;
    01209 }
    01210
    01211 static
    01212 #ifdef G_HAVE_INLINE
    01213 inline
    01214 #endif
    01215 DBusGProxyCall*
    01216 org_freedesktop_gnome_Magnifier_get_crosswire_length_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_crosswire_length_reply callback, gpointer userdata)
    01217
    01218 {
    01219   DBusGAsyncData *stuff;
    01220   stuff = g_slice_new (DBusGAsyncData);
    01221   stuff->cb = G_CALLBACK (callback);
    01222   stuff->userdata = userdata;
    01223   return dbus_g_proxy_begin_call (proxy, "getCrosswireLength", org_freedesktop_gnome_Magnifier_get_crosswire_length_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01224 }
    01225 static
    01226 #ifdef G_HAVE_INLINE
    01227 inline
    01228 #endif
    01229 gboolean
    01230 org_freedesktop_gnome_Magnifier_set_crosswire_clip (DBusGProxy *proxy, const gboolean IN_clip, GError **error)
    01231
    01232 {
    01233   return dbus_g_proxy_call (proxy, "setCrosswireClip", error, G_TYPE_BOOLEAN, IN_clip, G_TYPE_INVALID, G_TYPE_INVALID);
    01234 }
    01235
    01236 typedef void (*org_freedesktop_gnome_Magnifier_set_crosswire_clip_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    01237
    01238 static void
    01239 org_freedesktop_gnome_Magnifier_set_crosswire_clip_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01240 {
    01241   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01242   GError *error = NULL;
    01243   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    01244   (*(org_freedesktop_gnome_Magnifier_set_crosswire_clip_reply)data->cb) (proxy, error, data->userdata);
    01245   return;
    01246 }
    01247
    01248 static
    01249 #ifdef G_HAVE_INLINE
    01250 inline
    01251 #endif
    01252 DBusGProxyCall*
    01253 org_freedesktop_gnome_Magnifier_set_crosswire_clip_async (DBusGProxy *proxy, const gboolean IN_clip, org_freedesktop_gnome_Magnifier_set_crosswire_clip_reply callback, gpointer userdata)
    01254
    01255 {
    01256   DBusGAsyncData *stuff;
    01257   stuff = g_slice_new (DBusGAsyncData);
    01258   stuff->cb = G_CALLBACK (callback);
    01259   stuff->userdata = userdata;
    01260   return dbus_g_proxy_begin_call (proxy, "setCrosswireClip", org_freedesktop_gnome_Magnifier_set_crosswire_clip_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_clip, G_TYPE_INVALID);
    01261 }
    01262 static
    01263 #ifdef G_HAVE_INLINE
    01264 inline
    01265 #endif
    01266 gboolean
    01267 org_freedesktop_gnome_Magnifier_get_crosswire_clip (DBusGProxy *proxy, gboolean* OUT_clip, GError **error)
    01268
    01269 {
    01270   return dbus_g_proxy_call (proxy, "getCrosswireClip", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_clip, G_TYPE_INVALID);
    01271 }
    01272
    01273 typedef void (*org_freedesktop_gnome_Magnifier_get_crosswire_clip_reply) (DBusGProxy *proxy, gboolean OUT_clip, GError *error, gpointer userdata);
    01274
    01275 static void
    01276 org_freedesktop_gnome_Magnifier_get_crosswire_clip_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01277 {
    01278   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01279   GError *error = NULL;
    01280   gboolean OUT_clip;
    01281   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_clip, G_TYPE_INVALID);
    01282   (*(org_freedesktop_gnome_Magnifier_get_crosswire_clip_reply)data->cb) (proxy, OUT_clip, error, data->userdata);
    01283   return;
    01284 }
    01285
    01286 static
    01287 #ifdef G_HAVE_INLINE
    01288 inline
    01289 #endif
    01290 DBusGProxyCall*
    01291 org_freedesktop_gnome_Magnifier_get_crosswire_clip_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_crosswire_clip_reply callback, gpointer userdata)
    01292
    01293 {
    01294   DBusGAsyncData *stuff;
    01295   stuff = g_slice_new (DBusGAsyncData);
    01296   stuff->cb = G_CALLBACK (callback);
    01297   stuff->userdata = userdata;
    01298   return dbus_g_proxy_begin_call (proxy, "getCrosswireClip", org_freedesktop_gnome_Magnifier_get_crosswire_clip_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01299 }
    01300 static
    01301 #ifdef G_HAVE_INLINE
    01302 inline
    01303 #endif
    01304 gboolean
    01305 org_freedesktop_gnome_Magnifier_set_crosswire_color (DBusGProxy *proxy, const guint IN_color, GError **error)
    01306
    01307 {
    01308   return dbus_g_proxy_call (proxy, "setCrosswireColor", error, G_TYPE_UINT, IN_color, G_TYPE_INVALID, G_TYPE_INVALID);
    01309 }
    01310
    01311 typedef void (*org_freedesktop_gnome_Magnifier_set_crosswire_color_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
    01312
    01313 static void
    01314 org_freedesktop_gnome_Magnifier_set_crosswire_color_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01315 {
    01316   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01317   GError *error = NULL;
    01318   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
    01319   (*(org_freedesktop_gnome_Magnifier_set_crosswire_color_reply)data->cb) (proxy, error, data->userdata);
    01320   return;
    01321 }
    01322
    01323 static
    01324 #ifdef G_HAVE_INLINE
    01325 inline
    01326 #endif
    01327 DBusGProxyCall*
    01328 org_freedesktop_gnome_Magnifier_set_crosswire_color_async (DBusGProxy *proxy, const guint IN_color, org_freedesktop_gnome_Magnifier_set_crosswire_color_reply callback, gpointer userdata)
    01329
    01330 {
    01331   DBusGAsyncData *stuff;
    01332   stuff = g_slice_new (DBusGAsyncData);
    01333   stuff->cb = G_CALLBACK (callback);
    01334   stuff->userdata = userdata;
    01335   return dbus_g_proxy_begin_call (proxy, "setCrosswireColor", org_freedesktop_gnome_Magnifier_set_crosswire_color_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_color, G_TYPE_INVALID);
    01336 }
    01337 static
    01338 #ifdef G_HAVE_INLINE
    01339 inline
    01340 #endif
    01341 gboolean
    01342 org_freedesktop_gnome_Magnifier_get_crosswire_color (DBusGProxy *proxy, guint* OUT_color, GError **error)
    01343
    01344 {
    01345   return dbus_g_proxy_call (proxy, "getCrosswireColor", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_color, G_TYPE_INVALID);
    01346 }
    01347
    01348 typedef void (*org_freedesktop_gnome_Magnifier_get_crosswire_color_reply) (DBusGProxy *proxy, guint OUT_color, GError *error, gpointer userdata);
    01349
    01350 static void
    01351 org_freedesktop_gnome_Magnifier_get_crosswire_color_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
    01352 {
    01353   DBusGAsyncData *data = (DBusGAsyncData*) user_data;
    01354   GError *error = NULL;
    01355   guint OUT_color;
    01356   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_color, G_TYPE_INVALID);
    01357   (*(org_freedesktop_gnome_Magnifier_get_crosswire_color_reply)data->cb) (proxy, OUT_color, error, data->userdata);
    01358   return;
    01359 }
    01360
    01361 static
    01362 #ifdef G_HAVE_INLINE
    01363 inline
    01364 #endif
    01365 DBusGProxyCall*
    01366 org_freedesktop_gnome_Magnifier_get_crosswire_color_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_get_crosswire_color_reply callback, gpointer userdata)
    01367
    01368 {
    01369   DBusGAsyncData *stuff;
    01370   stuff = g_slice_new (DBusGAsyncData);
    01371   stuff->cb = G_CALLBACK (callback);
    01372   stuff->userdata = userdata;
    01373   return dbus_g_proxy_begin_call (proxy, "getCrosswireColor", org_freedesktop_gnome_Magnifier_get_crosswire_color_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
    01374 }
    01375 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_gnome_Magnifier */
    01376
    01377 G_END_DECLS