00001
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
01376
01377 G_END_DECLS