1031
1088
static gboolean
1089
source_remote_create_sync (ESource *source,
1090
ESource *scratch_source,
1091
GCancellable *cancellable,
1094
EDBusSourceRemoteCreatable *dbus_interface = NULL;
1095
GDBusObject *dbus_object;
1099
dbus_object = e_source_ref_dbus_object (source);
1100
if (dbus_object != NULL) {
1102
e_dbus_object_get_source_remote_creatable (
1103
E_DBUS_OBJECT (dbus_object));
1104
g_object_unref (dbus_object);
1107
if (dbus_interface == NULL) {
1110
G_IO_ERROR_NOT_SUPPORTED,
1111
_("Data source '%s' does not "
1112
"support creating remote resources"),
1113
e_source_get_display_name (source));
1117
uid = e_source_dup_uid (scratch_source);
1118
data = e_source_to_string (scratch_source, NULL);
1120
success = e_dbus_source_remote_creatable_call_create_sync (
1121
dbus_interface, uid, data, cancellable, error);
1126
g_object_unref (dbus_interface);
1131
/* Helper for source_remote_create() */
1133
source_remote_create_thread (GSimpleAsyncResult *simple,
1135
GCancellable *cancellable)
1137
AsyncContext *async_context;
1138
GError *error = NULL;
1140
async_context = g_simple_async_result_get_op_res_gpointer (simple);
1142
e_source_remote_create_sync (
1144
async_context->scratch_source,
1145
cancellable, &error);
1148
g_simple_async_result_take_error (simple, error);
1152
source_remote_create (ESource *source,
1153
ESource *scratch_source,
1154
GCancellable *cancellable,
1155
GAsyncReadyCallback callback,
1158
GSimpleAsyncResult *simple;
1159
AsyncContext *async_context;
1161
async_context = g_slice_new0 (AsyncContext);
1162
async_context->scratch_source = g_object_ref (scratch_source);
1164
simple = g_simple_async_result_new (
1165
G_OBJECT (source), callback,
1166
user_data, source_remote_create);
1168
g_simple_async_result_set_check_cancellable (simple, cancellable);
1170
g_simple_async_result_set_op_res_gpointer (
1171
simple, async_context, (GDestroyNotify) async_context_free);
1173
g_simple_async_result_run_in_thread (
1174
simple, source_remote_create_thread,
1175
G_PRIORITY_DEFAULT, cancellable);
1177
g_object_unref (simple);
1181
source_remote_create_finish (ESource *source,
1182
GAsyncResult *result,
1185
GSimpleAsyncResult *simple;
1187
g_return_val_if_fail (
1188
g_simple_async_result_is_valid (
1189
result, G_OBJECT (source), source_remote_create), FALSE);
1191
simple = G_SIMPLE_ASYNC_RESULT (result);
1193
/* Assume success unless a GError is set. */
1194
return !g_simple_async_result_propagate_error (simple, error);
1198
source_remote_delete_sync (ESource *source,
1199
GCancellable *cancellable,
1202
EDBusSourceRemoteDeletable *dbus_interface = NULL;
1203
GDBusObject *dbus_object;
1206
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
1208
dbus_object = e_source_ref_dbus_object (source);
1209
if (dbus_object != NULL) {
1211
e_dbus_object_get_source_remote_deletable (
1212
E_DBUS_OBJECT (dbus_object));
1213
g_object_unref (dbus_object);
1216
if (dbus_interface == NULL) {
1219
G_IO_ERROR_NOT_SUPPORTED,
1220
_("Data source '%s' does not "
1221
"support deleting remote resources"),
1222
e_source_get_display_name (source));
1226
success = e_dbus_source_remote_deletable_call_delete_sync (
1227
dbus_interface, cancellable, error);
1229
g_object_unref (dbus_interface);
1234
/* Helper for source_remote_delete() */
1236
source_remote_delete_thread (GSimpleAsyncResult *simple,
1238
GCancellable *cancellable)
1240
GError *error = NULL;
1242
e_source_remote_delete_sync (
1243
E_SOURCE (object), cancellable, &error);
1246
g_simple_async_result_take_error (simple, error);
1250
source_remote_delete (ESource *source,
1251
GCancellable *cancellable,
1252
GAsyncReadyCallback callback,
1255
GSimpleAsyncResult *simple;
1257
simple = g_simple_async_result_new (
1258
G_OBJECT (source), callback,
1259
user_data, source_remote_delete);
1261
g_simple_async_result_set_check_cancellable (simple, cancellable);
1263
g_simple_async_result_run_in_thread (
1264
simple, source_remote_delete_thread,
1265
G_PRIORITY_DEFAULT, cancellable);
1267
g_object_unref (simple);
1271
source_remote_delete_finish (ESource *source,
1272
GAsyncResult *result,
1275
GSimpleAsyncResult *simple;
1277
g_return_val_if_fail (
1278
g_simple_async_result_is_valid (
1279
result, G_OBJECT (source), source_remote_delete), FALSE);
1281
simple = G_SIMPLE_ASYNC_RESULT (result);
1283
/* Assume success unless a GError is set. */
1284
return !g_simple_async_result_propagate_error (simple, error);
1032
1288
source_initable_init (GInitable *initable,
1033
1289
GCancellable *cancellable,
1034
1290
GError **error)
1075
1337
success = source_parse_dbus_data (source, error);
1077
/* Avoid a spurious "changed" emission. */
1078
g_mutex_lock (source->priv->changed_lock);
1079
if (source->priv->changed != NULL) {
1080
g_source_destroy (source->priv->changed);
1081
g_source_unref (source->priv->changed);
1082
source->priv->changed = NULL;
1084
g_mutex_unlock (source->priv->changed_lock);
1086
1339
g_object_unref (dbus_source);
1088
1341
/* No D-Bus object implies we're configuring a new source,
1089
* so generate a new unique identifier (UID) for it. */
1342
* so generate a new unique identifier (UID) unless one was
1343
* explicitly provided through e_source_new_with_uid(). */
1344
} else if (source->priv->uid == NULL) {
1091
1345
source->priv->uid = e_uid_new ();
1348
/* Try to avoid a spurious "changed" emission. */
1349
g_mutex_lock (source->priv->changed_lock);
1350
if (source->priv->changed != NULL) {
1351
g_source_destroy (source->priv->changed);
1352
g_source_unref (source->priv->changed);
1353
source->priv->changed = NULL;
1355
g_mutex_unlock (source->priv->changed_lock);
1357
source->priv->initialized = TRUE;
1094
1359
return success;
1972
* e_source_get_remote_creatable:
1973
* @source: an #ESource
1975
* Returns whether new resources can be created on a remote server by
1976
* calling e_source_remote_create() on @source.
1978
* Generally this is only %TRUE if @source has an #ESourceCollection
1979
* extension, which means there is an #ECollectionBackend in the D-Bus
1980
* service that can handle create requests. If @source does not have
1981
* this capability, calls to e_source_remote_create() will fail.
1983
* Returns: whether @source can create remote resources
1988
e_source_get_remote_creatable (ESource *source)
1990
EDBusObject *dbus_object;
1991
EDBusSourceRemoteCreatable *dbus_source;
1993
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
1995
dbus_object = E_DBUS_OBJECT (source->priv->dbus_object);
1996
dbus_source = e_dbus_object_peek_source_remote_creatable (dbus_object);
1998
return (dbus_source != NULL);
2002
* e_source_get_remote_deletable:
2003
* @source: an #ESource
2005
* Returns whether the resource represented by @source can be deleted
2006
* from a remote server by calling e_source_remote_delete().
2008
* Generally this is only %TRUE if @source is a child of an #ESource
2009
* which has an #ESourceCollection extension, which means there is an
2010
* #ECollectionBackend in the D-Bus service that can handle delete
2011
* requests. If @source does not have this capability, calls to
2012
* e_source_remote_delete() will fail.
2014
* Returns: whether @source can delete remote resources
2019
e_source_get_remote_deletable (ESource *source)
2021
EDBusObject *dbus_object;
2022
EDBusSourceRemoteDeletable *dbus_source;
2024
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
2026
dbus_object = E_DBUS_OBJECT (source->priv->dbus_object);
2027
dbus_source = e_dbus_object_peek_source_remote_deletable (dbus_object);
2029
return (dbus_source != NULL);
1646
2033
* e_source_get_extension:
1647
2034
* @source: an #ESource
1648
2035
* @extension_name: an extension name
2187
2579
return class->write_finish (source, result, error);
2583
* e_source_remote_create_sync:
2584
* @source: an #ESource
2585
* @scratch_source: an #ESource describing the resource to create
2586
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
2587
* @error: return location for a #GError, or %NULL
2589
* Creates a new remote resource by picking out relevant details from
2590
* @scratch_source. The @scratch_source must be an #ESource with no
2591
* #GDBusObject. The @source must be #ESource:remote-creatable.
2593
* The details required to create the resource vary by #ECollectionBackend,
2594
* but in most cases the @scratch_source need only define the resource type
2595
* (address book, calendar, etc.), a display name for the resource, and
2596
* possibly a server-side path or ID for the resource.
2598
* If an error occurs, the function will set @error and return %FALSE.
2600
* Returns: %TRUE on success, %FALSE on failure
2605
e_source_remote_create_sync (ESource *source,
2606
ESource *scratch_source,
2607
GCancellable *cancellable,
2610
ESourceClass *class;
2612
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
2613
g_return_val_if_fail (E_IS_SOURCE (scratch_source), FALSE);
2615
class = E_SOURCE_GET_CLASS (source);
2616
g_return_val_if_fail (class->remote_create_sync != NULL, FALSE);
2618
return class->remote_create_sync (
2619
source, scratch_source, cancellable, error);
2623
* e_source_remote_create:
2624
* @source: an #ESource
2625
* @scratch_source: an #ESource describing the resource to create
2626
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
2627
* @callback: (scope async): a #GAsyncReadyCallback to call when the request
2629
* @user_data: (closure): data to pass to the callback function
2631
* Asynchronously creates a new remote resource by picking out relevant
2632
* details from @scratch_source. The @scratch_source must be an #ESource
2633
* with no #GDBusObject. The @source must be #ESource:remote-creatable.
2635
* The details required to create the resource vary by #ECollectionBackend,
2636
* but in most cases the @scratch_source need only define the resource type
2637
* (address book, calendar, etc.), a display name for the resource, and
2638
* possibly a server-side path or ID for the resource.
2640
* When the operation is finished, @callback will be called. You can then
2641
* call 3_source_remote_create_finish() to get the result of the operation.
2646
e_source_remote_create (ESource *source,
2647
ESource *scratch_source,
2648
GCancellable *cancellable,
2649
GAsyncReadyCallback callback,
2652
ESourceClass *class;
2654
g_return_if_fail (E_IS_SOURCE (source));
2655
g_return_if_fail (E_IS_SOURCE (scratch_source));
2657
class = E_SOURCE_GET_CLASS (source);
2658
g_return_if_fail (class->remote_create != NULL);
2660
class->remote_create (
2661
source, scratch_source,
2662
cancellable, callback, user_data);
2666
* e_source_remote_create_finish:
2667
* @source: an #ESource
2668
* @result: a #GAsyncResult
2669
* @error: return location for a #GError, or %NULL
2671
* Finishes the operation started with e_source_remote_create(). If
2672
* an error occurred, the function will set @error and return %FALSE.
2674
* Returns: %TRUE on success, %FALSE on failure
2679
e_source_remote_create_finish (ESource *source,
2680
GAsyncResult *result,
2683
ESourceClass *class;
2685
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
2687
class = E_SOURCE_GET_CLASS (source);
2688
g_return_val_if_fail (class->remote_create_finish != NULL, FALSE);
2690
return class->remote_create_finish (source, result, error);
2694
* e_source_remote_delete_sync:
2695
* @source: an #ESource
2696
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
2697
* @error: return location for a #GError, or %NULL
2699
* Deletes the resource represented by @source from a remote server.
2700
* The @source must be #ESource:remote-deletable. This will also delete
2701
* the key file for @source and broadcast its removal to all clients,
2702
* similar to e_source_remove_sync().
2704
* If an error occurs, the function will set @error and return %FALSE.
2706
* Returns: %TRUE on success, %FALSE on failure
2711
e_source_remote_delete_sync (ESource *source,
2712
GCancellable *cancellable,
2715
ESourceClass *class;
2717
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
2719
class = E_SOURCE_GET_CLASS (source);
2720
g_return_val_if_fail (class->remote_delete_sync != NULL, FALSE);
2722
return class->remote_delete_sync (source, cancellable, error);
2726
* e_source_remote_delete:
2727
* @source: an #ESource
2728
* @cancellable: (allow-none): optional #GCancellable object, or %NULL
2729
* @callback: (scope async): a #GAsyncReadyCallback to call when the request
2731
* @user_data: (closure): data to pass to the callback function
2733
* Asynchronously deletes the resource represented by @source from a remote
2734
* server. The @source must be #ESource:remote-deletable. This will also
2735
* delete the key file for @source and broadcast its removal to all clients,
2736
* similar to e_source_remove().
2738
* When the operation is finished, @callback will be called. You can then
2739
* call e_source_remote_delete_finish() to get the result of the operation.
2744
e_source_remote_delete (ESource *source,
2745
GCancellable *cancellable,
2746
GAsyncReadyCallback callback,
2749
ESourceClass *class;
2751
g_return_if_fail (E_IS_SOURCE (source));
2753
class = E_SOURCE_GET_CLASS (source);
2754
g_return_if_fail (class->remote_delete != NULL);
2756
class->remote_delete (source, cancellable, callback, user_data);
2760
* e_source_remote_delete_finish:
2761
* @source: an #ESource
2762
* @result: a #GAsyncResult
2763
* @error: return location for a #GError, or %NULL
2765
* Finishes the operation started with e_source_remote_delete(). If
2766
* an error occurred, the function will set @error and return %FALSE.
2768
* Returns: %TRUE on success, %FALSE on failure
2773
e_source_remote_delete_finish (ESource *source,
2774
GAsyncResult *result,
2777
ESourceClass *class;
2779
g_return_val_if_fail (E_IS_SOURCE (source), FALSE);
2781
class = E_SOURCE_GET_CLASS (source);
2782
g_return_val_if_fail (class->remote_delete_finish != NULL, FALSE);
2784
return class->remote_delete_finish (source, result, error);
added
removed
libedataserver/e-source.c
