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_ZoomRegion
00022 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_gnome_Magnifier_ZoomRegion
00023
00024 static
00025 #ifdef G_HAVE_INLINE
00026 inline
00027 #endif
00028 gboolean
00029 org_freedesktop_gnome_Magnifier_ZoomRegion_set_mag_factor (DBusGProxy *proxy, const gdouble IN_magX, const gdouble IN_magY, gboolean* OUT_b_ret, GError **error)
00030
00031 {
00032 return dbus_g_proxy_call (proxy, "setMagFactor", error, G_TYPE_DOUBLE, IN_magX, G_TYPE_DOUBLE, IN_magY, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_b_ret, G_TYPE_INVALID);
00033 }
00034
00035 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_mag_factor_reply) (DBusGProxy *proxy, gboolean OUT_b_ret, GError *error, gpointer userdata);
00036
00037 static void
00038 org_freedesktop_gnome_Magnifier_ZoomRegion_set_mag_factor_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_ZoomRegion_set_mag_factor_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_ZoomRegion_set_mag_factor_async (DBusGProxy *proxy, const gdouble IN_magX, const gdouble IN_magY, org_freedesktop_gnome_Magnifier_ZoomRegion_set_mag_factor_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, "setMagFactor", org_freedesktop_gnome_Magnifier_ZoomRegion_set_mag_factor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_magX, G_TYPE_DOUBLE, IN_magY, G_TYPE_INVALID);
00061 }
00062 static
00063 #ifdef G_HAVE_INLINE
00064 inline
00065 #endif
00066 gboolean
00067 org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor (DBusGProxy *proxy, GArray** OUT_factors, GError **error)
00068
00069 {
00070 return dbus_g_proxy_call (proxy, "getMagFactor", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), OUT_factors, G_TYPE_INVALID);
00071 }
00072
00073 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_reply) (DBusGProxy *proxy, GArray *OUT_factors, GError *error, gpointer userdata);
00074
00075 static void
00076 org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00077 {
00078 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00079 GError *error = NULL;
00080 GArray* OUT_factors;
00081 dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), &OUT_factors, G_TYPE_INVALID);
00082 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_reply)data->cb) (proxy, OUT_factors, error, data->userdata);
00083 return;
00084 }
00085
00086 static
00087 #ifdef G_HAVE_INLINE
00088 inline
00089 #endif
00090 DBusGProxyCall*
00091 org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_reply callback, gpointer userdata)
00092
00093 {
00094 DBusGAsyncData *stuff;
00095 stuff = g_slice_new (DBusGAsyncData);
00096 stuff->cb = G_CALLBACK (callback);
00097 stuff->userdata = userdata;
00098 return dbus_g_proxy_begin_call (proxy, "getMagFactor", org_freedesktop_gnome_Magnifier_ZoomRegion_get_mag_factor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00099 }
00100 static
00101 #ifdef G_HAVE_INLINE
00102 inline
00103 #endif
00104 gboolean
00105 org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi (DBusGProxy *proxy, const GArray* IN_Roi, GError **error)
00106
00107 {
00108 return dbus_g_proxy_call (proxy, "setRoi", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_Roi, G_TYPE_INVALID, G_TYPE_INVALID);
00109 }
00110
00111 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00112
00113 static void
00114 org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00115 {
00116 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00117 GError *error = NULL;
00118 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00119 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_reply)data->cb) (proxy, error, data->userdata);
00120 return;
00121 }
00122
00123 static
00124 #ifdef G_HAVE_INLINE
00125 inline
00126 #endif
00127 DBusGProxyCall*
00128 org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_async (DBusGProxy *proxy, const GArray* IN_Roi, org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_reply callback, gpointer userdata)
00129
00130 {
00131 DBusGAsyncData *stuff;
00132 stuff = g_slice_new (DBusGAsyncData);
00133 stuff->cb = G_CALLBACK (callback);
00134 stuff->userdata = userdata;
00135 return dbus_g_proxy_begin_call (proxy, "setRoi", org_freedesktop_gnome_Magnifier_ZoomRegion_set_roi_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_Roi, G_TYPE_INVALID);
00136 }
00137 static
00138 #ifdef G_HAVE_INLINE
00139 inline
00140 #endif
00141 gboolean
00142 org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer (DBusGProxy *proxy, GError **error)
00143
00144 {
00145 return dbus_g_proxy_call (proxy, "updatePointer", error, G_TYPE_INVALID, G_TYPE_INVALID);
00146 }
00147
00148 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00149
00150 static void
00151 org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00152 {
00153 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00154 GError *error = NULL;
00155 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00156 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer_reply)data->cb) (proxy, 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_ZoomRegion_update_pointer_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer_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, "updatePointer", org_freedesktop_gnome_Magnifier_ZoomRegion_update_pointer_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_ZoomRegion_mark_dirty (DBusGProxy *proxy, const GArray* IN_dirtyRegion, GError **error)
00180
00181 {
00182 return dbus_g_proxy_call (proxy, "markDirty", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_dirtyRegion, G_TYPE_INVALID, G_TYPE_INVALID);
00183 }
00184
00185 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00186
00187 static void
00188 org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00189 {
00190 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00191 GError *error = NULL;
00192 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00193 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_reply)data->cb) (proxy, error, data->userdata);
00194 return;
00195 }
00196
00197 static
00198 #ifdef G_HAVE_INLINE
00199 inline
00200 #endif
00201 DBusGProxyCall*
00202 org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_async (DBusGProxy *proxy, const GArray* IN_dirtyRegion, org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_reply callback, gpointer userdata)
00203
00204 {
00205 DBusGAsyncData *stuff;
00206 stuff = g_slice_new (DBusGAsyncData);
00207 stuff->cb = G_CALLBACK (callback);
00208 stuff->userdata = userdata;
00209 return dbus_g_proxy_begin_call (proxy, "markDirty", org_freedesktop_gnome_Magnifier_ZoomRegion_mark_dirty_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_dirtyRegion, G_TYPE_INVALID);
00210 }
00211 static
00212 #ifdef G_HAVE_INLINE
00213 inline
00214 #endif
00215 gboolean
00216 org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi (DBusGProxy *proxy, GArray** OUT_Roi-ret, GError **error)
00217
00218 {
00219 return dbus_g_proxy_call (proxy, "getRoi", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_Roi-ret, G_TYPE_INVALID);
00220 }
00221
00222 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_reply) (DBusGProxy *proxy, GArray *OUT_Roi-ret, GError *error, gpointer userdata);
00223
00224 static void
00225 org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00226 {
00227 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00228 GError *error = NULL;
00229 GArray* OUT_Roi-ret;
00230 dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_Roi-ret, G_TYPE_INVALID);
00231 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_reply)data->cb) (proxy, OUT_Roi-ret, error, data->userdata);
00232 return;
00233 }
00234
00235 static
00236 #ifdef G_HAVE_INLINE
00237 inline
00238 #endif
00239 DBusGProxyCall*
00240 org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_reply callback, gpointer userdata)
00241
00242 {
00243 DBusGAsyncData *stuff;
00244 stuff = g_slice_new (DBusGAsyncData);
00245 stuff->cb = G_CALLBACK (callback);
00246 stuff->userdata = userdata;
00247 return dbus_g_proxy_begin_call (proxy, "getRoi", org_freedesktop_gnome_Magnifier_ZoomRegion_get_roi_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00248 }
00249 static
00250 #ifdef G_HAVE_INLINE
00251 inline
00252 #endif
00253 gboolean
00254 org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize (DBusGProxy *proxy, const GArray* IN_bounds, GError **error)
00255
00256 {
00257 return dbus_g_proxy_call (proxy, "moveResize", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_bounds, G_TYPE_INVALID, G_TYPE_INVALID);
00258 }
00259
00260 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00261
00262 static void
00263 org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00264 {
00265 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00266 GError *error = NULL;
00267 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00268 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_reply)data->cb) (proxy, error, data->userdata);
00269 return;
00270 }
00271
00272 static
00273 #ifdef G_HAVE_INLINE
00274 inline
00275 #endif
00276 DBusGProxyCall*
00277 org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_async (DBusGProxy *proxy, const GArray* IN_bounds, org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_reply callback, gpointer userdata)
00278
00279 {
00280 DBusGAsyncData *stuff;
00281 stuff = g_slice_new (DBusGAsyncData);
00282 stuff->cb = G_CALLBACK (callback);
00283 stuff->userdata = userdata;
00284 return dbus_g_proxy_begin_call (proxy, "moveResize", org_freedesktop_gnome_Magnifier_ZoomRegion_move_resize_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_bounds, G_TYPE_INVALID);
00285 }
00286 static
00287 #ifdef G_HAVE_INLINE
00288 inline
00289 #endif
00290 gboolean
00291 org_freedesktop_gnome_Magnifier_ZoomRegion_dispose (DBusGProxy *proxy, GError **error)
00292
00293 {
00294 return dbus_g_proxy_call (proxy, "dispose", error, G_TYPE_INVALID, G_TYPE_INVALID);
00295 }
00296
00297 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00298
00299 static void
00300 org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00301 {
00302 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00303 GError *error = NULL;
00304 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00305 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_reply)data->cb) (proxy, error, data->userdata);
00306 return;
00307 }
00308
00309 static
00310 #ifdef G_HAVE_INLINE
00311 inline
00312 #endif
00313 DBusGProxyCall*
00314 org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_reply callback, gpointer userdata)
00315
00316 {
00317 DBusGAsyncData *stuff;
00318 stuff = g_slice_new (DBusGAsyncData);
00319 stuff->cb = G_CALLBACK (callback);
00320 stuff->userdata = userdata;
00321 return dbus_g_proxy_begin_call (proxy, "dispose", org_freedesktop_gnome_Magnifier_ZoomRegion_dispose_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00322 }
00323 static
00324 #ifdef G_HAVE_INLINE
00325 inline
00326 #endif
00327 gboolean
00328 org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos (DBusGProxy *proxy, const gint IN_mouse_x, const gint IN_mouse_y, GError **error)
00329
00330 {
00331 return dbus_g_proxy_call (proxy, "setPointerPos", error, G_TYPE_INT, IN_mouse_x, G_TYPE_INT, IN_mouse_y, G_TYPE_INVALID, G_TYPE_INVALID);
00332 }
00333
00334 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00335
00336 static void
00337 org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00338 {
00339 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00340 GError *error = NULL;
00341 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00342 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_reply)data->cb) (proxy, error, data->userdata);
00343 return;
00344 }
00345
00346 static
00347 #ifdef G_HAVE_INLINE
00348 inline
00349 #endif
00350 DBusGProxyCall*
00351 org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_async (DBusGProxy *proxy, const gint IN_mouse_x, const gint IN_mouse_y, org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_reply callback, gpointer userdata)
00352
00353 {
00354 DBusGAsyncData *stuff;
00355 stuff = g_slice_new (DBusGAsyncData);
00356 stuff->cb = G_CALLBACK (callback);
00357 stuff->userdata = userdata;
00358 return dbus_g_proxy_begin_call (proxy, "setPointerPos", org_freedesktop_gnome_Magnifier_ZoomRegion_set_pointer_pos_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_mouse_x, G_TYPE_INT, IN_mouse_y, G_TYPE_INVALID);
00359 }
00360 static
00361 #ifdef G_HAVE_INLINE
00362 inline
00363 #endif
00364 gboolean
00365 org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast (DBusGProxy *proxy, const gdouble IN_R, const gdouble IN_G, const gdouble IN_B, GError **error)
00366
00367 {
00368 return dbus_g_proxy_call (proxy, "setContrast", error, G_TYPE_DOUBLE, IN_R, G_TYPE_DOUBLE, IN_G, G_TYPE_DOUBLE, IN_B, G_TYPE_INVALID, G_TYPE_INVALID);
00369 }
00370
00371 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00372
00373 static void
00374 org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00375 {
00376 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00377 GError *error = NULL;
00378 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00379 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_reply)data->cb) (proxy, error, data->userdata);
00380 return;
00381 }
00382
00383 static
00384 #ifdef G_HAVE_INLINE
00385 inline
00386 #endif
00387 DBusGProxyCall*
00388 org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_async (DBusGProxy *proxy, const gdouble IN_R, const gdouble IN_G, const gdouble IN_B, org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_reply callback, gpointer userdata)
00389
00390 {
00391 DBusGAsyncData *stuff;
00392 stuff = g_slice_new (DBusGAsyncData);
00393 stuff->cb = G_CALLBACK (callback);
00394 stuff->userdata = userdata;
00395 return dbus_g_proxy_begin_call (proxy, "setContrast", org_freedesktop_gnome_Magnifier_ZoomRegion_set_contrast_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_R, G_TYPE_DOUBLE, IN_G, G_TYPE_DOUBLE, IN_B, G_TYPE_INVALID);
00396 }
00397 static
00398 #ifdef G_HAVE_INLINE
00399 inline
00400 #endif
00401 gboolean
00402 org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast (DBusGProxy *proxy, GArray** OUT_RGB, GError **error)
00403
00404 {
00405 return dbus_g_proxy_call (proxy, "getContrast", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), OUT_RGB, G_TYPE_INVALID);
00406 }
00407
00408 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_reply) (DBusGProxy *proxy, GArray *OUT_RGB, GError *error, gpointer userdata);
00409
00410 static void
00411 org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00412 {
00413 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00414 GError *error = NULL;
00415 GArray* OUT_RGB;
00416 dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_DOUBLE), &OUT_RGB, G_TYPE_INVALID);
00417 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_reply)data->cb) (proxy, OUT_RGB, error, data->userdata);
00418 return;
00419 }
00420
00421 static
00422 #ifdef G_HAVE_INLINE
00423 inline
00424 #endif
00425 DBusGProxyCall*
00426 org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_reply callback, gpointer userdata)
00427
00428 {
00429 DBusGAsyncData *stuff;
00430 stuff = g_slice_new (DBusGAsyncData);
00431 stuff->cb = G_CALLBACK (callback);
00432 stuff->userdata = userdata;
00433 return dbus_g_proxy_begin_call (proxy, "getContrast", org_freedesktop_gnome_Magnifier_ZoomRegion_get_contrast_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00434 }
00435 static
00436 #ifdef G_HAVE_INLINE
00437 inline
00438 #endif
00439 gboolean
00440 org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness (DBusGProxy *proxy, const gdouble IN_R, const gdouble IN_G, const gdouble IN_B, GError **error)
00441
00442 {
00443 return dbus_g_proxy_call (proxy, "setBrightness", error, G_TYPE_DOUBLE, IN_R, G_TYPE_DOUBLE, IN_G, G_TYPE_DOUBLE, IN_B, G_TYPE_INVALID, G_TYPE_INVALID);
00444 }
00445
00446 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00447
00448 static void
00449 org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00450 {
00451 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00452 GError *error = NULL;
00453 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00454 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_reply)data->cb) (proxy, error, data->userdata);
00455 return;
00456 }
00457
00458 static
00459 #ifdef G_HAVE_INLINE
00460 inline
00461 #endif
00462 DBusGProxyCall*
00463 org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_async (DBusGProxy *proxy, const gdouble IN_R, const gdouble IN_G, const gdouble IN_B, org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_reply callback, gpointer userdata)
00464
00465 {
00466 DBusGAsyncData *stuff;
00467 stuff = g_slice_new (DBusGAsyncData);
00468 stuff->cb = G_CALLBACK (callback);
00469 stuff->userdata = userdata;
00470 return dbus_g_proxy_begin_call (proxy, "setBrightness", org_freedesktop_gnome_Magnifier_ZoomRegion_set_brightness_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_DOUBLE, IN_R, G_TYPE_DOUBLE, IN_G, G_TYPE_DOUBLE, IN_B, G_TYPE_INVALID);
00471 }
00472 static
00473 #ifdef G_HAVE_INLINE
00474 inline
00475 #endif
00476 gboolean
00477 org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness (DBusGProxy *proxy, gdouble* OUT_RGB, GError **error)
00478
00479 {
00480 return dbus_g_proxy_call (proxy, "getBrightness", error, G_TYPE_INVALID, G_TYPE_DOUBLE, OUT_RGB, G_TYPE_INVALID);
00481 }
00482
00483 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_reply) (DBusGProxy *proxy, gdouble OUT_RGB, GError *error, gpointer userdata);
00484
00485 static void
00486 org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00487 {
00488 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00489 GError *error = NULL;
00490 gdouble OUT_RGB;
00491 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_DOUBLE, &OUT_RGB, G_TYPE_INVALID);
00492 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_reply)data->cb) (proxy, OUT_RGB, error, data->userdata);
00493 return;
00494 }
00495
00496 static
00497 #ifdef G_HAVE_INLINE
00498 inline
00499 #endif
00500 DBusGProxyCall*
00501 org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_reply callback, gpointer userdata)
00502
00503 {
00504 DBusGAsyncData *stuff;
00505 stuff = g_slice_new (DBusGAsyncData);
00506 stuff->cb = G_CALLBACK (callback);
00507 stuff->userdata = userdata;
00508 return dbus_g_proxy_begin_call (proxy, "getBrightness", org_freedesktop_gnome_Magnifier_ZoomRegion_get_brightness_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00509 }
00510 static
00511 #ifdef G_HAVE_INLINE
00512 inline
00513 #endif
00514 gboolean
00515 org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed (DBusGProxy *proxy, const gboolean IN_managed, GError **error)
00516
00517 {
00518 return dbus_g_proxy_call (proxy, "setManaged", error, G_TYPE_BOOLEAN, IN_managed, G_TYPE_INVALID, G_TYPE_INVALID);
00519 }
00520
00521 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00522
00523 static void
00524 org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00525 {
00526 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00527 GError *error = NULL;
00528 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00529 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_reply)data->cb) (proxy, error, data->userdata);
00530 return;
00531 }
00532
00533 static
00534 #ifdef G_HAVE_INLINE
00535 inline
00536 #endif
00537 DBusGProxyCall*
00538 org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_async (DBusGProxy *proxy, const gboolean IN_managed, org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_reply callback, gpointer userdata)
00539
00540 {
00541 DBusGAsyncData *stuff;
00542 stuff = g_slice_new (DBusGAsyncData);
00543 stuff->cb = G_CALLBACK (callback);
00544 stuff->userdata = userdata;
00545 return dbus_g_proxy_begin_call (proxy, "setManaged", org_freedesktop_gnome_Magnifier_ZoomRegion_set_managed_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_managed, G_TYPE_INVALID);
00546 }
00547 static
00548 #ifdef G_HAVE_INLINE
00549 inline
00550 #endif
00551 gboolean
00552 org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed (DBusGProxy *proxy, gboolean* OUT_managed, GError **error)
00553
00554 {
00555 return dbus_g_proxy_call (proxy, "getManaged", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_managed, G_TYPE_INVALID);
00556 }
00557
00558 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_reply) (DBusGProxy *proxy, gboolean OUT_managed, GError *error, gpointer userdata);
00559
00560 static void
00561 org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00562 {
00563 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00564 GError *error = NULL;
00565 gboolean OUT_managed;
00566 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_managed, G_TYPE_INVALID);
00567 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_reply)data->cb) (proxy, OUT_managed, error, data->userdata);
00568 return;
00569 }
00570
00571 static
00572 #ifdef G_HAVE_INLINE
00573 inline
00574 #endif
00575 DBusGProxyCall*
00576 org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_reply callback, gpointer userdata)
00577
00578 {
00579 DBusGAsyncData *stuff;
00580 stuff = g_slice_new (DBusGAsyncData);
00581 stuff->cb = G_CALLBACK (callback);
00582 stuff->userdata = userdata;
00583 return dbus_g_proxy_begin_call (proxy, "getManaged", org_freedesktop_gnome_Magnifier_ZoomRegion_get_managed_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00584 }
00585 static
00586 #ifdef G_HAVE_INLINE
00587 inline
00588 #endif
00589 gboolean
00590 org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse (DBusGProxy *proxy, const gboolean IN_poll_mouse, GError **error)
00591
00592 {
00593 return dbus_g_proxy_call (proxy, "setPollMouse", error, G_TYPE_BOOLEAN, IN_poll_mouse, G_TYPE_INVALID, G_TYPE_INVALID);
00594 }
00595
00596 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00597
00598 static void
00599 org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00600 {
00601 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00602 GError *error = NULL;
00603 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00604 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_reply)data->cb) (proxy, error, data->userdata);
00605 return;
00606 }
00607
00608 static
00609 #ifdef G_HAVE_INLINE
00610 inline
00611 #endif
00612 DBusGProxyCall*
00613 org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_async (DBusGProxy *proxy, const gboolean IN_poll_mouse, org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_reply callback, gpointer userdata)
00614
00615 {
00616 DBusGAsyncData *stuff;
00617 stuff = g_slice_new (DBusGAsyncData);
00618 stuff->cb = G_CALLBACK (callback);
00619 stuff->userdata = userdata;
00620 return dbus_g_proxy_begin_call (proxy, "setPollMouse", org_freedesktop_gnome_Magnifier_ZoomRegion_set_poll_mouse_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_poll_mouse, G_TYPE_INVALID);
00621 }
00622 static
00623 #ifdef G_HAVE_INLINE
00624 inline
00625 #endif
00626 gboolean
00627 org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse (DBusGProxy *proxy, gboolean* OUT_poll_mouse, GError **error)
00628
00629 {
00630 return dbus_g_proxy_call (proxy, "getPollMouse", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_poll_mouse, G_TYPE_INVALID);
00631 }
00632
00633 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_reply) (DBusGProxy *proxy, gboolean OUT_poll_mouse, GError *error, gpointer userdata);
00634
00635 static void
00636 org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00637 {
00638 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00639 GError *error = NULL;
00640 gboolean OUT_poll_mouse;
00641 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_poll_mouse, G_TYPE_INVALID);
00642 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_reply)data->cb) (proxy, OUT_poll_mouse, error, data->userdata);
00643 return;
00644 }
00645
00646 static
00647 #ifdef G_HAVE_INLINE
00648 inline
00649 #endif
00650 DBusGProxyCall*
00651 org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_reply callback, gpointer userdata)
00652
00653 {
00654 DBusGAsyncData *stuff;
00655 stuff = g_slice_new (DBusGAsyncData);
00656 stuff->cb = G_CALLBACK (callback);
00657 stuff->userdata = userdata;
00658 return dbus_g_proxy_begin_call (proxy, "getPollMouse", org_freedesktop_gnome_Magnifier_ZoomRegion_get_poll_mouse_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00659 }
00660 static
00661 #ifdef G_HAVE_INLINE
00662 inline
00663 #endif
00664 gboolean
00665 org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor (DBusGProxy *proxy, const gboolean IN_draw_cursor, GError **error)
00666
00667 {
00668 return dbus_g_proxy_call (proxy, "setDrawCursor", error, G_TYPE_BOOLEAN, IN_draw_cursor, G_TYPE_INVALID, G_TYPE_INVALID);
00669 }
00670
00671 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00672
00673 static void
00674 org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00675 {
00676 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00677 GError *error = NULL;
00678 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00679 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_reply)data->cb) (proxy, error, data->userdata);
00680 return;
00681 }
00682
00683 static
00684 #ifdef G_HAVE_INLINE
00685 inline
00686 #endif
00687 DBusGProxyCall*
00688 org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_async (DBusGProxy *proxy, const gboolean IN_draw_cursor, org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_reply callback, gpointer userdata)
00689
00690 {
00691 DBusGAsyncData *stuff;
00692 stuff = g_slice_new (DBusGAsyncData);
00693 stuff->cb = G_CALLBACK (callback);
00694 stuff->userdata = userdata;
00695 return dbus_g_proxy_begin_call (proxy, "setDrawCursor", org_freedesktop_gnome_Magnifier_ZoomRegion_set_draw_cursor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_draw_cursor, G_TYPE_INVALID);
00696 }
00697 static
00698 #ifdef G_HAVE_INLINE
00699 inline
00700 #endif
00701 gboolean
00702 org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor (DBusGProxy *proxy, gboolean* OUT_draw_cursor, GError **error)
00703
00704 {
00705 return dbus_g_proxy_call (proxy, "getDrawCursor", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_draw_cursor, G_TYPE_INVALID);
00706 }
00707
00708 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_reply) (DBusGProxy *proxy, gboolean OUT_draw_cursor, GError *error, gpointer userdata);
00709
00710 static void
00711 org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00712 {
00713 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00714 GError *error = NULL;
00715 gboolean OUT_draw_cursor;
00716 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_draw_cursor, G_TYPE_INVALID);
00717 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_reply)data->cb) (proxy, OUT_draw_cursor, error, data->userdata);
00718 return;
00719 }
00720
00721 static
00722 #ifdef G_HAVE_INLINE
00723 inline
00724 #endif
00725 DBusGProxyCall*
00726 org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_reply callback, gpointer userdata)
00727
00728 {
00729 DBusGAsyncData *stuff;
00730 stuff = g_slice_new (DBusGAsyncData);
00731 stuff->cb = G_CALLBACK (callback);
00732 stuff->userdata = userdata;
00733 return dbus_g_proxy_begin_call (proxy, "getDrawCursor", org_freedesktop_gnome_Magnifier_ZoomRegion_get_draw_cursor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00734 }
00735 static
00736 #ifdef G_HAVE_INLINE
00737 inline
00738 #endif
00739 gboolean
00740 org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert (DBusGProxy *proxy, const gboolean IN_invert, GError **error)
00741
00742 {
00743 return dbus_g_proxy_call (proxy, "setInvert", error, G_TYPE_BOOLEAN, IN_invert, G_TYPE_INVALID, G_TYPE_INVALID);
00744 }
00745
00746 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00747
00748 static void
00749 org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00750 {
00751 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00752 GError *error = NULL;
00753 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00754 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_reply)data->cb) (proxy, error, data->userdata);
00755 return;
00756 }
00757
00758 static
00759 #ifdef G_HAVE_INLINE
00760 inline
00761 #endif
00762 DBusGProxyCall*
00763 org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_async (DBusGProxy *proxy, const gboolean IN_invert, org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_reply callback, gpointer userdata)
00764
00765 {
00766 DBusGAsyncData *stuff;
00767 stuff = g_slice_new (DBusGAsyncData);
00768 stuff->cb = G_CALLBACK (callback);
00769 stuff->userdata = userdata;
00770 return dbus_g_proxy_begin_call (proxy, "setInvert", org_freedesktop_gnome_Magnifier_ZoomRegion_set_invert_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_invert, G_TYPE_INVALID);
00771 }
00772 static
00773 #ifdef G_HAVE_INLINE
00774 inline
00775 #endif
00776 gboolean
00777 org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert (DBusGProxy *proxy, gboolean* OUT_invert, GError **error)
00778
00779 {
00780 return dbus_g_proxy_call (proxy, "getInvert", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_invert, G_TYPE_INVALID);
00781 }
00782
00783 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_reply) (DBusGProxy *proxy, gboolean OUT_invert, GError *error, gpointer userdata);
00784
00785 static void
00786 org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00787 {
00788 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00789 GError *error = NULL;
00790 gboolean OUT_invert;
00791 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_invert, G_TYPE_INVALID);
00792 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_reply)data->cb) (proxy, OUT_invert, error, data->userdata);
00793 return;
00794 }
00795
00796 static
00797 #ifdef G_HAVE_INLINE
00798 inline
00799 #endif
00800 DBusGProxyCall*
00801 org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_reply callback, gpointer userdata)
00802
00803 {
00804 DBusGAsyncData *stuff;
00805 stuff = g_slice_new (DBusGAsyncData);
00806 stuff->cb = G_CALLBACK (callback);
00807 stuff->userdata = userdata;
00808 return dbus_g_proxy_begin_call (proxy, "getInvert", org_freedesktop_gnome_Magnifier_ZoomRegion_get_invert_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00809 }
00810 static
00811 #ifdef G_HAVE_INLINE
00812 inline
00813 #endif
00814 gboolean
00815 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll (DBusGProxy *proxy, const gint IN_smoothscroll, GError **error)
00816
00817 {
00818 return dbus_g_proxy_call (proxy, "setSmoothscroll", error, G_TYPE_INT, IN_smoothscroll, G_TYPE_INVALID, G_TYPE_INVALID);
00819 }
00820
00821 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00822
00823 static void
00824 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00825 {
00826 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00827 GError *error = NULL;
00828 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00829 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_reply)data->cb) (proxy, error, data->userdata);
00830 return;
00831 }
00832
00833 static
00834 #ifdef G_HAVE_INLINE
00835 inline
00836 #endif
00837 DBusGProxyCall*
00838 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_async (DBusGProxy *proxy, const gint IN_smoothscroll, org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_reply callback, gpointer userdata)
00839
00840 {
00841 DBusGAsyncData *stuff;
00842 stuff = g_slice_new (DBusGAsyncData);
00843 stuff->cb = G_CALLBACK (callback);
00844 stuff->userdata = userdata;
00845 return dbus_g_proxy_begin_call (proxy, "setSmoothscroll", org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothscroll_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_smoothscroll, G_TYPE_INVALID);
00846 }
00847 static
00848 #ifdef G_HAVE_INLINE
00849 inline
00850 #endif
00851 gboolean
00852 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll (DBusGProxy *proxy, gint* OUT_smoothscroll, GError **error)
00853
00854 {
00855 return dbus_g_proxy_call (proxy, "getSmoothscroll", error, G_TYPE_INVALID, G_TYPE_INT, OUT_smoothscroll, G_TYPE_INVALID);
00856 }
00857
00858 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_reply) (DBusGProxy *proxy, gint OUT_smoothscroll, GError *error, gpointer userdata);
00859
00860 static void
00861 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00862 {
00863 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00864 GError *error = NULL;
00865 gint OUT_smoothscroll;
00866 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_smoothscroll, G_TYPE_INVALID);
00867 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_reply)data->cb) (proxy, OUT_smoothscroll, error, data->userdata);
00868 return;
00869 }
00870
00871 static
00872 #ifdef G_HAVE_INLINE
00873 inline
00874 #endif
00875 DBusGProxyCall*
00876 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_reply callback, gpointer userdata)
00877
00878 {
00879 DBusGAsyncData *stuff;
00880 stuff = g_slice_new (DBusGAsyncData);
00881 stuff->cb = G_CALLBACK (callback);
00882 stuff->userdata = userdata;
00883 return dbus_g_proxy_begin_call (proxy, "getSmoothscroll", org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothscroll_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00884 }
00885 static
00886 #ifdef G_HAVE_INLINE
00887 inline
00888 #endif
00889 gboolean
00890 org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind (DBusGProxy *proxy, const gint IN_colorblind, GError **error)
00891
00892 {
00893 return dbus_g_proxy_call (proxy, "setColorblind", error, G_TYPE_INT, IN_colorblind, G_TYPE_INVALID, G_TYPE_INVALID);
00894 }
00895
00896 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00897
00898 static void
00899 org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00900 {
00901 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00902 GError *error = NULL;
00903 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00904 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_reply)data->cb) (proxy, error, data->userdata);
00905 return;
00906 }
00907
00908 static
00909 #ifdef G_HAVE_INLINE
00910 inline
00911 #endif
00912 DBusGProxyCall*
00913 org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_async (DBusGProxy *proxy, const gint IN_colorblind, org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_reply callback, gpointer userdata)
00914
00915 {
00916 DBusGAsyncData *stuff;
00917 stuff = g_slice_new (DBusGAsyncData);
00918 stuff->cb = G_CALLBACK (callback);
00919 stuff->userdata = userdata;
00920 return dbus_g_proxy_begin_call (proxy, "setColorblind", org_freedesktop_gnome_Magnifier_ZoomRegion_set_colorblind_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_colorblind, G_TYPE_INVALID);
00921 }
00922 static
00923 #ifdef G_HAVE_INLINE
00924 inline
00925 #endif
00926 gboolean
00927 org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind (DBusGProxy *proxy, gint* OUT_colorblind, GError **error)
00928
00929 {
00930 return dbus_g_proxy_call (proxy, "getColorblind", error, G_TYPE_INVALID, G_TYPE_INT, OUT_colorblind, G_TYPE_INVALID);
00931 }
00932
00933 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_reply) (DBusGProxy *proxy, gint OUT_colorblind, GError *error, gpointer userdata);
00934
00935 static void
00936 org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00937 {
00938 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00939 GError *error = NULL;
00940 gint OUT_colorblind;
00941 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_colorblind, G_TYPE_INVALID);
00942 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_reply)data->cb) (proxy, OUT_colorblind, error, data->userdata);
00943 return;
00944 }
00945
00946 static
00947 #ifdef G_HAVE_INLINE
00948 inline
00949 #endif
00950 DBusGProxyCall*
00951 org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_reply callback, gpointer userdata)
00952
00953 {
00954 DBusGAsyncData *stuff;
00955 stuff = g_slice_new (DBusGAsyncData);
00956 stuff->cb = G_CALLBACK (callback);
00957 stuff->userdata = userdata;
00958 return dbus_g_proxy_begin_call (proxy, "getColorblind", org_freedesktop_gnome_Magnifier_ZoomRegion_get_colorblind_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
00959 }
00960 static
00961 #ifdef G_HAVE_INLINE
00962 inline
00963 #endif
00964 gboolean
00965 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing (DBusGProxy *proxy, const char * IN_smoothing, GError **error)
00966
00967 {
00968 return dbus_g_proxy_call (proxy, "setSmoothing", error, G_TYPE_STRING, IN_smoothing, G_TYPE_INVALID, G_TYPE_INVALID);
00969 }
00970
00971 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
00972
00973 static void
00974 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
00975 {
00976 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
00977 GError *error = NULL;
00978 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
00979 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_reply)data->cb) (proxy, error, data->userdata);
00980 return;
00981 }
00982
00983 static
00984 #ifdef G_HAVE_INLINE
00985 inline
00986 #endif
00987 DBusGProxyCall*
00988 org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_async (DBusGProxy *proxy, const char * IN_smoothing, org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_reply callback, gpointer userdata)
00989
00990 {
00991 DBusGAsyncData *stuff;
00992 stuff = g_slice_new (DBusGAsyncData);
00993 stuff->cb = G_CALLBACK (callback);
00994 stuff->userdata = userdata;
00995 return dbus_g_proxy_begin_call (proxy, "setSmoothing", org_freedesktop_gnome_Magnifier_ZoomRegion_set_smoothing_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_smoothing, G_TYPE_INVALID);
00996 }
00997 static
00998 #ifdef G_HAVE_INLINE
00999 inline
01000 #endif
01001 gboolean
01002 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing (DBusGProxy *proxy, char ** OUT_smoothing, GError **error)
01003
01004 {
01005 return dbus_g_proxy_call (proxy, "getSmoothing", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_smoothing, G_TYPE_INVALID);
01006 }
01007
01008 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_reply) (DBusGProxy *proxy, char * OUT_smoothing, GError *error, gpointer userdata);
01009
01010 static void
01011 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01012 {
01013 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01014 GError *error = NULL;
01015 char * OUT_smoothing;
01016 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_smoothing, G_TYPE_INVALID);
01017 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_reply)data->cb) (proxy, OUT_smoothing, error, data->userdata);
01018 return;
01019 }
01020
01021 static
01022 #ifdef G_HAVE_INLINE
01023 inline
01024 #endif
01025 DBusGProxyCall*
01026 org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_reply callback, gpointer userdata)
01027
01028 {
01029 DBusGAsyncData *stuff;
01030 stuff = g_slice_new (DBusGAsyncData);
01031 stuff->cb = G_CALLBACK (callback);
01032 stuff->userdata = userdata;
01033 return dbus_g_proxy_begin_call (proxy, "getSmoothing", org_freedesktop_gnome_Magnifier_ZoomRegion_get_smoothing_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01034 }
01035 static
01036 #ifdef G_HAVE_INLINE
01037 inline
01038 #endif
01039 gboolean
01040 org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern (DBusGProxy *proxy, const gboolean IN_testpattern, GError **error)
01041
01042 {
01043 return dbus_g_proxy_call (proxy, "setTestpattern", error, G_TYPE_BOOLEAN, IN_testpattern, G_TYPE_INVALID, G_TYPE_INVALID);
01044 }
01045
01046 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01047
01048 static void
01049 org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01050 {
01051 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01052 GError *error = NULL;
01053 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01054 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_reply)data->cb) (proxy, error, data->userdata);
01055 return;
01056 }
01057
01058 static
01059 #ifdef G_HAVE_INLINE
01060 inline
01061 #endif
01062 DBusGProxyCall*
01063 org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_async (DBusGProxy *proxy, const gboolean IN_testpattern, org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_reply callback, gpointer userdata)
01064
01065 {
01066 DBusGAsyncData *stuff;
01067 stuff = g_slice_new (DBusGAsyncData);
01068 stuff->cb = G_CALLBACK (callback);
01069 stuff->userdata = userdata;
01070 return dbus_g_proxy_begin_call (proxy, "setTestpattern", org_freedesktop_gnome_Magnifier_ZoomRegion_set_testpattern_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_testpattern, G_TYPE_INVALID);
01071 }
01072 static
01073 #ifdef G_HAVE_INLINE
01074 inline
01075 #endif
01076 gboolean
01077 org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern (DBusGProxy *proxy, gboolean* OUT_testpattern, GError **error)
01078
01079 {
01080 return dbus_g_proxy_call (proxy, "getTestpattern", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_testpattern, G_TYPE_INVALID);
01081 }
01082
01083 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_reply) (DBusGProxy *proxy, gboolean OUT_testpattern, GError *error, gpointer userdata);
01084
01085 static void
01086 org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01087 {
01088 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01089 GError *error = NULL;
01090 gboolean OUT_testpattern;
01091 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_testpattern, G_TYPE_INVALID);
01092 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_reply)data->cb) (proxy, OUT_testpattern, error, data->userdata);
01093 return;
01094 }
01095
01096 static
01097 #ifdef G_HAVE_INLINE
01098 inline
01099 #endif
01100 DBusGProxyCall*
01101 org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_reply callback, gpointer userdata)
01102
01103 {
01104 DBusGAsyncData *stuff;
01105 stuff = g_slice_new (DBusGAsyncData);
01106 stuff->cb = G_CALLBACK (callback);
01107 stuff->userdata = userdata;
01108 return dbus_g_proxy_begin_call (proxy, "getTestpattern", org_freedesktop_gnome_Magnifier_ZoomRegion_get_testpattern_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01109 }
01110 static
01111 #ifdef G_HAVE_INLINE
01112 inline
01113 #endif
01114 gboolean
01115 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes (DBusGProxy *proxy, const GArray* IN_bordersizes, GError **error)
01116
01117 {
01118 return dbus_g_proxy_call (proxy, "setBordersizes", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_bordersizes, G_TYPE_INVALID, G_TYPE_INVALID);
01119 }
01120
01121 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01122
01123 static void
01124 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01125 {
01126 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01127 GError *error = NULL;
01128 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01129 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_reply)data->cb) (proxy, error, data->userdata);
01130 return;
01131 }
01132
01133 static
01134 #ifdef G_HAVE_INLINE
01135 inline
01136 #endif
01137 DBusGProxyCall*
01138 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_async (DBusGProxy *proxy, const GArray* IN_bordersizes, org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_reply callback, gpointer userdata)
01139
01140 {
01141 DBusGAsyncData *stuff;
01142 stuff = g_slice_new (DBusGAsyncData);
01143 stuff->cb = G_CALLBACK (callback);
01144 stuff->userdata = userdata;
01145 return dbus_g_proxy_begin_call (proxy, "setBordersizes", org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordersizes_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_bordersizes, G_TYPE_INVALID);
01146 }
01147 static
01148 #ifdef G_HAVE_INLINE
01149 inline
01150 #endif
01151 gboolean
01152 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes (DBusGProxy *proxy, GArray** OUT_bordersizes, GError **error)
01153
01154 {
01155 return dbus_g_proxy_call (proxy, "getBordersizes", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_bordersizes, G_TYPE_INVALID);
01156 }
01157
01158 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_reply) (DBusGProxy *proxy, GArray *OUT_bordersizes, GError *error, gpointer userdata);
01159
01160 static void
01161 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01162 {
01163 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01164 GError *error = NULL;
01165 GArray* OUT_bordersizes;
01166 dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_bordersizes, G_TYPE_INVALID);
01167 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_reply)data->cb) (proxy, OUT_bordersizes, error, data->userdata);
01168 return;
01169 }
01170
01171 static
01172 #ifdef G_HAVE_INLINE
01173 inline
01174 #endif
01175 DBusGProxyCall*
01176 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_reply callback, gpointer userdata)
01177
01178 {
01179 DBusGAsyncData *stuff;
01180 stuff = g_slice_new (DBusGAsyncData);
01181 stuff->cb = G_CALLBACK (callback);
01182 stuff->userdata = userdata;
01183 return dbus_g_proxy_begin_call (proxy, "getBordersizes", org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordersizes_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01184 }
01185 static
01186 #ifdef G_HAVE_INLINE
01187 inline
01188 #endif
01189 gboolean
01190 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor (DBusGProxy *proxy, const guint IN_bordercolor, GError **error)
01191
01192 {
01193 return dbus_g_proxy_call (proxy, "setBordercolor", error, G_TYPE_UINT, IN_bordercolor, G_TYPE_INVALID, G_TYPE_INVALID);
01194 }
01195
01196 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01197
01198 static void
01199 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01200 {
01201 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01202 GError *error = NULL;
01203 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01204 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_reply)data->cb) (proxy, error, data->userdata);
01205 return;
01206 }
01207
01208 static
01209 #ifdef G_HAVE_INLINE
01210 inline
01211 #endif
01212 DBusGProxyCall*
01213 org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_async (DBusGProxy *proxy, const guint IN_bordercolor, org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_reply callback, gpointer userdata)
01214
01215 {
01216 DBusGAsyncData *stuff;
01217 stuff = g_slice_new (DBusGAsyncData);
01218 stuff->cb = G_CALLBACK (callback);
01219 stuff->userdata = userdata;
01220 return dbus_g_proxy_begin_call (proxy, "setBordercolor", org_freedesktop_gnome_Magnifier_ZoomRegion_set_bordercolor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_UINT, IN_bordercolor, G_TYPE_INVALID);
01221 }
01222 static
01223 #ifdef G_HAVE_INLINE
01224 inline
01225 #endif
01226 gboolean
01227 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor (DBusGProxy *proxy, guint* OUT_bordercolor, GError **error)
01228
01229 {
01230 return dbus_g_proxy_call (proxy, "getBordercolor", error, G_TYPE_INVALID, G_TYPE_UINT, OUT_bordercolor, G_TYPE_INVALID);
01231 }
01232
01233 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_reply) (DBusGProxy *proxy, guint OUT_bordercolor, GError *error, gpointer userdata);
01234
01235 static void
01236 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01237 {
01238 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01239 GError *error = NULL;
01240 guint OUT_bordercolor;
01241 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_bordercolor, G_TYPE_INVALID);
01242 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_reply)data->cb) (proxy, OUT_bordercolor, error, data->userdata);
01243 return;
01244 }
01245
01246 static
01247 #ifdef G_HAVE_INLINE
01248 inline
01249 #endif
01250 DBusGProxyCall*
01251 org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_reply callback, gpointer userdata)
01252
01253 {
01254 DBusGAsyncData *stuff;
01255 stuff = g_slice_new (DBusGAsyncData);
01256 stuff->cb = G_CALLBACK (callback);
01257 stuff->userdata = userdata;
01258 return dbus_g_proxy_begin_call (proxy, "getBordercolor", org_freedesktop_gnome_Magnifier_ZoomRegion_get_bordercolor_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01259 }
01260 static
01261 #ifdef G_HAVE_INLINE
01262 inline
01263 #endif
01264 gboolean
01265 org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign (DBusGProxy *proxy, const gint IN_align, GError **error)
01266
01267 {
01268 return dbus_g_proxy_call (proxy, "setXalign", error, G_TYPE_INT, IN_align, G_TYPE_INVALID, G_TYPE_INVALID);
01269 }
01270
01271 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01272
01273 static void
01274 org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01275 {
01276 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01277 GError *error = NULL;
01278 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01279 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_reply)data->cb) (proxy, error, data->userdata);
01280 return;
01281 }
01282
01283 static
01284 #ifdef G_HAVE_INLINE
01285 inline
01286 #endif
01287 DBusGProxyCall*
01288 org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_async (DBusGProxy *proxy, const gint IN_align, org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_reply callback, gpointer userdata)
01289
01290 {
01291 DBusGAsyncData *stuff;
01292 stuff = g_slice_new (DBusGAsyncData);
01293 stuff->cb = G_CALLBACK (callback);
01294 stuff->userdata = userdata;
01295 return dbus_g_proxy_begin_call (proxy, "setXalign", org_freedesktop_gnome_Magnifier_ZoomRegion_set_xalign_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_align, G_TYPE_INVALID);
01296 }
01297 static
01298 #ifdef G_HAVE_INLINE
01299 inline
01300 #endif
01301 gboolean
01302 org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign (DBusGProxy *proxy, gint* OUT_align, GError **error)
01303
01304 {
01305 return dbus_g_proxy_call (proxy, "getXalign", error, G_TYPE_INVALID, G_TYPE_INT, OUT_align, G_TYPE_INVALID);
01306 }
01307
01308 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_reply) (DBusGProxy *proxy, gint OUT_align, GError *error, gpointer userdata);
01309
01310 static void
01311 org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01312 {
01313 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01314 GError *error = NULL;
01315 gint OUT_align;
01316 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_align, G_TYPE_INVALID);
01317 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_reply)data->cb) (proxy, OUT_align, error, data->userdata);
01318 return;
01319 }
01320
01321 static
01322 #ifdef G_HAVE_INLINE
01323 inline
01324 #endif
01325 DBusGProxyCall*
01326 org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_reply callback, gpointer userdata)
01327
01328 {
01329 DBusGAsyncData *stuff;
01330 stuff = g_slice_new (DBusGAsyncData);
01331 stuff->cb = G_CALLBACK (callback);
01332 stuff->userdata = userdata;
01333 return dbus_g_proxy_begin_call (proxy, "getXalign", org_freedesktop_gnome_Magnifier_ZoomRegion_get_xalign_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01334 }
01335 static
01336 #ifdef G_HAVE_INLINE
01337 inline
01338 #endif
01339 gboolean
01340 org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign (DBusGProxy *proxy, const gint IN_align, GError **error)
01341
01342 {
01343 return dbus_g_proxy_call (proxy, "setYalign", error, G_TYPE_INT, IN_align, G_TYPE_INVALID, G_TYPE_INVALID);
01344 }
01345
01346 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01347
01348 static void
01349 org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01350 {
01351 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01352 GError *error = NULL;
01353 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01354 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_reply)data->cb) (proxy, error, data->userdata);
01355 return;
01356 }
01357
01358 static
01359 #ifdef G_HAVE_INLINE
01360 inline
01361 #endif
01362 DBusGProxyCall*
01363 org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_async (DBusGProxy *proxy, const gint IN_align, org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_reply callback, gpointer userdata)
01364
01365 {
01366 DBusGAsyncData *stuff;
01367 stuff = g_slice_new (DBusGAsyncData);
01368 stuff->cb = G_CALLBACK (callback);
01369 stuff->userdata = userdata;
01370 return dbus_g_proxy_begin_call (proxy, "setYalign", org_freedesktop_gnome_Magnifier_ZoomRegion_set_yalign_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_align, G_TYPE_INVALID);
01371 }
01372 static
01373 #ifdef G_HAVE_INLINE
01374 inline
01375 #endif
01376 gboolean
01377 org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign (DBusGProxy *proxy, gint* OUT_align, GError **error)
01378
01379 {
01380 return dbus_g_proxy_call (proxy, "getYalign", error, G_TYPE_INVALID, G_TYPE_INT, OUT_align, G_TYPE_INVALID);
01381 }
01382
01383 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_reply) (DBusGProxy *proxy, gint OUT_align, GError *error, gpointer userdata);
01384
01385 static void
01386 org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01387 {
01388 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01389 GError *error = NULL;
01390 gint OUT_align;
01391 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_align, G_TYPE_INVALID);
01392 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_reply)data->cb) (proxy, OUT_align, error, data->userdata);
01393 return;
01394 }
01395
01396 static
01397 #ifdef G_HAVE_INLINE
01398 inline
01399 #endif
01400 DBusGProxyCall*
01401 org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_reply callback, gpointer userdata)
01402
01403 {
01404 DBusGAsyncData *stuff;
01405 stuff = g_slice_new (DBusGAsyncData);
01406 stuff->cb = G_CALLBACK (callback);
01407 stuff->userdata = userdata;
01408 return dbus_g_proxy_begin_call (proxy, "getYalign", org_freedesktop_gnome_Magnifier_ZoomRegion_get_yalign_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01409 }
01410 static
01411 #ifdef G_HAVE_INLINE
01412 inline
01413 #endif
01414 gboolean
01415 org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport (DBusGProxy *proxy, const GArray* IN_viewport, GError **error)
01416
01417 {
01418 return dbus_g_proxy_call (proxy, "setViewport", error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_viewport, G_TYPE_INVALID, G_TYPE_INVALID);
01419 }
01420
01421 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01422
01423 static void
01424 org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01425 {
01426 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01427 GError *error = NULL;
01428 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01429 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_reply)data->cb) (proxy, error, data->userdata);
01430 return;
01431 }
01432
01433 static
01434 #ifdef G_HAVE_INLINE
01435 inline
01436 #endif
01437 DBusGProxyCall*
01438 org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_async (DBusGProxy *proxy, const GArray* IN_viewport, org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_reply callback, gpointer userdata)
01439
01440 {
01441 DBusGAsyncData *stuff;
01442 stuff = g_slice_new (DBusGAsyncData);
01443 stuff->cb = G_CALLBACK (callback);
01444 stuff->userdata = userdata;
01445 return dbus_g_proxy_begin_call (proxy, "setViewport", org_freedesktop_gnome_Magnifier_ZoomRegion_set_viewport_async_callback, stuff, _dbus_glib_async_data_free, dbus_g_type_get_collection ("GArray", G_TYPE_INT), IN_viewport, G_TYPE_INVALID);
01446 }
01447 static
01448 #ifdef G_HAVE_INLINE
01449 inline
01450 #endif
01451 gboolean
01452 org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport (DBusGProxy *proxy, GArray** OUT_viewport, GError **error)
01453
01454 {
01455 return dbus_g_proxy_call (proxy, "getViewport", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_INT), OUT_viewport, G_TYPE_INVALID);
01456 }
01457
01458 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_reply) (DBusGProxy *proxy, GArray *OUT_viewport, GError *error, gpointer userdata);
01459
01460 static void
01461 org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01462 {
01463 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01464 GError *error = NULL;
01465 GArray* OUT_viewport;
01466 dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_INT), &OUT_viewport, G_TYPE_INVALID);
01467 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_reply)data->cb) (proxy, OUT_viewport, error, data->userdata);
01468 return;
01469 }
01470
01471 static
01472 #ifdef G_HAVE_INLINE
01473 inline
01474 #endif
01475 DBusGProxyCall*
01476 org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_reply callback, gpointer userdata)
01477
01478 {
01479 DBusGAsyncData *stuff;
01480 stuff = g_slice_new (DBusGAsyncData);
01481 stuff->cb = G_CALLBACK (callback);
01482 stuff->userdata = userdata;
01483 return dbus_g_proxy_begin_call (proxy, "getViewport", org_freedesktop_gnome_Magnifier_ZoomRegion_get_viewport_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01484 }
01485 static
01486 #ifdef G_HAVE_INLINE
01487 inline
01488 #endif
01489 gboolean
01490 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test (DBusGProxy *proxy, const gint IN_timing_test, GError **error)
01491
01492 {
01493 return dbus_g_proxy_call (proxy, "setTimingTest", error, G_TYPE_INT, IN_timing_test, G_TYPE_INVALID, G_TYPE_INVALID);
01494 }
01495
01496 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01497
01498 static void
01499 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01500 {
01501 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01502 GError *error = NULL;
01503 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01504 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_reply)data->cb) (proxy, error, data->userdata);
01505 return;
01506 }
01507
01508 static
01509 #ifdef G_HAVE_INLINE
01510 inline
01511 #endif
01512 DBusGProxyCall*
01513 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_async (DBusGProxy *proxy, const gint IN_timing_test, org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_reply callback, gpointer userdata)
01514
01515 {
01516 DBusGAsyncData *stuff;
01517 stuff = g_slice_new (DBusGAsyncData);
01518 stuff->cb = G_CALLBACK (callback);
01519 stuff->userdata = userdata;
01520 return dbus_g_proxy_begin_call (proxy, "setTimingTest", org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_test_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_timing_test, G_TYPE_INVALID);
01521 }
01522 static
01523 #ifdef G_HAVE_INLINE
01524 inline
01525 #endif
01526 gboolean
01527 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test (DBusGProxy *proxy, gint* OUT_timing_test, GError **error)
01528
01529 {
01530 return dbus_g_proxy_call (proxy, "getTimingTest", error, G_TYPE_INVALID, G_TYPE_INT, OUT_timing_test, G_TYPE_INVALID);
01531 }
01532
01533 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_reply) (DBusGProxy *proxy, gint OUT_timing_test, GError *error, gpointer userdata);
01534
01535 static void
01536 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01537 {
01538 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01539 GError *error = NULL;
01540 gint OUT_timing_test;
01541 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_timing_test, G_TYPE_INVALID);
01542 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_reply)data->cb) (proxy, OUT_timing_test, error, data->userdata);
01543 return;
01544 }
01545
01546 static
01547 #ifdef G_HAVE_INLINE
01548 inline
01549 #endif
01550 DBusGProxyCall*
01551 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_reply callback, gpointer userdata)
01552
01553 {
01554 DBusGAsyncData *stuff;
01555 stuff = g_slice_new (DBusGAsyncData);
01556 stuff->cb = G_CALLBACK (callback);
01557 stuff->userdata = userdata;
01558 return dbus_g_proxy_begin_call (proxy, "getTimingTest", org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_test_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01559 }
01560 static
01561 #ifdef G_HAVE_INLINE
01562 inline
01563 #endif
01564 gboolean
01565 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output (DBusGProxy *proxy, const gboolean IN_timing_output, GError **error)
01566
01567 {
01568 return dbus_g_proxy_call (proxy, "setTimingOutput", error, G_TYPE_BOOLEAN, IN_timing_output, G_TYPE_INVALID, G_TYPE_INVALID);
01569 }
01570
01571 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01572
01573 static void
01574 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01575 {
01576 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01577 GError *error = NULL;
01578 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01579 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_reply)data->cb) (proxy, error, data->userdata);
01580 return;
01581 }
01582
01583 static
01584 #ifdef G_HAVE_INLINE
01585 inline
01586 #endif
01587 DBusGProxyCall*
01588 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_async (DBusGProxy *proxy, const gboolean IN_timing_output, org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_reply callback, gpointer userdata)
01589
01590 {
01591 DBusGAsyncData *stuff;
01592 stuff = g_slice_new (DBusGAsyncData);
01593 stuff->cb = G_CALLBACK (callback);
01594 stuff->userdata = userdata;
01595 return dbus_g_proxy_begin_call (proxy, "setTimingOutput", org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_output_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_timing_output, G_TYPE_INVALID);
01596 }
01597 static
01598 #ifdef G_HAVE_INLINE
01599 inline
01600 #endif
01601 gboolean
01602 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output (DBusGProxy *proxy, gboolean* OUT_timing_output, GError **error)
01603
01604 {
01605 return dbus_g_proxy_call (proxy, "getTimingOutput", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_timing_output, G_TYPE_INVALID);
01606 }
01607
01608 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_reply) (DBusGProxy *proxy, gboolean OUT_timing_output, GError *error, gpointer userdata);
01609
01610 static void
01611 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01612 {
01613 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01614 GError *error = NULL;
01615 gboolean OUT_timing_output;
01616 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_timing_output, G_TYPE_INVALID);
01617 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_reply)data->cb) (proxy, OUT_timing_output, error, data->userdata);
01618 return;
01619 }
01620
01621 static
01622 #ifdef G_HAVE_INLINE
01623 inline
01624 #endif
01625 DBusGProxyCall*
01626 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_reply callback, gpointer userdata)
01627
01628 {
01629 DBusGAsyncData *stuff;
01630 stuff = g_slice_new (DBusGAsyncData);
01631 stuff->cb = G_CALLBACK (callback);
01632 stuff->userdata = userdata;
01633 return dbus_g_proxy_begin_call (proxy, "getTimingOutput", org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_output_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01634 }
01635 static
01636 #ifdef G_HAVE_INLINE
01637 inline
01638 #endif
01639 gboolean
01640 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate (DBusGProxy *proxy, const gint IN_timing_pan_rate, GError **error)
01641
01642 {
01643 return dbus_g_proxy_call (proxy, "setTimingPanRate", error, G_TYPE_INT, IN_timing_pan_rate, G_TYPE_INVALID, G_TYPE_INVALID);
01644 }
01645
01646 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01647
01648 static void
01649 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01650 {
01651 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01652 GError *error = NULL;
01653 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01654 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_reply)data->cb) (proxy, error, data->userdata);
01655 return;
01656 }
01657
01658 static
01659 #ifdef G_HAVE_INLINE
01660 inline
01661 #endif
01662 DBusGProxyCall*
01663 org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_async (DBusGProxy *proxy, const gint IN_timing_pan_rate, org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_reply callback, gpointer userdata)
01664
01665 {
01666 DBusGAsyncData *stuff;
01667 stuff = g_slice_new (DBusGAsyncData);
01668 stuff->cb = G_CALLBACK (callback);
01669 stuff->userdata = userdata;
01670 return dbus_g_proxy_begin_call (proxy, "setTimingPanRate", org_freedesktop_gnome_Magnifier_ZoomRegion_set_timing_pan_rate_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_timing_pan_rate, G_TYPE_INVALID);
01671 }
01672 static
01673 #ifdef G_HAVE_INLINE
01674 inline
01675 #endif
01676 gboolean
01677 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate (DBusGProxy *proxy, gint* OUT_timing_pan_rate, GError **error)
01678
01679 {
01680 return dbus_g_proxy_call (proxy, "getTimingPanRate", error, G_TYPE_INVALID, G_TYPE_INT, OUT_timing_pan_rate, G_TYPE_INVALID);
01681 }
01682
01683 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_reply) (DBusGProxy *proxy, gint OUT_timing_pan_rate, GError *error, gpointer userdata);
01684
01685 static void
01686 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01687 {
01688 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01689 GError *error = NULL;
01690 gint OUT_timing_pan_rate;
01691 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INT, &OUT_timing_pan_rate, G_TYPE_INVALID);
01692 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_reply)data->cb) (proxy, OUT_timing_pan_rate, error, data->userdata);
01693 return;
01694 }
01695
01696 static
01697 #ifdef G_HAVE_INLINE
01698 inline
01699 #endif
01700 DBusGProxyCall*
01701 org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_reply callback, gpointer userdata)
01702
01703 {
01704 DBusGAsyncData *stuff;
01705 stuff = g_slice_new (DBusGAsyncData);
01706 stuff->cb = G_CALLBACK (callback);
01707 stuff->userdata = userdata;
01708 return dbus_g_proxy_begin_call (proxy, "getTimingPanRate", org_freedesktop_gnome_Magnifier_ZoomRegion_get_timing_pan_rate_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01709 }
01710 static
01711 #ifdef G_HAVE_INLINE
01712 inline
01713 #endif
01714 gboolean
01715 org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier (DBusGProxy *proxy, const gboolean IN_exit_magnifier, GError **error)
01716
01717 {
01718 return dbus_g_proxy_call (proxy, "setExitMagnifier", error, G_TYPE_BOOLEAN, IN_exit_magnifier, G_TYPE_INVALID, G_TYPE_INVALID);
01719 }
01720
01721 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
01722
01723 static void
01724 org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01725 {
01726 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01727 GError *error = NULL;
01728 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
01729 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_reply)data->cb) (proxy, error, data->userdata);
01730 return;
01731 }
01732
01733 static
01734 #ifdef G_HAVE_INLINE
01735 inline
01736 #endif
01737 DBusGProxyCall*
01738 org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_async (DBusGProxy *proxy, const gboolean IN_exit_magnifier, org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_reply callback, gpointer userdata)
01739
01740 {
01741 DBusGAsyncData *stuff;
01742 stuff = g_slice_new (DBusGAsyncData);
01743 stuff->cb = G_CALLBACK (callback);
01744 stuff->userdata = userdata;
01745 return dbus_g_proxy_begin_call (proxy, "setExitMagnifier", org_freedesktop_gnome_Magnifier_ZoomRegion_set_exit_magnifier_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_exit_magnifier, G_TYPE_INVALID);
01746 }
01747 static
01748 #ifdef G_HAVE_INLINE
01749 inline
01750 #endif
01751 gboolean
01752 org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier (DBusGProxy *proxy, gboolean* OUT_exit_magnifier, GError **error)
01753
01754 {
01755 return dbus_g_proxy_call (proxy, "getExitMagnifier", error, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_exit_magnifier, G_TYPE_INVALID);
01756 }
01757
01758 typedef void (*org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_reply) (DBusGProxy *proxy, gboolean OUT_exit_magnifier, GError *error, gpointer userdata);
01759
01760 static void
01761 org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
01762 {
01763 DBusGAsyncData *data = (DBusGAsyncData*) user_data;
01764 GError *error = NULL;
01765 gboolean OUT_exit_magnifier;
01766 dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_exit_magnifier, G_TYPE_INVALID);
01767 (*(org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_reply)data->cb) (proxy, OUT_exit_magnifier, error, data->userdata);
01768 return;
01769 }
01770
01771 static
01772 #ifdef G_HAVE_INLINE
01773 inline
01774 #endif
01775 DBusGProxyCall*
01776 org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_async (DBusGProxy *proxy, org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_reply callback, gpointer userdata)
01777
01778 {
01779 DBusGAsyncData *stuff;
01780 stuff = g_slice_new (DBusGAsyncData);
01781 stuff->cb = G_CALLBACK (callback);
01782 stuff->userdata = userdata;
01783 return dbus_g_proxy_begin_call (proxy, "getExitMagnifier", org_freedesktop_gnome_Magnifier_ZoomRegion_get_exit_magnifier_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
01784 }
01785 #endif
01786
01787 G_END_DECLS