#include <gio/gio.h>
/* Private D-Bus classes. */
+#include <e-dbus-calendar.h>
#include <e-dbus-calendar-factory.h>
#include <libedataserver/e-client-private.h>
#include "e-cal-types.h"
#include "e-timezone-cache.h"
-#include "e-gdbus-cal.h"
-
#define E_CAL_CLIENT_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_CAL_CLIENT, ECalClientPrivate))
+/* Set this to a sufficiently large value
+ * to cover most long-running operations. */
+#define DBUS_PROXY_TIMEOUT_MS (3 * 60 * 1000) /* 3 minutes */
+
+typedef struct _AsyncContext AsyncContext;
+typedef struct _SignalClosure SignalClosure;
+typedef struct _RunInThreadClosure RunInThreadClosure;
+
struct _ECalClientPrivate {
- GDBusProxy *dbus_proxy;
+ EDBusCalendar *dbus_proxy;
+ GMainContext *main_context;
guint gone_signal_id;
ECalClientSourceType source_type;
icaltimezone *default_zone;
- gchar *cache_dir;
GMutex zone_cache_lock;
GHashTable *zone_cache;
+
+ gulong dbus_proxy_error_handler_id;
+ gulong dbus_proxy_notify_handler_id;
+ gulong dbus_proxy_free_busy_data_handler_id;
+};
+
+struct _AsyncContext {
+ ECalClientView *client_view;
+ icalcomponent *in_comp;
+ icalcomponent *out_comp;
+ icaltimezone *zone;
+ GSList *comp_list;
+ GSList *object_list;
+ GSList *string_list;
+ gchar *sexp;
+ gchar *tzid;
+ gchar *uid;
+ gchar *rid;
+ gchar *auid;
+ CalObjModType mod;
+ time_t start;
+ time_t end;
+};
+
+struct _SignalClosure {
+ EClient *client;
+ gchar *property_name;
+ gchar *error_message;
+ gchar **free_busy_data;
+};
+
+struct _RunInThreadClosure {
+ GSimpleAsyncThreadFunc func;
+ GSimpleAsyncResult *simple;
+ GCancellable *cancellable;
};
enum {
};
/* Forward Declarations */
+static void e_cal_client_initable_init
+ (GInitableIface *interface);
+static void e_cal_client_async_initable_init
+ (GAsyncInitableIface *interface);
static void e_cal_client_timezone_cache_init
(ETimezoneCacheInterface *interface);
e_cal_client,
E_TYPE_CLIENT,
G_IMPLEMENT_INTERFACE (
+ G_TYPE_INITABLE,
+ e_cal_client_initable_init)
+ G_IMPLEMENT_INTERFACE (
+ G_TYPE_ASYNC_INITABLE,
+ e_cal_client_async_initable_init)
+ G_IMPLEMENT_INTERFACE (
E_TYPE_TIMEZONE_CACHE,
e_cal_client_timezone_cache_init))
static void
+async_context_free (AsyncContext *async_context)
+{
+ if (async_context->client_view != NULL)
+ g_object_unref (async_context->client_view);
+
+ if (async_context->in_comp != NULL)
+ icalcomponent_free (async_context->in_comp);
+
+ if (async_context->out_comp != NULL)
+ icalcomponent_free (async_context->out_comp);
+
+ if (async_context->zone != NULL)
+ icaltimezone_free (async_context->zone, 1);
+
+ g_slist_free_full (
+ async_context->comp_list,
+ (GDestroyNotify) icalcomponent_free);
+
+ g_slist_free_full (
+ async_context->object_list,
+ (GDestroyNotify) g_object_unref);
+
+ g_slist_free_full (
+ async_context->string_list,
+ (GDestroyNotify) g_free);
+
+ g_free (async_context->sexp);
+ g_free (async_context->tzid);
+ g_free (async_context->uid);
+ g_free (async_context->rid);
+ g_free (async_context->auid);
+
+ g_slice_free (AsyncContext, async_context);
+}
+
+static void
+signal_closure_free (SignalClosure *signal_closure)
+{
+ g_object_unref (signal_closure->client);
+
+ g_free (signal_closure->property_name);
+ g_free (signal_closure->error_message);
+
+ g_strfreev (signal_closure->free_busy_data);
+
+ g_slice_free (SignalClosure, signal_closure);
+}
+
+static void
+run_in_thread_closure_free (RunInThreadClosure *run_in_thread_closure)
+{
+ if (run_in_thread_closure->simple != NULL)
+ g_object_unref (run_in_thread_closure->simple);
+
+ if (run_in_thread_closure->cancellable != NULL)
+ g_object_unref (run_in_thread_closure->cancellable);
+
+ g_slice_free (RunInThreadClosure, run_in_thread_closure);
+}
+
+static void
free_zone_cb (gpointer zone)
{
icaltimezone_free (zone, 1);
return TRUE;
}
+static gpointer
+cal_client_dbus_thread (gpointer user_data)
+{
+ GMainContext *main_context = user_data;
+ GMainLoop *main_loop;
+
+ g_main_context_push_thread_default (main_context);
+
+ main_loop = g_main_loop_new (main_context, FALSE);
+ g_main_loop_run (main_loop);
+ g_main_loop_unref (main_loop);
+
+ g_main_context_pop_thread_default (main_context);
+
+ g_main_context_unref (main_context);
+
+ return NULL;
+}
+
+static gpointer
+cal_client_dbus_thread_init (gpointer unused)
+{
+ GMainContext *main_context;
+
+ main_context = g_main_context_new ();
+
+ /* This thread terminates when the process itself terminates, so
+ * no need to worry about unreferencing the returned GThread. */
+ g_thread_new (
+ "cal-client-dbus-thread",
+ cal_client_dbus_thread,
+ g_main_context_ref (main_context));
+
+ return main_context;
+}
+
+static GMainContext *
+cal_client_ref_dbus_main_context (void)
+{
+ static GOnce cal_client_dbus_thread_once = G_ONCE_INIT;
+
+ g_once (
+ &cal_client_dbus_thread_once,
+ cal_client_dbus_thread_init, NULL);
+
+ return g_main_context_ref (cal_client_dbus_thread_once.retval);
+}
+
+static gboolean
+cal_client_run_in_dbus_thread_idle_cb (gpointer user_data)
+{
+ RunInThreadClosure *closure = user_data;
+ GObject *source_object;
+ GAsyncResult *result;
+
+ result = G_ASYNC_RESULT (closure->simple);
+ source_object = g_async_result_get_source_object (result);
+
+ closure->func (
+ closure->simple,
+ source_object,
+ closure->cancellable);
+
+ if (source_object != NULL)
+ g_object_unref (source_object);
+
+ g_simple_async_result_complete_in_idle (closure->simple);
+
+ return FALSE;
+}
+
+static void
+cal_client_run_in_dbus_thread (GSimpleAsyncResult *simple,
+ GSimpleAsyncThreadFunc func,
+ gint io_priority,
+ GCancellable *cancellable)
+{
+ RunInThreadClosure *closure;
+ GMainContext *main_context;
+ GSource *idle_source;
+
+ main_context = cal_client_ref_dbus_main_context ();
+
+ closure = g_slice_new0 (RunInThreadClosure);
+ closure->func = func;
+ closure->simple = g_object_ref (simple);
+
+ if (G_IS_CANCELLABLE (cancellable))
+ closure->cancellable = g_object_ref (cancellable);
+
+ idle_source = g_idle_source_new ();
+ g_source_set_priority (idle_source, io_priority);
+ g_source_set_callback (
+ idle_source, cal_client_run_in_dbus_thread_idle_cb,
+ closure, (GDestroyNotify) run_in_thread_closure_free);
+ g_source_attach (idle_source, main_context);
+ g_source_unref (idle_source);
+
+ g_main_context_unref (main_context);
+}
+
static void gdbus_cal_client_disconnect (ECalClient *client);
/*
g_dbus_connection_signal_unsubscribe (connection, client->priv->gone_signal_id);
client->priv->gone_signal_id = 0;
- e_gdbus_cal_call_close_sync (client->priv->dbus_proxy, NULL, NULL);
+ e_dbus_calendar_call_close_sync (
+ client->priv->dbus_proxy, NULL, NULL);
g_object_unref (client->priv->dbus_proxy);
client->priv->dbus_proxy = NULL;
}
UNLOCK_FACTORY ();
}
-static void
-backend_error_cb (EGdbusCal *object,
- const gchar *message,
- ECalClient *client)
-{
- g_return_if_fail (E_IS_CAL_CLIENT (client));
- g_return_if_fail (message != NULL);
-
- e_client_emit_backend_error (E_CLIENT (client), message);
-}
-
-static void
-readonly_cb (EGdbusCal *object,
- gboolean readonly,
- ECalClient *client)
+static gboolean
+cal_client_emit_backend_error_idle_cb (gpointer user_data)
{
- g_return_if_fail (E_IS_CAL_CLIENT (client));
+ SignalClosure *signal_closure = user_data;
- e_client_set_readonly (E_CLIENT (client), readonly);
-}
-
-static void
-online_cb (EGdbusCal *object,
- gboolean is_online,
- ECalClient *client)
-{
- g_return_if_fail (E_IS_CAL_CLIENT (client));
+ g_signal_emit_by_name (
+ signal_closure->client,
+ "backend-error",
+ signal_closure->error_message);
- e_client_set_online (E_CLIENT (client), is_online);
+ return FALSE;
}
-static void
-opened_cb (EGdbusCal *object,
- const gchar * const *error_strv,
- ECalClient *client)
-{
- GError *error = NULL;
-
- g_return_if_fail (E_IS_CAL_CLIENT (client));
- g_return_if_fail (error_strv != NULL);
- g_return_if_fail (e_gdbus_templates_decode_error (error_strv, &error));
-
- e_client_emit_opened (E_CLIENT (client), error);
+static gboolean
+cal_client_emit_backend_property_changed_idle_cb (gpointer user_data)
+{
+ SignalClosure *signal_closure = user_data;
+ gchar *prop_value = NULL;
+
+ /* XXX Despite appearances, this function does not block. */
+ e_client_get_backend_property_sync (
+ signal_closure->client,
+ signal_closure->property_name,
+ &prop_value, NULL, NULL);
+
+ if (prop_value != NULL) {
+ g_signal_emit_by_name (
+ signal_closure->client,
+ "backend-property-changed",
+ signal_closure->property_name,
+ prop_value);
+ g_free (prop_value);
+ }
- if (error)
- g_error_free (error);
+ return FALSE;
}
-static void
-free_busy_data_cb (EGdbusCal *object,
- const gchar * const *free_busy_strv,
- ECalClient *client)
+static gboolean
+cal_client_emit_free_busy_data_idle_cb (gpointer user_data)
{
- GSList *ecalcomps = NULL;
+ SignalClosure *signal_closure = user_data;
+ GSList *list = NULL;
+ gchar **strv;
gint ii;
- g_return_if_fail (E_IS_CAL_CLIENT (client));
- g_return_if_fail (free_busy_strv != NULL);
+ strv = signal_closure->free_busy_data;
- for (ii = 0; free_busy_strv[ii]; ii++) {
+ for (ii = 0; strv[ii] != NULL; ii++) {
ECalComponent *comp;
icalcomponent *icalcomp;
icalcomponent_kind kind;
- icalcomp = icalcomponent_new_from_string (free_busy_strv[ii]);
- if (!icalcomp)
+ icalcomp = icalcomponent_new_from_string (strv[ii]);
+ if (icalcomp == NULL)
continue;
kind = icalcomponent_isa (icalcomp);
- if (kind == ICAL_VFREEBUSY_COMPONENT) {
- comp = e_cal_component_new ();
- if (!e_cal_component_set_icalcomponent (comp, icalcomp)) {
- icalcomponent_free (icalcomp);
- g_object_unref (G_OBJECT (comp));
- continue;
- }
+ if (kind != ICAL_VFREEBUSY_COMPONENT) {
+ icalcomponent_free (icalcomp);
+ continue;
+ }
- ecalcomps = g_slist_prepend (ecalcomps, comp);
- } else {
+ comp = e_cal_component_new ();
+ if (!e_cal_component_set_icalcomponent (comp, icalcomp)) {
icalcomponent_free (icalcomp);
+ g_object_unref (comp);
+ continue;
}
+
+ list = g_slist_prepend (list, comp);
}
- ecalcomps = g_slist_reverse (ecalcomps);
+ list = g_slist_reverse (list);
+
+ g_signal_emit (
+ signal_closure->client,
+ signals[FREE_BUSY_DATA], 0, list);
- g_signal_emit (client, signals[FREE_BUSY_DATA], 0, ecalcomps);
+ g_slist_free_full (list, (GDestroyNotify) g_object_unref);
- e_client_util_free_object_slist (ecalcomps);
+ return FALSE;
}
static void
-backend_property_changed_cb (EGdbusCal *object,
- const gchar * const *name_value_strv,
- ECalClient *client)
+cal_client_dbus_proxy_error_cb (EDBusCalendar *dbus_proxy,
+ const gchar *error_message,
+ ECalClient *cal_client)
{
- gchar *prop_name = NULL, *prop_value = NULL;
-
- g_return_if_fail (E_IS_CAL_CLIENT (client));
- g_return_if_fail (name_value_strv != NULL);
- g_return_if_fail (e_gdbus_templates_decode_two_strings (name_value_strv, &prop_name, &prop_value));
- g_return_if_fail (prop_name != NULL);
- g_return_if_fail (*prop_name);
- g_return_if_fail (prop_value != NULL);
+ GSource *idle_source;
+ SignalClosure *signal_closure;
- e_client_emit_backend_property_changed (E_CLIENT (client), prop_name, prop_value);
+ signal_closure = g_slice_new0 (SignalClosure);
+ signal_closure->client = g_object_ref (cal_client);
+ signal_closure->error_message = g_strdup (error_message);
- g_free (prop_name);
- g_free (prop_value);
+ idle_source = g_idle_source_new ();
+ g_source_set_callback (
+ idle_source,
+ cal_client_emit_backend_error_idle_cb,
+ signal_closure,
+ (GDestroyNotify) signal_closure_free);
+ g_source_attach (idle_source, cal_client->priv->main_context);
+ g_source_unref (idle_source);
}
-/*
- * Converts a GSList of icalcomponents into a NULL-terminated array of
- * valid UTF-8 strings, suitable for sending over DBus.
- */
-static gchar **
-icalcomponent_slist_to_utf8_icomp_array (GSList *icalcomponents)
-{
- gchar **array;
- const GSList *l;
- gint i = 0;
-
- array = g_new0 (gchar *, g_slist_length (icalcomponents) + 1);
- for (l = icalcomponents; l != NULL; l = l->next) {
- gchar *comp_str = icalcomponent_as_ical_string_r ((icalcomponent *) l->data);
- array[i++] = e_util_utf8_make_valid (comp_str);
- g_free (comp_str);
+static void
+cal_client_dbus_proxy_notify_cb (EDBusCalendar *dbus_proxy,
+ GParamSpec *pspec,
+ ECalClient *cal_client)
+{
+ const gchar *backend_prop_name = NULL;
+
+ if (g_str_equal (pspec->name, "alarm-email-address")) {
+ backend_prop_name = CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS;
+ }
+
+ if (g_str_equal (pspec->name, "cache-dir")) {
+ backend_prop_name = CLIENT_BACKEND_PROPERTY_CACHE_DIR;
+ }
+
+ if (g_str_equal (pspec->name, "cal-email-address")) {
+ backend_prop_name = CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS;
+ }
+
+ if (g_str_equal (pspec->name, "capabilities")) {
+ gchar **strv;
+ gchar *csv;
+
+ backend_prop_name = CLIENT_BACKEND_PROPERTY_CAPABILITIES;
+
+ strv = e_dbus_calendar_dup_capabilities (dbus_proxy);
+ csv = g_strjoinv (",", strv);
+ e_client_set_capabilities (E_CLIENT (cal_client), csv);
+ g_free (csv);
+ g_free (strv);
+ }
+
+ if (g_str_equal (pspec->name, "default-object")) {
+ backend_prop_name = CAL_BACKEND_PROPERTY_DEFAULT_OBJECT;
+ }
+
+ if (g_str_equal (pspec->name, "online")) {
+ gboolean online;
+
+ backend_prop_name = CLIENT_BACKEND_PROPERTY_ONLINE;
+
+ online = e_dbus_calendar_get_online (dbus_proxy);
+ e_client_set_online (E_CLIENT (cal_client), online);
+ }
+
+ if (g_str_equal (pspec->name, "revision")) {
+ backend_prop_name = CLIENT_BACKEND_PROPERTY_REVISION;
+ }
+
+ if (g_str_equal (pspec->name, "writable")) {
+ gboolean writable;
+
+ backend_prop_name = CLIENT_BACKEND_PROPERTY_READONLY;
+
+ writable = e_dbus_calendar_get_writable (dbus_proxy);
+ e_client_set_readonly (E_CLIENT (cal_client), !writable);
}
- return array;
+ if (backend_prop_name != NULL) {
+ GSource *idle_source;
+ SignalClosure *signal_closure;
+
+ signal_closure = g_slice_new0 (SignalClosure);
+ signal_closure->client = g_object_ref (cal_client);
+ signal_closure->property_name = g_strdup (backend_prop_name);
+
+ idle_source = g_idle_source_new ();
+ g_source_set_callback (
+ idle_source,
+ cal_client_emit_backend_property_changed_idle_cb,
+ signal_closure,
+ (GDestroyNotify) signal_closure_free);
+ g_source_attach (idle_source, cal_client->priv->main_context);
+ g_source_unref (idle_source);
+ }
}
-/*
- * Converts a GSList of icalcomponents into a GSList of strings.
- */
-static GSList *
-icalcomponent_slist_to_string_slist (GSList *icalcomponents)
+static void
+cal_client_dbus_proxy_free_busy_data_cb (EDBusCalendar *dbus_proxy,
+ gchar **free_busy_data,
+ ECalClient *cal_client)
{
- GSList *strings = NULL;
- const GSList *l;
+ GSource *idle_source;
+ SignalClosure *signal_closure;
- for (l = icalcomponents; l != NULL; l = l->next) {
- strings = g_slist_prepend (strings, icalcomponent_as_ical_string_r ((icalcomponent *) l->data));
- }
+ signal_closure = g_slice_new0 (SignalClosure);
+ signal_closure->client = g_object_ref (cal_client);
+ signal_closure->free_busy_data = g_strdupv (free_busy_data);
- return g_slist_reverse (strings);
+ idle_source = g_idle_source_new ();
+ g_source_set_callback (
+ idle_source,
+ cal_client_emit_free_busy_data_idle_cb,
+ signal_closure,
+ (GDestroyNotify) signal_closure_free);
+ g_source_attach (idle_source, cal_client->priv->main_context);
+ g_source_unref (idle_source);
}
static void
static void
cal_client_dispose (GObject *object)
{
- EClient *client;
+ ECalClientPrivate *priv;
- client = E_CLIENT (object);
+ priv = E_CAL_CLIENT_GET_PRIVATE (object);
- e_client_cancel_all (client);
+ e_client_cancel_all (E_CLIENT (object));
- gdbus_cal_client_disconnect (E_CAL_CLIENT (client));
+ if (priv->dbus_proxy_error_handler_id > 0) {
+ g_signal_handler_disconnect (
+ priv->dbus_proxy,
+ priv->dbus_proxy_error_handler_id);
+ priv->dbus_proxy_error_handler_id = 0;
+ }
+
+ if (priv->dbus_proxy_notify_handler_id > 0) {
+ g_signal_handler_disconnect (
+ priv->dbus_proxy,
+ priv->dbus_proxy_notify_handler_id);
+ priv->dbus_proxy_notify_handler_id = 0;
+ }
+
+ if (priv->dbus_proxy_free_busy_data_handler_id > 0) {
+ g_signal_handler_disconnect (
+ priv->dbus_proxy,
+ priv->dbus_proxy_free_busy_data_handler_id);
+ priv->dbus_proxy_free_busy_data_handler_id = 0;
+ }
+
+ gdbus_cal_client_disconnect (E_CAL_CLIENT (object));
+
+ if (priv->main_context != NULL) {
+ g_main_context_unref (priv->main_context);
+ priv->main_context = NULL;
+ }
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (e_cal_client_parent_class)->dispose (object);
priv = client->priv;
- g_free (priv->cache_dir);
- priv->cache_dir = NULL;
-
if (priv->default_zone && priv->default_zone != icaltimezone_get_utc_timezone ())
icaltimezone_free (priv->default_zone, 1);
- priv->default_zone = NULL;
g_mutex_lock (&priv->zone_cache_lock);
g_hash_table_destroy (priv->zone_cache);
- priv->zone_cache = NULL;
g_mutex_unlock (&priv->zone_cache_lock);
+
g_mutex_clear (&priv->zone_cache_lock);
/* Chain up to parent's finalize() method. */
priv = E_CAL_CLIENT_GET_PRIVATE (client);
- return priv->dbus_proxy;
+ return G_DBUS_PROXY (priv->dbus_proxy);
}
static void
unwrap_dbus_error (dbus_error, out_error);
}
-static void
-cal_client_retrieve_capabilities (EClient *client,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- g_return_if_fail (E_IS_CAL_CLIENT (client));
-
- e_client_get_backend_property (client, CLIENT_BACKEND_PROPERTY_CAPABILITIES, cancellable, callback, user_data);
-}
-
-static gboolean
-cal_client_retrieve_capabilities_finish (EClient *client,
- GAsyncResult *result,
- gchar **capabilities,
- GError **error)
-{
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
-
- return e_client_get_backend_property_finish (client, result, capabilities, error);
-}
-
static gboolean
cal_client_retrieve_capabilities_sync (EClient *client,
gchar **capabilities,
GCancellable *cancellable,
GError **error)
{
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
-
- return e_client_get_backend_property_sync (client, CLIENT_BACKEND_PROPERTY_CAPABILITIES, capabilities, cancellable, error);
-}
-
-static void
-cal_client_get_backend_property (EClient *client,
- const gchar *prop_name,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_client_proxy_call_string_with_res_op_data (
- client, prop_name, cancellable, callback, user_data, cal_client_get_backend_property, prop_name,
- e_gdbus_cal_call_get_backend_property,
- NULL, NULL, e_gdbus_cal_call_get_backend_property_finish, NULL, NULL);
-}
-
-static gboolean
-cal_client_get_backend_property_finish (EClient *client,
- GAsyncResult *result,
- gchar **prop_value,
- GError **error)
-{
- g_return_val_if_fail (prop_value != NULL, FALSE);
-
- return e_client_proxy_call_finish_string (client, result, prop_value, error, cal_client_get_backend_property);
+ return e_client_get_backend_property_sync (
+ client, CLIENT_BACKEND_PROPERTY_CAPABILITIES,
+ capabilities, cancellable, error);
}
static gboolean
GError **error)
{
ECalClient *cal_client;
-
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
+ EDBusCalendar *dbus_proxy;
+ gchar **strv;
cal_client = E_CAL_CLIENT (client);
+ dbus_proxy = cal_client->priv->dbus_proxy;
- if (cal_client->priv->dbus_proxy == NULL) {
- set_proxy_gone_error (error);
- return FALSE;
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_OPENED)) {
+ *prop_value = g_strdup ("TRUE");
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_OPENING)) {
+ *prop_value = g_strdup ("FALSE");
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_ONLINE)) {
+ if (e_dbus_calendar_get_online (dbus_proxy))
+ *prop_value = g_strdup ("TRUE");
+ else
+ *prop_value = g_strdup ("FALSE");
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_READONLY)) {
+ if (e_dbus_calendar_get_writable (dbus_proxy))
+ *prop_value = g_strdup ("FALSE");
+ else
+ *prop_value = g_strdup ("TRUE");
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_CACHE_DIR)) {
+ *prop_value = e_dbus_calendar_dup_cache_dir (dbus_proxy);
+ return TRUE;
}
- return e_client_proxy_call_sync_string__string (client, prop_name, prop_value, cancellable, error, e_gdbus_cal_call_get_backend_property_sync);
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_REVISION)) {
+ *prop_value = e_dbus_calendar_dup_revision (dbus_proxy);
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_CAPABILITIES)) {
+ strv = e_dbus_calendar_dup_capabilities (dbus_proxy);
+ *prop_value = g_strjoinv (",", strv);
+ g_strfreev (strv);
+ return TRUE;
+ }
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS)) {
+ *prop_value = e_dbus_calendar_dup_alarm_email_address (dbus_proxy);
+ }
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS)) {
+ *prop_value = e_dbus_calendar_dup_cal_email_address (dbus_proxy);
+ }
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_DEFAULT_OBJECT)) {
+ *prop_value = e_dbus_calendar_dup_default_object (dbus_proxy);
+ }
+
+ g_set_error (
+ error, E_CLIENT_ERROR, E_CLIENT_ERROR_NOT_SUPPORTED,
+ _("Unknown calendar property '%s'"), prop_name);
+
+ return FALSE;
}
static gboolean
return FALSE;
}
-static void
-cal_client_open (EClient *client,
- gboolean only_if_exists,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_client_proxy_call_boolean (
- client, only_if_exists, cancellable, callback, user_data, cal_client_open,
- e_gdbus_cal_call_open,
- e_gdbus_cal_call_open_finish, NULL, NULL, NULL, NULL);
-}
-
-static gboolean
-cal_client_open_finish (EClient *client,
- GAsyncResult *result,
- GError **error)
-{
- return e_client_proxy_call_finish_void (client, result, error, cal_client_open);
-}
-
static gboolean
cal_client_open_sync (EClient *client,
gboolean only_if_exists,
return FALSE;
}
- return e_client_proxy_call_sync_boolean__void (client, only_if_exists, cancellable, error, e_gdbus_cal_call_open_sync);
-}
-
-static void
-cal_client_refresh (EClient *client,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_client_proxy_call_void (
- client, cancellable, callback, user_data, cal_client_refresh,
- e_gdbus_cal_call_refresh,
- e_gdbus_cal_call_refresh_finish, NULL, NULL, NULL, NULL);
+ return e_dbus_calendar_call_open_sync (
+ cal_client->priv->dbus_proxy, cancellable, error);
}
static gboolean
-cal_client_refresh_finish (EClient *client,
- GAsyncResult *result,
- GError **error)
-{
- return e_client_proxy_call_finish_void (client, result, error, cal_client_refresh);
-}
-
-static gboolean
-cal_client_refresh_sync (EClient *client,
- GCancellable *cancellable,
- GError **error)
+cal_client_refresh_sync (EClient *client,
+ GCancellable *cancellable,
+ GError **error)
{
ECalClient *cal_client;
return FALSE;
}
- return e_client_proxy_call_sync_void__void (client, cancellable, error, e_gdbus_cal_call_refresh_sync);
+ return e_dbus_calendar_call_refresh_sync (
+ cal_client->priv->dbus_proxy, cancellable, error);
+}
+
+static void
+cal_client_init_in_dbus_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ ECalClientPrivate *priv;
+ EClient *client;
+ ESource *source;
+ GDBusConnection *connection;
+ const gchar *uid;
+ gchar *object_path = NULL;
+ gulong handler_id;
+ GError *error = NULL;
+
+ priv = E_CAL_CLIENT_GET_PRIVATE (source_object);
+
+ client = E_CLIENT (source_object);
+ source = e_client_get_source (client);
+ uid = e_source_get_uid (source);
+
+ LOCK_FACTORY ();
+ gdbus_cal_factory_activate (cancellable, &error);
+ UNLOCK_FACTORY ();
+
+ if (error != NULL) {
+ unwrap_dbus_error (error, &error);
+ g_simple_async_result_take_error (simple, error);
+ return;
+ }
+
+ switch (e_cal_client_get_source_type (E_CAL_CLIENT (client))) {
+ case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
+ e_dbus_calendar_factory_call_open_calendar_sync (
+ cal_factory, uid, &object_path,
+ cancellable, &error);
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
+ e_dbus_calendar_factory_call_open_task_list_sync (
+ cal_factory, uid, &object_path,
+ cancellable, &error);
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
+ e_dbus_calendar_factory_call_open_memo_list_sync (
+ cal_factory, uid, &object_path,
+ cancellable, &error);
+ break;
+ default:
+ g_return_if_reached ();
+ }
+
+ /* Sanity check. */
+ g_return_if_fail (
+ ((object_path != NULL) && (error == NULL)) ||
+ ((object_path == NULL) && (error != NULL)));
+
+ if (object_path == NULL) {
+ unwrap_dbus_error (error, &error);
+ g_simple_async_result_take_error (simple, error);
+ return;
+ }
+
+ connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (cal_factory));
+
+ priv->dbus_proxy = e_dbus_calendar_proxy_new_sync (
+ connection,
+ G_DBUS_PROXY_FLAGS_NONE,
+ CALENDAR_DBUS_SERVICE_NAME,
+ object_path,
+ cancellable, &error);
+
+ g_free (object_path);
+
+ /* Sanity check. */
+ g_return_if_fail (
+ ((priv->dbus_proxy != NULL) && (error == NULL)) ||
+ ((priv->dbus_proxy == NULL) && (error != NULL)));
+
+ if (error != NULL) {
+ unwrap_dbus_error (error, &error);
+ g_simple_async_result_take_error (simple, error);
+ return;
+ }
+
+ g_dbus_proxy_set_default_timeout (
+ G_DBUS_PROXY (priv->dbus_proxy), DBUS_PROXY_TIMEOUT_MS);
+
+ priv->gone_signal_id = g_dbus_connection_signal_subscribe (
+ connection,
+ "org.freedesktop.DBus", /* sender */
+ "org.freedesktop.DBus", /* interface */
+ "NameOwnerChanged", /* member */
+ "/org/freedesktop/DBus", /* object_path */
+ "org.gnome.evolution.dataserver.Calendar", /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ gdbus_cal_client_connection_gone_cb, client, NULL);
+
+ g_signal_connect (
+ connection, "closed",
+ G_CALLBACK (gdbus_cal_client_closed_cb), client);
+
+ handler_id = g_signal_connect (
+ priv->dbus_proxy, "error",
+ G_CALLBACK (cal_client_dbus_proxy_error_cb), client);
+ priv->dbus_proxy_error_handler_id = handler_id;
+
+ handler_id = g_signal_connect (
+ priv->dbus_proxy, "notify",
+ G_CALLBACK (cal_client_dbus_proxy_notify_cb), client);
+ priv->dbus_proxy_notify_handler_id = handler_id;
+
+ handler_id = g_signal_connect (
+ priv->dbus_proxy, "free-busy-data",
+ G_CALLBACK (cal_client_dbus_proxy_free_busy_data_cb), client);
+ priv->dbus_proxy_free_busy_data_handler_id = handler_id;
+}
+
+static gboolean
+cal_client_initable_init (GInitable *initable,
+ GCancellable *cancellable,
+ GError **error)
+{
+ EAsyncClosure *closure;
+ GAsyncResult *result;
+ gboolean success;
+
+ closure = e_async_closure_new ();
+
+ g_async_initable_init_async (
+ G_ASYNC_INITABLE (initable),
+ G_PRIORITY_DEFAULT, cancellable,
+ e_async_closure_callback, closure);
+
+ result = e_async_closure_wait (closure);
+
+ success = g_async_initable_init_finish (
+ G_ASYNC_INITABLE (initable), result, error);
+
+ e_async_closure_free (closure);
+
+ return success;
+}
+
+static void
+cal_client_initable_init_async (GAsyncInitable *initable,
+ gint io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GSimpleAsyncResult *simple;
+
+ simple = g_simple_async_result_new (
+ G_OBJECT (initable), callback, user_data,
+ cal_client_initable_init_async);
+
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ cal_client_run_in_dbus_thread (
+ simple, cal_client_init_in_dbus_thread,
+ io_priority, cancellable);
+
+ g_object_unref (simple);
+}
+
+static gboolean
+cal_client_initable_init_finish (GAsyncInitable *initable,
+ GAsyncResult *result,
+ GError **error)
+{
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (initable),
+ cal_client_initable_init_async), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
static void
object_class->finalize = cal_client_finalize;
client_class = E_CLIENT_CLASS (class);
- client_class->get_dbus_proxy = cal_client_get_dbus_proxy;
- client_class->unwrap_dbus_error = cal_client_unwrap_dbus_error;
- client_class->retrieve_capabilities = cal_client_retrieve_capabilities;
- client_class->retrieve_capabilities_finish = cal_client_retrieve_capabilities_finish;
- client_class->retrieve_capabilities_sync = cal_client_retrieve_capabilities_sync;
- client_class->get_backend_property = cal_client_get_backend_property;
- client_class->get_backend_property_finish = cal_client_get_backend_property_finish;
- client_class->get_backend_property_sync = cal_client_get_backend_property_sync;
- client_class->set_backend_property_sync = cal_client_set_backend_property_sync;
- client_class->open = cal_client_open;
- client_class->open_finish = cal_client_open_finish;
- client_class->open_sync = cal_client_open_sync;
- client_class->refresh = cal_client_refresh;
- client_class->refresh_finish = cal_client_refresh_finish;
- client_class->refresh_sync = cal_client_refresh_sync;
+ client_class->get_dbus_proxy = cal_client_get_dbus_proxy;
+ client_class->unwrap_dbus_error = cal_client_unwrap_dbus_error;
+ client_class->retrieve_capabilities_sync = cal_client_retrieve_capabilities_sync;
+ client_class->get_backend_property_sync = cal_client_get_backend_property_sync;
+ client_class->set_backend_property_sync = cal_client_set_backend_property_sync;
+ client_class->open_sync = cal_client_open_sync;
+ client_class->refresh_sync = cal_client_refresh_sync;
g_object_class_install_property (
object_class,
}
static void
+e_cal_client_initable_init (GInitableIface *interface)
+{
+ interface->init = cal_client_initable_init;
+}
+
+static void
+e_cal_client_async_initable_init (GAsyncInitableIface *interface)
+{
+ interface->init_async = cal_client_initable_init_async;
+ interface->init_finish = cal_client_initable_init_finish;
+}
+
+static void
e_cal_client_timezone_cache_init (ETimezoneCacheInterface *interface)
{
interface->add_timezone = cal_client_add_cached_timezone;
client->priv->default_zone = icaltimezone_get_utc_timezone ();
g_mutex_init (&client->priv->zone_cache_lock);
client->priv->zone_cache = zone_cache;
+
+ /* This is so the D-Bus thread can schedule signal emissions
+ * on the thread-default context for this thread. */
+ client->priv->main_context = g_main_context_ref_thread_default ();
}
/**
ECalClientSourceType source_type,
GError **error)
{
- ECalClient *client;
- GError *err = NULL;
- GDBusConnection *connection;
- const gchar *uid;
- gchar *object_path = NULL;
-
g_return_val_if_fail (E_IS_SOURCE (source), NULL);
g_return_val_if_fail (
source_type == E_CAL_CLIENT_SOURCE_TYPE_EVENTS ||
source_type == E_CAL_CLIENT_SOURCE_TYPE_TASKS ||
source_type == E_CAL_CLIENT_SOURCE_TYPE_MEMOS, NULL);
- LOCK_FACTORY ();
- /* XXX Oops, e_cal_client_new() forgot to take a GCancellable. */
- if (!gdbus_cal_factory_activate (NULL, &err)) {
- UNLOCK_FACTORY ();
- if (err) {
- unwrap_dbus_error (err, &err);
- g_warning ("%s: Failed to run calendar factory: %s", G_STRFUNC, err->message);
- g_propagate_error (error, err);
- } else {
- g_warning ("%s: Failed to run calendar factory: Unknown error", G_STRFUNC);
- g_set_error_literal (error, E_CLIENT_ERROR, E_CLIENT_ERROR_DBUS_ERROR, _("Failed to run calendar factory"));
- }
-
- return NULL;
- }
-
- uid = e_source_get_uid (source);
-
- client = g_object_new (
- E_TYPE_CAL_CLIENT,
+ return g_initable_new (
+ E_TYPE_CAL_CLIENT, NULL, error,
"source", source, "source-type", source_type, NULL);
-
- UNLOCK_FACTORY ();
-
- switch (source_type) {
- case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
- e_dbus_calendar_factory_call_open_calendar_sync (
- cal_factory, uid, &object_path, NULL, &err);
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
- e_dbus_calendar_factory_call_open_task_list_sync (
- cal_factory, uid, &object_path, NULL, &err);
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
- e_dbus_calendar_factory_call_open_memo_list_sync (
- cal_factory, uid, &object_path, NULL, &err);
- break;
- default:
- g_return_val_if_reached (NULL);
- }
-
- /* Sanity check. */
- g_return_val_if_fail (
- ((object_path != NULL) && (err == NULL)) ||
- ((object_path == NULL) && (err != NULL)), NULL);
-
- if (err != NULL) {
- unwrap_dbus_error (err, &err);
- g_propagate_error (error, err);
- g_object_unref (client);
- return NULL;
- }
-
- connection = g_dbus_proxy_get_connection (G_DBUS_PROXY (cal_factory));
-
- client->priv->dbus_proxy = G_DBUS_PROXY (e_gdbus_cal_proxy_new_sync (
- connection,
- G_DBUS_PROXY_FLAGS_NONE,
- CALENDAR_DBUS_SERVICE_NAME,
- object_path,
- NULL, &err));
-
- g_free (object_path);
-
- /* Sanity check. */
- g_return_val_if_fail (
- ((object_path != NULL) && (err == NULL)) ||
- ((object_path == NULL) && (err != NULL)), NULL);
-
- if (err != NULL) {
- unwrap_dbus_error (err, &err);
- g_propagate_error (error, err);
- g_object_unref (client);
- return NULL;
- }
-
- client->priv->gone_signal_id = g_dbus_connection_signal_subscribe (
- connection,
- "org.freedesktop.DBus", /* sender */
- "org.freedesktop.DBus", /* interface */
- "NameOwnerChanged", /* member */
- "/org/freedesktop/DBus", /* object_path */
- "org.gnome.evolution.dataserver.Calendar", /* arg0 */
- G_DBUS_SIGNAL_FLAGS_NONE,
- gdbus_cal_client_connection_gone_cb, client, NULL);
-
- g_signal_connect (
- connection, "closed",
- G_CALLBACK (gdbus_cal_client_closed_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "backend_error",
- G_CALLBACK (backend_error_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "readonly",
- G_CALLBACK (readonly_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "online",
- G_CALLBACK (online_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "opened",
- G_CALLBACK (opened_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "free-busy-data",
- G_CALLBACK (free_busy_data_cb), client);
-
- g_signal_connect (
- client->priv->dbus_proxy, "backend-property-changed",
- G_CALLBACK (backend_property_changed_cb), client);
-
- return client;
}
/**
ECalClientSourceType
e_cal_client_get_source_type (ECalClient *client)
{
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), E_CAL_CLIENT_SOURCE_TYPE_LAST);
+ g_return_val_if_fail (
+ E_IS_CAL_CLIENT (client),
+ E_CAL_CLIENT_SOURCE_TYPE_LAST);
return client->priv->source_type;
}
const gchar *
e_cal_client_get_local_attachment_store (ECalClient *client)
{
- gchar *cache_dir = NULL;
- GError *error = NULL;
-
g_return_val_if_fail (E_IS_CAL_CLIENT (client), NULL);
- if (client->priv->cache_dir || !client->priv->dbus_proxy)
- return client->priv->cache_dir;
-
- e_gdbus_cal_call_get_backend_property_sync (client->priv->dbus_proxy, CLIENT_BACKEND_PROPERTY_CACHE_DIR, &cache_dir, NULL, &error);
-
- if (error == NULL) {
- client->priv->cache_dir = cache_dir;
- } else {
- unwrap_dbus_error (error, &error);
- g_warning ("%s", error->message);
- g_error_free (error);
- }
-
- return client->priv->cache_dir;
+ return e_dbus_calendar_get_cache_dir (client->priv->dbus_proxy);
}
/* icaltimezone_copy does a shallow copy while icaltimezone_free tries to free the entire
* Since: 3.2
**/
void
-e_cal_client_set_default_timezone (ECalClient *client, /* const */ icaltimezone *zone)
+e_cal_client_set_default_timezone (ECalClient *client,
+ icaltimezone *zone)
{
g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (zone != NULL);
*
* Since: 3.2
**/
-/* const */ icaltimezone *
+icaltimezone *
e_cal_client_get_default_timezone (ECalClient *client)
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), NULL);
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- return e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_ONE_ALARM_ONLY);
+ return e_client_check_capability (
+ E_CLIENT (client),
+ CAL_STATIC_CAPABILITY_ONE_ALARM_ONLY);
}
/**
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- return e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_SAVE_SCHEDULES);
+ return e_client_check_capability (
+ E_CLIENT (client),
+ CAL_STATIC_CAPABILITY_SAVE_SCHEDULES);
}
/**
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- return e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_ORGANIZER_MUST_ATTEND);
+ return e_client_check_capability (
+ E_CLIENT (client),
+ CAL_STATIC_CAPABILITY_ORGANIZER_MUST_ATTEND);
}
/**
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- return e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_ORGANIZER_MUST_ACCEPT);
+ return e_client_check_capability (
+ E_CLIENT (client),
+ CAL_STATIC_CAPABILITY_ORGANIZER_MUST_ACCEPT);
}
/**
{
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- return e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_RECURRENCES_NO_MASTER);
+ return e_client_check_capability (
+ E_CLIENT (client),
+ CAL_STATIC_CAPABILITY_RECURRENCES_NO_MASTER);
}
/**
return obj_string;
}
-static gboolean
-complete_string_exchange (gboolean res,
- gchar *out_string,
- gchar **result,
- GError **error)
-{
- g_return_val_if_fail (result != NULL, FALSE);
-
- if (res && out_string) {
- if (*out_string) {
- *result = out_string;
- } else {
- /* empty string is returned as NULL */
- *result = NULL;
- g_free (out_string);
- }
- } else {
- *result = NULL;
- g_free (out_string);
- res = FALSE;
-
- if (error && !*error)
- g_propagate_error (error, e_client_error_create (E_CLIENT_ERROR_INVALID_ARG, NULL));
- }
-
- return res;
-}
-
-static gboolean
-complete_strv_exchange (gboolean res,
- gchar **out_strings,
- GSList **result,
- GError **error)
-{
- g_return_val_if_fail (result != NULL, FALSE);
-
- if (res && out_strings) {
- *result = e_client_util_strv_to_slist ((const gchar * const*) out_strings);
- } else {
- *result = NULL;
- res = FALSE;
-
- if (error && !*error)
- g_propagate_error (error, e_client_error_create (E_CLIENT_ERROR_INVALID_ARG, NULL));
- }
-
- g_strfreev (out_strings);
-
- return res;
-}
-
-static gboolean
-cal_client_get_default_object_from_cache_finish (EClient *client,
- GAsyncResult *result,
- gchar **prop_value,
- GError **error)
+/* Helper for e_cal_client_get_default_object() */
+static void
+cal_client_get_default_object_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
{
- GSimpleAsyncResult *simple;
- GError *local_error = NULL;
-
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (prop_value != NULL, FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (client), cal_client_get_default_object_from_cache_finish), FALSE);
-
- simple = G_SIMPLE_ASYNC_RESULT (result);
+ AsyncContext *async_context;
+ GError *error = NULL;
- if (g_simple_async_result_propagate_error (simple, &local_error)) {
- e_client_unwrap_dbus_error (client, local_error, error);
- return FALSE;
- }
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- *prop_value = g_strdup (g_simple_async_result_get_op_res_gpointer (simple));
+ e_cal_client_get_default_object_sync (
+ E_CAL_CLIENT (source_object),
+ &async_context->out_comp,
+ cancellable, &error);
- return *prop_value != NULL;
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- EClient *base_client = E_CLIENT (client);
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- e_client_proxy_call_string (
- base_client, CAL_BACKEND_PROPERTY_DEFAULT_OBJECT, cancellable, callback, user_data, e_cal_client_get_default_object,
- e_gdbus_cal_call_get_backend_property,
- NULL, NULL, e_gdbus_cal_call_get_backend_property_finish, NULL, NULL);
-}
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
-static gboolean
-complete_get_object (gboolean res,
- gchar *out_string,
- icalcomponent **icalcomp,
- gboolean ensure_unique_uid,
- GError **error)
-{
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ async_context = g_slice_new0 (AsyncContext);
- if (res && out_string) {
- *icalcomp = icalparser_parse_string (out_string);
- if (!*icalcomp) {
- g_propagate_error (error, e_cal_client_error_create (E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
- res = FALSE;
- } else if (ensure_unique_uid && icalcomponent_get_uid (*icalcomp)) {
- /* make sure the UID is always unique */
- gchar *new_uid = e_cal_component_gen_uid ();
-
- icalcomponent_set_uid (*icalcomp, new_uid);
- g_free (new_uid);
- }
- } else {
- *icalcomp = NULL;
- res = FALSE;
- }
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_default_object);
- g_free (out_string);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- return res;
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_default_object_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
* e_cal_client_get_default_object_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @icalcomp: (out): Return value for the default calendar object.
+ * @out_icalcomp: (out): Return value for the default calendar object.
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_default_object() and
- * sets @icalcomp to an #icalcomponent from the backend that contains
- * the default values for properties needed. This @icalcomp should be
+ * sets @out_icalcomp to an #icalcomponent from the backend that contains
+ * the default values for properties needed. This @out_icalcomp should be
* freed with icalcomponent_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_default_object_finish (ECalClient *client,
GAsyncResult *result,
- icalcomponent **icalcomp,
+ icalcomponent **out_icalcomp,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_default_object), FALSE);
- if (g_simple_async_result_get_source_tag (G_SIMPLE_ASYNC_RESULT (result)) == cal_client_get_default_object_from_cache_finish) {
- res = cal_client_get_default_object_from_cache_finish (E_CLIENT (client), result, &out_string, error);
- } else {
- res = e_client_proxy_call_finish_string (E_CLIENT (client), result, &out_string, error, e_cal_client_get_default_object);
- }
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return complete_get_object (res, out_string, icalcomp, TRUE, error);
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ g_return_val_if_fail (async_context->out_comp != NULL, FALSE);
+
+ if (out_icalcomp != NULL) {
+ *out_icalcomp = async_context->out_comp;
+ async_context->out_comp = NULL;
+ }
+
+ return TRUE;
}
/**
* e_cal_client_get_default_object_sync:
* @client: an #ECalClient
- * @icalcomp: (out): Return value for the default calendar object.
+ * @out_icalcomp: (out): Return value for the default calendar object.
* @cancellable: a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* Retrives an #icalcomponent from the backend that contains the default
- * values for properties needed. This @icalcomp should be freed with
+ * values for properties needed. This @out_icalcomp should be freed with
* icalcomponent_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
**/
gboolean
e_cal_client_get_default_object_sync (ECalClient *client,
- icalcomponent **icalcomp,
+ icalcomponent **out_icalcomp,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL;
+ icalcomponent *icalcomp = NULL;
+ gchar *string;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ g_return_val_if_fail (out_icalcomp != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- res = e_client_proxy_call_sync_string__string (E_CLIENT (client), CAL_BACKEND_PROPERTY_DEFAULT_OBJECT, &out_string, cancellable, error, e_gdbus_cal_call_get_backend_property_sync);
+ string = e_dbus_calendar_dup_default_object (client->priv->dbus_proxy);
+ if (string != NULL) {
+ icalcomp = icalparser_parse_string (string);
+ g_free (string);
+ }
- return complete_get_object (res, out_string, icalcomp, TRUE, error);
-}
+ if (icalcomp == NULL) {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ return FALSE;
+ }
-static gboolean
-complete_get_object_master (ECalClientSourceType source_type,
- gboolean res,
- gchar *out_string,
- icalcomponent **icalcomp,
- GError **error)
-{
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ if (icalcomponent_get_uid (icalcomp) != NULL) {
+ gchar *new_uid;
- if (res && out_string) {
- icalcomponent *tmp_comp = icalparser_parse_string (out_string);
- if (!tmp_comp) {
- *icalcomp = NULL;
- g_propagate_error (error, e_cal_client_error_create (E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
- res = FALSE;
- } else {
- icalcomponent_kind kind;
- icalcomponent *master_comp = NULL;
-
- switch (source_type) {
- case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
- kind = ICAL_VEVENT_COMPONENT;
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
- kind = ICAL_VTODO_COMPONENT;
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
- kind = ICAL_VJOURNAL_COMPONENT;
- break;
- default:
- icalcomponent_free (tmp_comp);
- *icalcomp = NULL;
- res = FALSE;
+ /* Make sure the UID is always unique. */
+ new_uid = e_cal_component_gen_uid ();
+ icalcomponent_set_uid (icalcomp, new_uid);
+ g_free (new_uid);
+ }
- g_warn_if_reached ();
- }
+ *out_icalcomp = icalcomp;
- if (res && icalcomponent_isa (tmp_comp) == kind) {
- *icalcomp = tmp_comp;
- tmp_comp = NULL;
- } else if (res && icalcomponent_isa (tmp_comp) == ICAL_VCALENDAR_COMPONENT) {
- for (master_comp = icalcomponent_get_first_component (tmp_comp, kind);
- master_comp;
- master_comp = icalcomponent_get_next_component (tmp_comp, kind)) {
- if (!icalcomponent_get_uid (master_comp))
- continue;
+ return TRUE;
+}
- if (icaltime_is_null_time (icalcomponent_get_recurrenceid (master_comp)) ||
- !icaltime_is_valid_time (icalcomponent_get_recurrenceid (master_comp)))
- break;
- }
+/* Helper for e_cal_client_get_object() */
+static void
+cal_client_get_object_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- if (!master_comp)
- master_comp = icalcomponent_get_first_component (tmp_comp, kind);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- *icalcomp = master_comp ? icalcomponent_new_clone (master_comp) : NULL;
- }
+ e_cal_client_get_object_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->uid,
+ async_context->rid,
+ &async_context->out_comp,
+ cancellable, &error);
- if (tmp_comp)
- icalcomponent_free (tmp_comp);
- }
- } else {
- *icalcomp = NULL;
- res = FALSE;
- }
-
- g_free (out_string);
-
- return res && *icalcomp;
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (uid != NULL);
+ /* rid is optional */
- strv = e_gdbus_cal_encode_get_object (uid, rid);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->uid = g_strdup (uid);
+ async_context->rid = g_strdup (rid);
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_get_object,
- e_gdbus_cal_call_get_object,
- NULL, NULL, e_gdbus_cal_call_get_object_finish, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_object);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_object_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
* e_cal_client_get_object_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @icalcomp: (out): Return value for the calendar component object.
+ * @out_icalcomp: (out): Return value for the calendar component object.
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_object() and
- * sets @icalcomp to queried component. This function always returns
+ * sets @out_icalcomp to queried component. This function always returns
* master object for a case of @rid being NULL or an empty string.
* This component should be freed with icalcomponent_free().
*
gboolean
e_cal_client_get_object_finish (ECalClient *client,
GAsyncResult *result,
- icalcomponent **icalcomp,
+ icalcomponent **out_icalcomp,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_object), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ g_return_val_if_fail (async_context->out_comp != NULL, FALSE);
- res = e_client_proxy_call_finish_string (E_CLIENT (client), result, &out_string, error, e_cal_client_get_object);
+ if (out_icalcomp != NULL) {
+ *out_icalcomp = async_context->out_comp;
+ async_context->out_comp = NULL;
+ }
- return complete_get_object_master (e_cal_client_get_source_type (client), res, out_string, icalcomp, error);
+ return TRUE;
}
/**
* @client: an #ECalClient
* @uid: Unique identifier for a calendar component.
* @rid: Recurrence identifier.
- * @icalcomp: (out): Return value for the calendar component object.
+ * @out_icalcomp: (out): Return value for the calendar component object.
* @cancellable: a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
e_cal_client_get_object_sync (ECalClient *client,
const gchar *uid,
const gchar *rid,
- icalcomponent **icalcomp,
+ icalcomponent **out_icalcomp,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL, **strv;
+ icalcomponent *icalcomp = NULL;
+ icalcomponent_kind kind;
+ gchar *utf8_uid;
+ gchar *utf8_rid;
+ gchar *string = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
- g_return_val_if_fail (icalcomp != NULL, FALSE);
+ g_return_val_if_fail (out_icalcomp != NULL, FALSE);
+
+ if (rid == NULL)
+ rid = "";
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- strv = e_gdbus_cal_encode_get_object (uid, rid);
- res = e_client_proxy_call_sync_strv__string (E_CLIENT (client), (const gchar * const *) strv, &out_string, cancellable, error, e_gdbus_cal_call_get_object_sync);
- g_strfreev (strv);
+ utf8_uid = e_util_utf8_make_valid (uid);
+ utf8_rid = e_util_utf8_make_valid (rid);
+
+ success = e_dbus_calendar_call_get_object_sync (
+ client->priv->dbus_proxy, utf8_uid, utf8_rid,
+ &string, cancellable, error);
+
+ g_free (utf8_uid);
+ g_free (utf8_rid);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (string != NULL)) ||
+ (!success && (string == NULL)), FALSE);
+
+ if (!success)
+ return FALSE;
+
+ icalcomp = icalparser_parse_string (string);
+
+ g_free (string);
+
+ if (icalcomp == NULL) {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ return FALSE;
+ }
+
+ switch (e_cal_client_get_source_type (client)) {
+ case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
+ kind = ICAL_VEVENT_COMPONENT;
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
+ kind = ICAL_VTODO_COMPONENT;
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
+ kind = ICAL_VJOURNAL_COMPONENT;
+ break;
+ default:
+ g_warn_if_reached ();
+ kind = ICAL_VEVENT_COMPONENT;
+ break;
+ }
+
+ if (icalcomponent_isa (icalcomp) == kind) {
+ *out_icalcomp = icalcomp;
- return complete_get_object_master (e_cal_client_get_source_type (client), res, out_string, icalcomp, error);
+ } else if (icalcomponent_isa (icalcomp) == ICAL_VCALENDAR_COMPONENT) {
+ icalcomponent *subcomponent;
+
+ for (subcomponent = icalcomponent_get_first_component (icalcomp, kind);
+ subcomponent != NULL;
+ subcomponent = icalcomponent_get_next_component (icalcomp, kind)) {
+ struct icaltimetype recurrenceid;
+
+ if (icalcomponent_get_uid (subcomponent) == NULL)
+ continue;
+
+ recurrenceid =
+ icalcomponent_get_recurrenceid (subcomponent);
+
+ if (icaltime_is_null_time (recurrenceid))
+ break;
+
+ if (!icaltime_is_valid_time (recurrenceid))
+ break;
+ }
+
+ if (subcomponent == NULL)
+ subcomponent = icalcomponent_get_first_component (icalcomp, kind);
+ if (subcomponent != NULL)
+ subcomponent = icalcomponent_new_clone (subcomponent);
+
+ /* XXX Shouldn't we set an error is this is still NULL? */
+ *out_icalcomp = subcomponent;
+
+ icalcomponent_free (icalcomp);
+ }
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_get_objects_for_uid() */
+static void
+cal_client_get_objects_for_uid_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_get_objects_for_uid_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->uid,
+ &async_context->object_list,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (uid != NULL);
- strv = e_gdbus_cal_encode_get_object (uid, "");
-
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_get_objects_for_uid,
- e_gdbus_cal_call_get_object,
- NULL, NULL, e_gdbus_cal_call_get_object_finish, NULL, NULL);
-
- g_strfreev (strv);
-}
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->uid = g_strdup (uid);
-static gboolean
-complete_get_objects_for_uid (ECalClientSourceType source_type,
- gboolean res,
- gchar *out_string,
- GSList **ecalcomps,
- GError **error)
-{
- icalcomponent *icalcomp = NULL;
- icalcomponent_kind kind;
- ECalComponent *comp;
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_objects_for_uid);
- res = complete_get_object (res, out_string, &icalcomp, FALSE, error);
- if (!res || !icalcomp)
- return FALSE;
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- kind = icalcomponent_isa (icalcomp);
- if ((kind == ICAL_VEVENT_COMPONENT && source_type == E_CAL_CLIENT_SOURCE_TYPE_EVENTS) ||
- (kind == ICAL_VTODO_COMPONENT && source_type == E_CAL_CLIENT_SOURCE_TYPE_TASKS) ||
- (kind == ICAL_VJOURNAL_COMPONENT && source_type == E_CAL_CLIENT_SOURCE_TYPE_MEMOS)) {
- comp = e_cal_component_new ();
- e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (icalcomp));
- *ecalcomps = g_slist_append (NULL, comp);
- } else if (kind == ICAL_VCALENDAR_COMPONENT) {
- icalcomponent *subcomp;
- icalcomponent_kind kind_to_find;
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- switch (source_type) {
- case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
- kind_to_find = ICAL_VTODO_COMPONENT;
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
- kind_to_find = ICAL_VJOURNAL_COMPONENT;
- break;
- case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
- default:
- kind_to_find = ICAL_VEVENT_COMPONENT;
- break;
- }
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_objects_for_uid_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- *ecalcomps = NULL;
- subcomp = icalcomponent_get_first_component (icalcomp, kind_to_find);
- while (subcomp) {
- comp = e_cal_component_new ();
- e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp));
- *ecalcomps = g_slist_prepend (*ecalcomps, comp);
- subcomp = icalcomponent_get_next_component (icalcomp, kind_to_find);
- }
-
- *ecalcomps = g_slist_reverse (*ecalcomps);
- }
-
- icalcomponent_free (icalcomp);
-
- return TRUE;
+ g_object_unref (simple);
}
/**
* e_cal_client_get_objects_for_uid_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @ecalcomps: (out) (transfer full) (element-type ECalComponent): Return value
- * for the list of objects obtained from the backend
+ * @out_ecalcomps: (out) (transfer full) (element-type ECalComponent):
+ * Return location for the list of objects obtained from the
+ * backend
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_objects_for_uid() and
- * sets @ecalcomps to a list of #ECalComponent<!-- -->s corresponding to
+ * sets @out_ecalcomps to a list of #ECalComponent<!-- -->s corresponding to
* found components for a given uid of the same type as this client.
* This list should be freed with e_cal_client_free_ecalcomp_slist().
*
gboolean
e_cal_client_get_objects_for_uid_finish (ECalClient *client,
GAsyncResult *result,
- GSList **ecalcomps,
+ GSList **out_ecalcomps,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (ecalcomps != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_objects_for_uid), FALSE);
- res = e_client_proxy_call_finish_string (E_CLIENT (client), result, &out_string, error, e_cal_client_get_objects_for_uid);
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return complete_get_objects_for_uid (e_cal_client_get_source_type (client), res, out_string, ecalcomps, error);
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ if (out_ecalcomps != NULL) {
+ *out_ecalcomps = async_context->object_list;
+ async_context->object_list = NULL;
+ }
+
+ return TRUE;
}
/**
* e_cal_client_get_objects_for_uid_sync:
* @client: an #ECalClient
* @uid: Unique identifier for a calendar component
- * @ecalcomps: (out) (transfer full) (element-type ECalComponent): Return value
- * for the list of objects obtained from the backend
+ * @out_ecalcomps: (out) (transfer full) (element-type ECalComponent):
+ * Return location for the list of objects obtained from the
+ * backend
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
gboolean
e_cal_client_get_objects_for_uid_sync (ECalClient *client,
const gchar *uid,
- GSList **ecalcomps,
+ GSList **out_ecalcomps,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL, **strv = NULL;
+ icalcomponent *icalcomp;
+ icalcomponent_kind kind;
+ gchar *utf8_uid;
+ gchar *string = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
- g_return_val_if_fail (ecalcomps != NULL, FALSE);
+ g_return_val_if_fail (out_ecalcomps != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- strv = e_gdbus_cal_encode_get_object (uid, "");
- res = e_client_proxy_call_sync_strv__string (E_CLIENT (client), (const gchar * const *) strv, &out_string, cancellable, error, e_gdbus_cal_call_get_object_sync);
- g_strfreev (strv);
+ utf8_uid = e_util_utf8_make_valid (uid);
- return complete_get_objects_for_uid (e_cal_client_get_source_type (client), res, out_string, ecalcomps, error);
+ success = e_dbus_calendar_call_get_object_sync (
+ client->priv->dbus_proxy, utf8_uid, "",
+ &string, cancellable, error);
+
+ g_free (utf8_uid);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (string != NULL)) ||
+ (!success && (string == NULL)), FALSE);
+
+ icalcomp = icalparser_parse_string (string);
+
+ g_free (string);
+
+ if (icalcomp == NULL) {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ return FALSE;
+ }
+
+ switch (e_cal_client_get_source_type (client)) {
+ case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
+ kind = ICAL_VEVENT_COMPONENT;
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
+ kind = ICAL_VTODO_COMPONENT;
+ break;
+ case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
+ kind = ICAL_VJOURNAL_COMPONENT;
+ break;
+ default:
+ g_warn_if_reached ();
+ kind = ICAL_VEVENT_COMPONENT;
+ break;
+ }
+
+ if (icalcomponent_isa (icalcomp) == kind) {
+ ECalComponent *comp;
+
+ comp = e_cal_component_new ();
+ e_cal_component_set_icalcomponent (comp, icalcomp);
+ *out_ecalcomps = g_slist_append (NULL, comp);
+
+ } else if (icalcomponent_isa (icalcomp) == ICAL_VCALENDAR_COMPONENT) {
+ GSList *tmp = NULL;
+ icalcomponent *subcomponent;
+
+ subcomponent = icalcomponent_get_first_component (
+ icalcomp, kind);
+
+ while (subcomponent != NULL) {
+ ECalComponent *comp;
+ icalcomponent *clone;
+
+ comp = e_cal_component_new ();
+ clone = icalcomponent_new_clone (subcomponent);
+ e_cal_component_set_icalcomponent (comp, clone);
+ tmp = g_slist_prepend (tmp, comp);
+
+ subcomponent = icalcomponent_get_next_component (
+ icalcomp, kind);
+ }
+
+ *out_ecalcomps = g_slist_reverse (tmp);
+
+ icalcomponent_free (icalcomp);
+ }
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_get_object_list() */
+static void
+cal_client_get_object_list_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_get_object_list_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->sexp,
+ &async_context->comp_list,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *gdbus_sexp = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (sexp != NULL);
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), cancellable, callback, user_data, e_cal_client_get_object_list,
- e_gdbus_cal_call_get_object_list,
- NULL, NULL, NULL, e_gdbus_cal_call_get_object_list_finish, NULL);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->sexp = g_strdup (sexp);
- g_free (gdbus_sexp);
-}
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_object_list);
-static gboolean
-complete_get_object_list (gboolean res,
- gchar **out_strv,
- GSList **icalcomps,
- GError **error)
-{
- g_return_val_if_fail (icalcomps != NULL, FALSE);
-
- *icalcomps = NULL;
-
- if (res && out_strv) {
- gint ii;
- icalcomponent *icalcomp;
-
- for (ii = 0; out_strv[ii]; ii++) {
- icalcomp = icalcomponent_new_from_string (out_strv[ii]);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- if (!icalcomp)
- continue;
-
- *icalcomps = g_slist_prepend (*icalcomps, icalcomp);
- }
-
- *icalcomps = g_slist_reverse (*icalcomps);
- } else {
- res = FALSE;
- }
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- g_strfreev (out_strv);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_object_list_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- return res;
+ g_object_unref (simple);
}
/**
* e_cal_client_get_object_list_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @icalcomps: (out) (element-type icalcomponent): list of matching
- * #icalcomponent<!-- -->s
+ * @out_icalcomps: (out) (element-type icalcomponent): list of matching
+ * #icalcomponent<!-- -->s
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_object_list() and
- * sets @icalcomps to a matching list of #icalcomponent-s.
+ * sets @out_icalcomps to a matching list of #icalcomponent-s.
* This list should be freed with e_cal_client_free_icalcomp_slist().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_object_list_finish (ECalClient *client,
GAsyncResult *result,
- GSList **icalcomps,
+ GSList **out_icalcomps,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (icalcomps != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_object_list), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strv, error, e_cal_client_get_object_list);
+ if (out_icalcomps != NULL) {
+ *out_icalcomps = async_context->comp_list;
+ async_context->comp_list = NULL;
+ }
- return complete_get_object_list (res, out_strv, icalcomps, error);
+ return TRUE;
}
/**
* e_cal_client_get_object_list_sync:
* @client: an #ECalClient
* @sexp: an S-expression representing the query
- * @icalcomps: (out) (element-type icalcomponent): list of matching
- * #icalcomponent<!-- -->s
+ * @out_icalcomps: (out) (element-type icalcomponent): list of matching
+ * #icalcomponent<!-- -->s
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* Gets a list of objects from the calendar that match the query specified
- * by the @sexp argument. The objects will be returned in the @icalcomps
+ * by the @sexp argument. The objects will be returned in the @out_icalcomps
* argument, which is a list of #icalcomponent.
* This list should be freed with e_cal_client_free_icalcomp_slist().
*
gboolean
e_cal_client_get_object_list_sync (ECalClient *client,
const gchar *sexp,
- GSList **icalcomps,
+ GSList **out_icalcomps,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL, *gdbus_sexp = NULL;
+ GSList *tmp = NULL;
+ gchar *utf8_sexp;
+ gchar **strv = NULL;
+ gboolean success;
+ gint ii;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (sexp != NULL, FALSE);
- g_return_val_if_fail (icalcomps != NULL, FALSE);
+ g_return_val_if_fail (out_icalcomps != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- res = e_client_proxy_call_sync_string__strv (E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), &out_strv, cancellable, error, e_gdbus_cal_call_get_object_list_sync);
- g_free (gdbus_sexp);
+ utf8_sexp = e_util_utf8_make_valid (sexp);
+
+ success = e_dbus_calendar_call_get_object_list_sync (
+ client->priv->dbus_proxy, utf8_sexp,
+ &strv, cancellable, error);
+
+ g_free (utf8_sexp);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (strv != NULL)) ||
+ (!success && (strv == NULL)), FALSE);
+
+ if (!success)
+ return FALSE;
+
+ for (ii = 0; strv[ii] != NULL; ii++) {
+ icalcomponent *icalcomp;
+
+ icalcomp = icalcomponent_new_from_string (strv[ii]);
+ if (icalcomp == NULL)
+ continue;
+
+ tmp = g_slist_prepend (tmp, icalcomp);
+ }
+
+ *out_icalcomps = g_slist_reverse (tmp);
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_get_object_list_as_comps() */
+static void
+cal_client_get_object_list_as_comps_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return complete_get_object_list (res, out_strv, icalcomps, error);
+ e_cal_client_get_object_list_as_comps_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->sexp,
+ &async_context->object_list,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
*
* Since: 3.2
**/
-void
-e_cal_client_get_object_list_as_comps (ECalClient *client,
- const gchar *sexp,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- gchar *gdbus_sexp = NULL;
-
- g_return_if_fail (sexp != NULL);
-
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), cancellable, callback, user_data, e_cal_client_get_object_list_as_comps,
- e_gdbus_cal_call_get_object_list,
- NULL, NULL, NULL, e_gdbus_cal_call_get_object_list_finish, NULL);
-
- g_free (gdbus_sexp);
-}
-
-static gboolean
-complete_get_object_list_as_comps (gboolean res,
- gchar **out_strv,
- GSList **ecalcomps,
- GError **error)
+void
+e_cal_client_get_object_list_as_comps (ECalClient *client,
+ const gchar *sexp,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- GSList *icalcomps = NULL;
-
- g_return_val_if_fail (ecalcomps != NULL, FALSE);
-
- *ecalcomps = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- res = complete_get_object_list (res, out_strv, &icalcomps, error);
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
+ g_return_if_fail (sexp != NULL);
- if (res) {
- GSList *iter;
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->sexp = g_strdup (sexp);
- for (iter = icalcomps; iter; iter = iter->next) {
- ECalComponent *comp;
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_object_list_as_comps);
- comp = e_cal_component_new ();
- /* takes ownership of the icalcomp, thus free only the list at the end */
- if (e_cal_component_set_icalcomponent (comp, iter->data))
- *ecalcomps = g_slist_prepend (*ecalcomps, comp);
- else
- icalcomponent_free (iter->data);
- }
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- g_slist_free (icalcomps);
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- *ecalcomps = g_slist_reverse (*ecalcomps);
- } else {
- e_cal_client_free_icalcomp_slist (icalcomps);
- }
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_object_list_as_comps_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- return res;
+ g_object_unref (simple);
}
/**
* e_cal_client_get_object_list_as_comps_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @ecalcomps: (out) (element-type ECalComponent): list of matching
- * #ECalComponent<!-- -->s
+ * @out_ecalcomps: (out) (element-type ECalComponent): list of matching
+ * #ECalComponent<!-- -->s
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_object_list_as_comps() and
- * sets @ecalcomps to a matching list of #ECalComponent-s.
+ * sets @out_ecalcomps to a matching list of #ECalComponent-s.
* This list should be freed with e_cal_client_free_ecalcomp_slist().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_object_list_as_comps_finish (ECalClient *client,
GAsyncResult *result,
- GSList **ecalcomps,
+ GSList **out_ecalcomps,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_object_list), FALSE);
- g_return_val_if_fail (ecalcomps != NULL, FALSE);
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strv, error, e_cal_client_get_object_list_as_comps);
+ if (out_ecalcomps != NULL) {
+ *out_ecalcomps = async_context->object_list;
+ async_context->object_list = NULL;
+ }
- return complete_get_object_list_as_comps (res, out_strv, ecalcomps, error);
+ return TRUE;
}
/**
* e_cal_client_get_object_list_as_comps_sync:
* @client: an #ECalClient
* @sexp: an S-expression representing the query
- * @ecalcomps: (out) (element-type ECalComponent): list of matching
- * #ECalComponent<!-- -->s
+ * @out_ecalcomps: (out) (element-type ECalComponent): list of matching
+ * #ECalComponent<!-- -->s
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* Gets a list of objects from the calendar that match the query specified
- * by the @sexp argument. The objects will be returned in the @ecalcomps
+ * by the @sexp argument. The objects will be returned in the @out_ecalcomps
* argument, which is a list of #ECalComponent.
* This list should be freed with e_cal_client_free_ecalcomp_slist().
*
gboolean
e_cal_client_get_object_list_as_comps_sync (ECalClient *client,
const gchar *sexp,
- GSList **ecalcomps,
+ GSList **out_ecalcomps,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL, *gdbus_sexp = NULL;
+ GSList *list = NULL;
+ GSList *link;
+ GQueue trash = G_QUEUE_INIT;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (sexp != NULL, FALSE);
- g_return_val_if_fail (ecalcomps != NULL, FALSE);
+ g_return_val_if_fail (out_ecalcomps != NULL, FALSE);
- if (client->priv->dbus_proxy == NULL) {
- set_proxy_gone_error (error);
+ success = e_cal_client_get_object_list_sync (
+ client, sexp, &list, cancellable, error);
+
+ if (!success) {
+ g_warn_if_fail (list == NULL);
return FALSE;
}
- res = e_client_proxy_call_sync_string__strv (E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), &out_strv, cancellable, error, e_gdbus_cal_call_get_object_list_sync);
- g_free (gdbus_sexp);
+ /* Convert the icalcomponent list to an ECalComponent list. */
+ for (link = list; link != NULL; link = g_slist_next (link)) {
+ ECalComponent *comp;
+ icalcomponent *icalcomp = link->data;
+
+ comp = e_cal_component_new ();
+
+ /* This takes ownership of the icalcomponent, if it works. */
+ if (e_cal_component_set_icalcomponent (comp, icalcomp)) {
+ link->data = g_object_ref (comp);
+ } else {
+ /* On failure, free resources and add
+ * the GSList link to the trash queue. */
+ icalcomponent_free (icalcomp);
+ g_queue_push_tail (&trash, link);
+ link->data = NULL;
+ }
+
+ g_object_unref (comp);
+ }
+
+ /* Delete GSList links we failed to convert. */
+ while ((link = g_queue_pop_head (&trash)) != NULL)
+ list = g_slist_delete_link (list, link);
+
+ *out_ecalcomps = list;
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_get_free_busy() */
+static void
+cal_client_get_free_busy_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_get_free_busy_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->start,
+ async_context->end,
+ async_context->string_list,
+ cancellable, &error);
- return complete_get_object_list_as_comps (res, out_strv, ecalcomps, error);
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (start > 0);
g_return_if_fail (end > 0);
- strv = e_gdbus_cal_encode_get_free_busy (start, end, users);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->start = start;
+ async_context->end = end;
+ async_context->string_list = g_slist_copy_deep (
+ (GSList *) users, (GCopyFunc) g_strdup, NULL);
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_get_free_busy,
- e_gdbus_cal_call_get_free_busy,
- e_gdbus_cal_call_get_free_busy_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_free_busy);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_free_busy_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_get_free_busy);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_free_busy), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
GCancellable *cancellable,
GError **error)
{
- gboolean res;
gchar **strv;
+ gboolean success;
+ gint ii = 0;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
+ g_return_val_if_fail (start > 0, FALSE);
+ g_return_val_if_fail (end > 0, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- strv = e_gdbus_cal_encode_get_free_busy (start, end, users);
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_get_free_busy_sync);
+ strv = g_new0 (gchar *, g_slist_length ((GSList *) users) + 1);
+ while (users != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (users->data);
+ users = g_slist_next (users);
+ }
+
+ success = e_dbus_calendar_call_get_free_busy_sync (
+ client->priv->dbus_proxy,
+ (gint64) start, (gint64) end,
+ (const gchar * const *) strv,
+ cancellable, error);
+
g_strfreev (strv);
- return res;
+ return success;
+}
+
+/* Helper for e_cal_client_create_object() */
+static void
+cal_client_create_object_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_create_object_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->in_comp,
+ &async_context->uid,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_create_object (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *comp_str, *gdbus_comp = NULL;
- const gchar *strv[2];
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (icalcomp != NULL);
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
- strv[0] = e_util_ensure_gdbus_string (comp_str, &gdbus_comp);
- strv[1] = NULL;
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->in_comp = icalcomponent_new_clone (icalcomp);
- g_return_if_fail (strv[0] != NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_create_object);
- e_client_proxy_call_strv (
- E_CLIENT (client), strv, cancellable, callback, user_data, e_cal_client_create_object,
- e_gdbus_cal_call_create_objects,
- NULL, NULL, NULL, e_gdbus_cal_call_create_objects_finish, NULL);
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- g_free (comp_str);
- g_free (gdbus_comp);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_create_object_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
* e_cal_client_create_object_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @uid: (out): Return value for the UID assigned to the new component by the calendar backend
+ * @out_uid: (out): Return value for the UID assigned to the new component
+ * by the calendar backend
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_create_object() and
- * sets @uid to newly assigned UID for the created object.
- * This @uid should be freed with g_free().
+ * sets @out_uid to newly assigned UID for the created object.
+ * This @out_uid should be freed with g_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
gboolean
e_cal_client_create_object_finish (ECalClient *client,
GAsyncResult *result,
- gchar **uid,
+ gchar **out_uid,
GError **error)
{
- gboolean res;
- gchar **out_strings = NULL;
- gchar *out_string = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (uid != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_create_object), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strings, error, e_cal_client_create_object);
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ g_return_val_if_fail (async_context->uid != NULL, FALSE);
- if (res && out_strings) {
- out_string = g_strdup (out_strings[0]);
- g_strfreev (out_strings);
+ if (out_uid != NULL) {
+ *out_uid = async_context->uid;
+ async_context->uid = NULL;
}
- return complete_string_exchange (res, out_string, uid, error);
+ return TRUE;
}
/**
* e_cal_client_create_object_sync:
* @client: an #ECalClient
* @icalcomp: The component to create
- * @uid: (out): Return value for the UID assigned to the new component by the calendar backend
+ * @out_uid: (out): Return value for the UID assigned to the new component
+ * by the calendar backend
* @cancellable: a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
- * Requests the calendar backend to create the object specified by the @icalcomp
- * argument. Some backends would assign a specific UID to the newly created object,
- * in those cases that UID would be returned in the @uid argument. This function
- * does not modify the original @icalcomp if its UID changes.
- * Returned @uid should be freed with g_free().
+ * Requests the calendar backend to create the object specified by the
+ * @icalcomp argument. Some backends would assign a specific UID to the newly
+ * created object, in those cases that UID would be returned in the @out_uid
+ * argument. This function does not modify the original @icalcomp if its UID
+ * changes. Returned @out_uid should be freed with g_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
**/
gboolean
e_cal_client_create_object_sync (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
- gchar **uid,
+ icalcomponent *icalcomp,
+ gchar **out_uid,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *comp_str, *gdbus_comp = NULL;
- const gchar *strv[2];
- gchar **out_strings = NULL;
- gchar *out_string = NULL;
+ GSList link = { icalcomp, NULL };
+ GSList *string_list = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (icalcomp != NULL, FALSE);
- g_return_val_if_fail (uid != NULL, FALSE);
- if (client->priv->dbus_proxy == NULL) {
- set_proxy_gone_error (error);
- return FALSE;
- }
+ success = e_cal_client_create_objects_sync (
+ client, &link, &string_list, cancellable, error);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (string_list != NULL)) ||
+ (!success && (string_list == NULL)), FALSE);
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
- strv[0] = e_util_ensure_gdbus_string (comp_str, &gdbus_comp);
- strv[1] = NULL;
+ if (out_uid != NULL && string_list != NULL)
+ *out_uid = g_strdup (string_list->data);
- g_return_val_if_fail (strv[0] != NULL, FALSE);
+ g_slist_free_full (string_list, (GDestroyNotify) g_free);
+
+ return success;
+}
- res = e_client_proxy_call_sync_strv__strv (E_CLIENT (client), strv, &out_strings, cancellable, error, e_gdbus_cal_call_create_objects_sync);
+/* Helper for e_cal_client_create_objects() */
+static void
+cal_client_create_objects_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- g_free (comp_str);
- g_free (gdbus_comp);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- if (res && out_strings) {
- out_string = g_strdup (out_strings[0]);
- g_strfreev (out_strings);
- }
+ e_cal_client_create_objects_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->comp_list,
+ &async_context->string_list,
+ cancellable, &error);
- return complete_string_exchange (res, out_string, uid, error);
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **array;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (icalcomps != NULL);
- array = icalcomponent_slist_to_utf8_icomp_array (icalcomps);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->comp_list = g_slist_copy_deep (
+ icalcomps, (GCopyFunc) icalcomponent_new_clone, NULL);
+
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_create_objects);
+
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) array, cancellable, callback, user_data, e_cal_client_create_objects,
- e_gdbus_cal_call_create_objects,
- NULL, NULL, NULL, e_gdbus_cal_call_create_objects_finish, NULL);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_create_objects_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- g_strfreev (array);
+ g_object_unref (simple);
}
/**
* e_cal_client_create_objects_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @uids: (out) (element-type utf8): Return value for the UIDs assigned to the
- * new components by the calendar backend
+ * @out_uids: (out) (element-type utf8): Return value for the UIDs assigned
+ * to the new components by the calendar backend
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_create_objects() and
- * sets @uids to newly assigned UIDs for the created objects.
- * This @uids should be freed with e_client_util_free_string_slist().
+ * sets @out_uids to newly assigned UIDs for the created objects.
+ * This @out_uids should be freed with e_client_util_free_string_slist().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
gboolean
e_cal_client_create_objects_finish (ECalClient *client,
GAsyncResult *result,
- GSList **uids,
+ GSList **out_uids,
GError **error)
{
- gboolean res;
- gchar **out_strings = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- g_return_val_if_fail (uids != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_create_objects), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strings, error, e_cal_client_create_objects);
+ if (out_uids != NULL) {
+ *out_uids = async_context->string_list;
+ async_context->string_list = NULL;
+ }
- return complete_strv_exchange (res, out_strings, uids, error);
+ return TRUE;
}
/**
* e_cal_client_create_objects_sync:
* @client: an #ECalClient
* @icalcomps: (element-type icalcomponent): The components to create
- * @uids: (out) (element-type utf8): Return value for the UIDs assigned to the
- * new components by the calendar backend
+ * @out_uids: (out) (element-type utf8): Return value for the UIDs assigned
+ * to the new components by the calendar backend
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
- * Requests the calendar backend to create the objects specified by the @icalcomps
- * argument. Some backends would assign a specific UID to the newly created objects,
- * in those cases these UIDs would be returned in the @uids argument. This function
- * does not modify the original @icalcomps if their UID changes.
- * Returned @uid should be freed with e_client_util_free_string_slist().
+ * Requests the calendar backend to create the objects specified by the
+ * @icalcomps argument. Some backends would assign a specific UID to the
+ * newly created objects, in those cases these UIDs would be returned in
+ * the @out_uids argument. This function does not modify the original
+ * @icalcomps if their UID changes. Returned @out_uids should be freed
+ * with e_client_util_free_string_slist().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
gboolean
e_cal_client_create_objects_sync (ECalClient *client,
GSList *icalcomps,
- GSList **uids,
+ GSList **out_uids,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **array, **out_strings = NULL;
+ gchar **strv;
+ gchar **uids = NULL;
+ gboolean success;
+ gint ii = 0;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (icalcomps != NULL, FALSE);
- g_return_val_if_fail (uids != NULL, FALSE);
+ g_return_val_if_fail (out_uids != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- array = icalcomponent_slist_to_utf8_icomp_array (icalcomps);
+ strv = g_new0 (gchar *, g_slist_length (icalcomps) + 1);
+ while (icalcomps != NULL) {
+ gchar *ical_string;
+
+ ical_string = icalcomponent_as_ical_string_r (icalcomps->data);
+ strv[ii++] = e_util_utf8_make_valid (ical_string);
+ g_free (ical_string);
+
+ icalcomps = g_slist_next (icalcomps);
+ }
+
+ success = e_dbus_calendar_call_create_objects_sync (
+ client->priv->dbus_proxy,
+ (const gchar * const *) strv,
+ &uids, cancellable, error);
+
+ g_strfreev (strv);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (uids != NULL)) ||
+ (!success && (uids == NULL)), FALSE);
+
+ if (uids != NULL) {
+ GSList *tmp = NULL;
+
+ /* Steal the string array elements. */
+ for (ii = 0; uids[ii] != NULL; ii++) {
+ tmp = g_slist_prepend (tmp, uids[ii]);
+ uids[ii] = NULL;
+ }
+
+ *out_uids = g_slist_reverse (tmp);
+ }
+
+ g_strfreev (uids);
+
+ return success;
+}
+
+/* Helper for e_cal_client_modify_object() */
+static void
+cal_client_modify_object_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- res = e_client_proxy_call_sync_strv__strv (E_CLIENT (client), (const gchar * const *) array, &out_strings, cancellable, error, e_gdbus_cal_call_create_objects_sync);
+ e_cal_client_modify_object_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->in_comp,
+ async_context->mod,
+ cancellable, &error);
- return complete_strv_exchange (res, out_strings, uids, error);
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_modify_object (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
ECalObjModType mod,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *comp_str, **strv;
- GSList comp_strings = {0,};
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (icalcomp != NULL);
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
- comp_strings.data = comp_str;
- strv = e_gdbus_cal_encode_modify_objects (&comp_strings, mod);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->in_comp = icalcomponent_new_clone (icalcomp);
+ async_context->mod = mod;
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_modify_object,
- e_gdbus_cal_call_modify_objects,
- e_gdbus_cal_call_modify_objects_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_modify_object);
- g_strfreev (strv);
- g_free (comp_str);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_modify_object_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_modify_object);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_modify_object), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
**/
gboolean
e_cal_client_modify_object_sync (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
ECalObjModType mod,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *comp_str, **strv;
- GSList comp_strings = {0,};
+ GSList link = { icalcomp, NULL };
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (icalcomp != NULL, FALSE);
- if (client->priv->dbus_proxy == NULL) {
- set_proxy_gone_error (error);
- return FALSE;
- }
+ return e_cal_client_modify_objects_sync (
+ client, &link, mod, cancellable, error);
+}
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
- comp_strings.data = comp_str;
- strv = e_gdbus_cal_encode_modify_objects (&comp_strings, mod);
+/* Helper for e_cal_client_modify_objects() */
+static void
+cal_client_modify_objects_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_modify_objects_sync);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- g_strfreev (strv);
- g_free (comp_str);
+ e_cal_client_modify_objects_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->comp_list,
+ async_context->mod,
+ cancellable, &error);
- return res;
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_modify_objects (ECalClient *client,
- /* const */ GSList *comps,
+ GSList *comps,
ECalObjModType mod,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSList *comp_strings;
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (comps != NULL);
- comp_strings = icalcomponent_slist_to_string_slist (comps);
- strv = e_gdbus_cal_encode_modify_objects (comp_strings, mod);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->comp_list = g_slist_copy_deep (
+ comps, (GCopyFunc) icalcomponent_new_clone, NULL);
+ async_context->mod = mod;
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_modify_objects,
- e_gdbus_cal_call_modify_objects,
- e_gdbus_cal_call_modify_objects_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_modify_objects);
- g_strfreev (strv);
- e_client_util_free_string_slist (comp_strings);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_modify_objects_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_modify_objects), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_modify_objects);
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
**/
gboolean
e_cal_client_modify_objects_sync (ECalClient *client,
- /* const */ GSList *comps,
+ GSList *comps,
ECalObjModType mod,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
+ GEnumClass *enum_class;
+ GEnumValue *enum_value;
+ gboolean success;
gchar **strv;
- GSList *comp_strings;
+ gint ii = 0;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (comps != NULL, FALSE);
return FALSE;
}
- comp_strings = icalcomponent_slist_to_string_slist (comps);
- strv = e_gdbus_cal_encode_modify_objects (comp_strings, mod);
+ enum_class = g_type_class_ref (E_TYPE_CAL_OBJ_MOD_TYPE);
+ enum_value = g_enum_get_value (enum_class, mod);
+ g_return_val_if_fail (enum_value != NULL, FALSE);
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_modify_objects_sync);
+ strv = g_new0 (gchar *, g_slist_length (comps) + 1);
+ while (comps != NULL) {
+ gchar *ical_string;
+
+ ical_string = icalcomponent_as_ical_string_r (comps->data);
+ strv[ii++] = e_util_utf8_make_valid (ical_string);
+ g_free (ical_string);
+ }
+
+ success = e_dbus_calendar_call_modify_objects_sync (
+ client->priv->dbus_proxy,
+ (const gchar * const *) strv,
+ enum_value->value_nick,
+ cancellable, error);
g_strfreev (strv);
- e_client_util_free_string_slist (comp_strings);
- return res;
+ g_type_class_unref (enum_class);
+
+ return success;
+}
+
+/* Helper for e_cal_client_remove_object() */
+static void
+cal_client_remove_object_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_remove_object_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->uid,
+ async_context->rid,
+ async_context->mod,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
- GSList ids = {0,};
- ECalComponentId id;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (uid != NULL);
+ /* rid is optional */
- id.uid = (gchar *) uid;
- id.rid = (gchar *) rid;
- ids.data = &id;
- strv = e_gdbus_cal_encode_remove_objects (&ids, mod);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->uid = g_strdup (uid);
+ async_context->rid = g_strdup (rid);
+ async_context->mod = mod;
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_remove_object,
- e_gdbus_cal_call_remove_objects,
- e_gdbus_cal_call_remove_objects_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_remove_object);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_remove_object_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_remove_object);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_remove_object), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **strv;
- GSList ids = {0,};
- ECalComponentId id;
+ ECalComponentId id = { (gchar *) uid, (gchar *) rid };
+ GSList link = { &id, NULL };
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
return FALSE;
}
- id.uid = (gchar *) uid;
- id.rid = (gchar *) rid;
- ids.data = &id;
- strv = e_gdbus_cal_encode_remove_objects (&ids, mod);
+ return e_cal_client_remove_objects_sync (
+ client, &link, mod, cancellable, error);
+}
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_remove_objects_sync);
+/* Helper for e_cal_client_remove_objects() */
+static void
+cal_client_remove_objects_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- g_strfreev (strv);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return res;
+ e_cal_client_remove_objects_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->string_list,
+ async_context->mod,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (ids != NULL);
- strv = e_gdbus_cal_encode_remove_objects (ids, mod);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->string_list = g_slist_copy_deep (
+ (GSList *) ids, (GCopyFunc) g_strdup, NULL);
+ async_context->mod = mod;
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_remove_objects,
- e_gdbus_cal_call_remove_objects,
- e_gdbus_cal_call_remove_objects_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_remove_objects);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_remove_objects_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_remove_objects);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_remove_objects), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
* e_cal_client_remove_objects_sync:
* @client: an #ECalClient
- * @ids: (element-type ECalComponentId): A list of #ECalComponentId objects
- * identifying the objects to remove
+ * @ids: (element-type ECalComponentId): a list of #ECalComponentId objects
+ * identifying the objects to remove
* @mod: Type of the removal
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* This function allows the removal of instances of recurrent
- * appointments. #ECalComponentId objects can identify specific instances (if rid is not NULL).
- * If what you want is to remove all instances, use a #NULL rid in the #ECalComponentId and E_CAL_OBJ_MOD_ALL
- * for the @mod.
+ * appointments. #ECalComponentId objects can identify specific instances
+ * (if rid is not %NULL). If what you want is to remove all instances, use
+ * a %NULL rid in the #ECalComponentId and E_CAL_OBJ_MOD_ALL for the @mod.
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **strv;
+ GVariantBuilder builder;
+ GEnumClass *enum_class;
+ GEnumValue *enum_value;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (ids != NULL, FALSE);
return FALSE;
}
- strv = e_gdbus_cal_encode_remove_objects (ids, mod);
+ enum_class = g_type_class_ref (E_TYPE_CAL_OBJ_MOD_TYPE);
+ enum_value = g_enum_get_value (enum_class, mod);
+ g_return_val_if_fail (enum_value != NULL, FALSE);
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_remove_objects_sync);
+ g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
+ while (ids != NULL) {
+ ECalComponentId *id = ids->data;
+ gchar *utf8_uid;
+ gchar *utf8_rid;
- g_strfreev (strv);
+ if (id->uid == NULL || *id->uid == '\0')
+ continue;
+
+ utf8_uid = e_util_utf8_make_valid (id->uid);
+ if (id->rid != NULL)
+ utf8_rid = e_util_utf8_make_valid (id->rid);
+ else
+ utf8_rid = g_strdup ("");
+
+ g_variant_builder_add (&builder, "(ss)", utf8_uid, utf8_rid);
+
+ g_free (utf8_uid);
+ g_free (utf8_rid);
+ }
+
+ success = e_dbus_calendar_call_remove_objects_sync (
+ client->priv->dbus_proxy,
+ g_variant_builder_end (&builder),
+ enum_value->value_nick,
+ cancellable, error);
+
+ g_type_class_unref (enum_class);
+
+ return success;
+}
+
+/* Helper for e_cal_client_receive_objects() */
+static void
+cal_client_receive_objects_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return res;
+ e_cal_client_receive_objects_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->in_comp,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_receive_objects (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *comp_str, *gdbus_comp = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (icalcomp != NULL);
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->in_comp = icalcomponent_new_clone (icalcomp);
+
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_receive_objects);
+
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (comp_str, &gdbus_comp), cancellable, callback, user_data, e_cal_client_receive_objects,
- e_gdbus_cal_call_receive_objects,
- e_gdbus_cal_call_receive_objects_finish, NULL, NULL, NULL, NULL);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_receive_objects_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- g_free (comp_str);
- g_free (gdbus_comp);
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_receive_objects);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_receive_objects), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
**/
gboolean
e_cal_client_receive_objects_sync (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *comp_str, *gdbus_comp = NULL;
+ gchar *ical_string;
+ gchar *utf8_ical_string;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
return FALSE;
}
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
+ ical_string = icalcomponent_as_ical_string_r (icalcomp);
+ utf8_ical_string = e_util_utf8_make_valid (ical_string);
+
+ success = e_dbus_calendar_call_receive_objects_sync (
+ client->priv->dbus_proxy,
+ utf8_ical_string, cancellable, error);
+
+ g_free (utf8_ical_string);
+ g_free (ical_string);
+
+ return success;
+}
+
+/* Helper for e_cal_client_send_objects() */
+static void
+cal_client_send_objects_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- res = e_client_proxy_call_sync_string__void (E_CLIENT (client), e_util_ensure_gdbus_string (comp_str, &gdbus_comp), cancellable, error, e_gdbus_cal_call_receive_objects_sync);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- g_free (comp_str);
- g_free (gdbus_comp);
+ e_cal_client_send_objects_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->in_comp,
+ &async_context->string_list,
+ &async_context->out_comp,
+ cancellable, &error);
- return res;
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_send_objects (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
+ icalcomponent *icalcomp,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *comp_str, *gdbus_comp = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (icalcomp != NULL);
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
-
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (comp_str, &gdbus_comp), cancellable, callback, user_data, e_cal_client_send_objects,
- e_gdbus_cal_call_send_objects,
- NULL, NULL, NULL, e_gdbus_cal_call_send_objects_finish, NULL);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->in_comp = icalcomponent_new_clone (icalcomp);
- g_free (comp_str);
- g_free (gdbus_comp);
-}
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_send_objects);
-static gboolean
-complete_send_objects (gboolean res,
- gchar **out_strv,
- GSList **users,
- icalcomponent **modified_icalcomp,
- GError **error)
-{
- g_return_val_if_fail (users != NULL, FALSE);
- g_return_val_if_fail (modified_icalcomp != NULL, FALSE);
-
- *users = NULL;
- *modified_icalcomp = NULL;
-
- if (res && out_strv) {
- gchar *calobj = NULL;
-
- if (e_gdbus_cal_decode_send_objects ((const gchar * const *) out_strv, &calobj, users)) {
- *modified_icalcomp = icalparser_parse_string (calobj);
- if (!*modified_icalcomp) {
- g_propagate_error (error, e_cal_client_error_create (E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
- e_client_util_free_string_slist (*users);
- *users = NULL;
- res = FALSE;
- }
- } else {
- g_propagate_error (error, e_client_error_create (E_CLIENT_ERROR_INVALID_ARG, NULL));
- e_client_util_free_string_slist (*users);
- *users = NULL;
- res = FALSE;
- }
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- g_free (calobj);
- } else {
- res = FALSE;
- }
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- g_strfreev (out_strv);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_send_objects_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- return res;
+ g_object_unref (simple);
}
/**
* e_cal_client_send_objects_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @users: (out) (element-type utf8): List of users to send
- * the @modified_icalcomp to
- * @modified_icalcomp: (out): Return value for the icalcomponent to be sent
+ * @out_users: (out) (element-type utf8): List of users to send
+ * the @out_modified_icalcomp to
+ * @out_modified_icalcomp: (out): Return value for the icalcomponent to be sent
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_send_objects() and
- * populates @users with a list of users to send @modified_icalcomp to.
- * The @users list should be freed with e_client_util_free_string_slist() and
- * the @modified_icalcomp should be freed with icalcomponent_free().
+ * populates @out_users with a list of users to send @out_modified_icalcomp to.
+ *
+ * The @out_users list should be freed with e_client_util_free_string_slist()
+ * and the @out_modified_icalcomp should be freed with icalcomponent_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
gboolean
e_cal_client_send_objects_finish (ECalClient *client,
GAsyncResult *result,
- GSList **users,
- icalcomponent **modified_icalcomp,
+ GSList **out_users,
+ icalcomponent **out_modified_icalcomp,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_send_objects), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ g_return_val_if_fail (async_context->out_comp != NULL, FALSE);
- g_return_val_if_fail (users != NULL, FALSE);
- g_return_val_if_fail (modified_icalcomp != NULL, FALSE);
+ if (out_users != NULL) {
+ *out_users = async_context->string_list;
+ async_context->string_list = NULL;
+ }
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strv, error, e_cal_client_send_objects);
+ if (out_modified_icalcomp != NULL) {
+ *out_modified_icalcomp = async_context->out_comp;
+ async_context->out_comp = NULL;
+ }
- return complete_send_objects (res, out_strv, users, modified_icalcomp, error);
+ return TRUE;
}
/**
* e_cal_client_send_objects_sync:
* @client: an #ECalClient
* @icalcomp: An icalcomponent to be sent
- * @users: (out) (element-type utf8): List of users to send
- * the @modified_icalcomp to
- * @modified_icalcomp: (out): Return value for the icalcomponent to be sent
+ * @out_users: (out) (element-type utf8): List of users to send the
+ * @out_modified_icalcomp to
+ * @out_modified_icalcomp: (out): Return value for the icalcomponent to be sent
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* Requests a calendar backend to send meeting information stored in @icalcomp.
- * The backend can modify this component and request a send to users in the @users list.
- * The @users list should be freed with e_client_util_free_string_slist() and
- * the @modified_icalcomp should be freed with icalcomponent_free().
+ * The backend can modify this component and request a send to users in the
+ * @out_users list.
+ *
+ * The @out_users list should be freed with e_client_util_free_string_slist()
+ * and the @out_modified_icalcomp should be freed with icalcomponent_free().
*
* Returns: %TRUE if successful, %FALSE otherwise.
*
**/
gboolean
e_cal_client_send_objects_sync (ECalClient *client,
- /* const */ icalcomponent *icalcomp,
- GSList **users,
- icalcomponent **modified_icalcomp,
+ icalcomponent *icalcomp,
+ GSList **out_users,
+ icalcomponent **out_modified_icalcomp,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL, *comp_str, *gdbus_comp = NULL;
+ gchar *ical_string;
+ gchar *utf8_ical_string;
+ gchar **users = NULL;
+ gchar *out_ical_string = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (icalcomp != NULL, FALSE);
- g_return_val_if_fail (users != NULL, FALSE);
- g_return_val_if_fail (modified_icalcomp != NULL, FALSE);
+ g_return_val_if_fail (out_users != NULL, FALSE);
+ g_return_val_if_fail (out_modified_icalcomp != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- comp_str = icalcomponent_as_ical_string_r (icalcomp);
+ ical_string = icalcomponent_as_ical_string_r (icalcomp);
+ utf8_ical_string = e_util_utf8_make_valid (ical_string);
+
+ success = e_dbus_calendar_call_send_objects_sync (
+ client->priv->dbus_proxy, utf8_ical_string,
+ &users, &out_ical_string, cancellable, error);
+
+ g_free (utf8_ical_string);
+ g_free (ical_string);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (out_ical_string != NULL)) ||
+ (!success && (out_ical_string == NULL)), FALSE);
+
+ if (!success) {
+ g_warn_if_fail (users == NULL);
+ return FALSE;
+ }
+
+ icalcomp = icalparser_parse_string (out_ical_string);
+
+ g_free (out_ical_string);
+
+ if (icalcomp != NULL) {
+ *out_modified_icalcomp = icalcomp;
+ } else {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ g_strfreev (users);
+ return FALSE;
+ }
+
+ if (users != NULL) {
+ GSList *tmp = NULL;
+ gint ii;
+
+ for (ii = 0; users[ii] != NULL; ii++) {
+ tmp = g_slist_prepend (tmp, users[ii]);
+ users[ii] = NULL;
+ }
+
+ *out_users = g_slist_reverse (tmp);
+ }
+
+ g_strfreev (users);
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_get_attachment_uris() */
+static void
+cal_client_get_attachment_uris_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- res = e_client_proxy_call_sync_string__strv (E_CLIENT (client), e_util_ensure_gdbus_string (comp_str, &gdbus_comp), &out_strv, cancellable, error, e_gdbus_cal_call_send_objects_sync);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- g_free (comp_str);
- g_free (gdbus_comp);
+ e_cal_client_get_attachment_uris_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->uid,
+ async_context->rid,
+ &async_context->string_list,
+ cancellable, &error);
- return complete_send_objects (res, out_strv, users, modified_icalcomp, error);
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_CAL_CLIENT (client));
g_return_if_fail (uid != NULL);
+ /* rid is optional */
- strv = e_gdbus_cal_encode_get_attachment_uris (uid, rid);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->uid = g_strdup (uid);
+ async_context->rid = g_strdup (rid);
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_get_attachment_uris,
- e_gdbus_cal_call_get_attachment_uris,
- NULL, NULL, NULL, e_gdbus_cal_call_get_attachment_uris_finish, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_attachment_uris);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_attachment_uris_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
* e_cal_client_get_attachment_uris_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @attachment_uris: (out) (element-type utf8): Return the list of attachment
- * URIs
+ * @out_attachment_uris: (out) (element-type utf8): Return location for the
+ * list of attachment URIs
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_attachment_uris() and
- * sets @attachment_uris to uris for component's attachments.
+ * sets @out_attachment_uris to uris for component's attachments.
* The list should be freed with e_client_util_free_string_slist().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_attachment_uris_finish (ECalClient *client,
GAsyncResult *result,
- GSList **attachment_uris,
+ GSList **out_attachment_uris,
GError **error)
{
- gboolean res;
- gchar **out_strv = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_attachment_uris), FALSE);
- g_return_val_if_fail (attachment_uris != NULL, FALSE);
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- res = e_client_proxy_call_finish_strv (E_CLIENT (client), result, &out_strv, error, e_cal_client_get_attachment_uris);
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
- if (res && out_strv) {
- *attachment_uris = e_client_util_strv_to_slist ((const gchar * const *) out_strv);
- } else {
- *attachment_uris = NULL;
+ if (out_attachment_uris != NULL) {
+ *out_attachment_uris = async_context->string_list;
+ async_context->string_list = NULL;
}
- g_strfreev (out_strv);
-
- return res;
+ return TRUE;
}
/**
* @client: an #ECalClient
* @uid: Unique identifier for a calendar component
* @rid: Recurrence identifier
- * @attachment_uris: (out) (element-type utf8): Return the list of attachment
- * URIs
+ * @out_attachment_uris: (out) (element-type utf8): Return location for the
+ * list of attachment URIs
* @cancellable: (allow-none): a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
e_cal_client_get_attachment_uris_sync (ECalClient *client,
const gchar *uid,
const gchar *rid,
- GSList **attachment_uris,
+ GSList **out_attachment_uris,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **strv, **out_strv = NULL;
+ gchar *utf8_uid;
+ gchar *utf8_rid;
+ gchar **uris = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
- g_return_val_if_fail (attachment_uris != NULL, FALSE);
+ g_return_val_if_fail (out_attachment_uris != NULL, FALSE);
+
+ if (rid == NULL)
+ rid = "";
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- strv = e_gdbus_cal_encode_get_attachment_uris (uid, rid);
+ utf8_uid = e_util_utf8_make_valid (uid);
+ utf8_rid = e_util_utf8_make_valid (rid);
- res = e_client_proxy_call_sync_strv__strv (E_CLIENT (client), (const gchar * const *) strv, &out_strv, cancellable, error, e_gdbus_cal_call_get_attachment_uris_sync);
+ success = e_dbus_calendar_call_get_attachment_uris_sync (
+ client->priv->dbus_proxy, utf8_uid,
+ utf8_rid, &uris, cancellable, error);
- g_strfreev (strv);
+ g_free (utf8_uid);
+ g_free (utf8_rid);
- if (res && out_strv) {
- *attachment_uris = e_client_util_strv_to_slist ((const gchar * const *) out_strv);
- } else {
- *attachment_uris = NULL;
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (uris != NULL)) ||
+ (!success && (uris == NULL)), FALSE);
+
+ if (uris != NULL) {
+ GSList *tmp;
+ gint ii;
+
+ for (ii = 0; uris[ii] != NULL; ii++) {
+ tmp = g_slist_prepend (tmp, uris[ii]);
+ uris[ii] = NULL;
+ }
+
+ *out_attachment_uris = g_slist_reverse (tmp);
}
- g_strfreev (out_strv);
+ return success;
+}
+
+/* Helper for e_cal_client_discard_alarm() */
+static void
+cal_client_discard_alarm_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- return res;
+ e_cal_client_discard_alarm_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->uid,
+ async_context->rid,
+ async_context->auid,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar **strv;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (uid != NULL);
+ /* rid is optional */
g_return_if_fail (auid != NULL);
- strv = e_gdbus_cal_encode_discard_alarm (uid, rid, auid);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->uid = g_strdup (uid);
+ async_context->rid = NULL;
+ async_context->auid = g_strdup (auid);
- e_client_proxy_call_strv (
- E_CLIENT (client), (const gchar * const *) strv, cancellable, callback, user_data, e_cal_client_discard_alarm,
- e_gdbus_cal_call_discard_alarm,
- e_gdbus_cal_call_discard_alarm_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_discard_alarm);
- g_strfreev (strv);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_discard_alarm_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_discard_alarm);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_discard_alarm), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar **strv;
+ gchar *utf8_uid;
+ gchar *utf8_rid;
+ gchar *utf8_auid;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (uid != NULL, FALSE);
g_return_val_if_fail (auid != NULL, FALSE);
+ if (rid == NULL)
+ rid = "";
+
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- strv = e_gdbus_cal_encode_discard_alarm (uid, rid, auid);
+ utf8_uid = e_util_utf8_make_valid (uid);
+ utf8_rid = e_util_utf8_make_valid (rid);
+ utf8_auid = e_util_utf8_make_valid (auid);
- res = e_client_proxy_call_sync_strv__void (E_CLIENT (client), (const gchar * const *) strv, cancellable, error, e_gdbus_cal_call_discard_alarm_sync);
+ success = e_dbus_calendar_call_discard_alarm_sync (
+ client->priv->dbus_proxy, utf8_uid,
+ utf8_rid, utf8_auid, cancellable, error);
- g_strfreev (strv);
+ g_free (utf8_uid);
+ g_free (utf8_rid);
+ g_free (utf8_auid);
- return res;
+ return success;
+}
+
+/* Helper for e_cal_client_get_view() */
+static void
+cal_client_get_view_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_get_view_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->sexp,
+ &async_context->client_view,
+ cancellable, &error);
+
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *gdbus_sexp = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (sexp != NULL);
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), cancellable, callback, user_data, e_cal_client_get_view,
- e_gdbus_cal_call_get_view,
- NULL, NULL, e_gdbus_cal_call_get_view_finish, NULL, NULL);
-
- g_free (gdbus_sexp);
-}
-
-static gboolean
-complete_get_view (ECalClient *client,
- gboolean res,
- gchar *view_path,
- ECalClientView **view,
- GError **error)
-{
- g_return_val_if_fail (view != NULL, FALSE);
-
- if (view_path && res && cal_factory) {
- GDBusConnection *connection;
- GError *local_error = NULL;
-
- connection = g_dbus_proxy_get_connection (
- G_DBUS_PROXY (cal_factory));
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->sexp = g_strdup (sexp);
- *view = g_initable_new (
- E_TYPE_CAL_CLIENT_VIEW,
- NULL, &local_error,
- "client", client,
- "connection", connection,
- "object-path", view_path,
- NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_view);
- if (local_error != NULL) {
- unwrap_dbus_error (local_error, error);
- res = FALSE;
- }
- } else {
- *view = NULL;
- res = FALSE;
- }
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- if (!*view && error && !*error)
- g_set_error_literal (error, E_CLIENT_ERROR, E_CLIENT_ERROR_DBUS_ERROR, _("Cannot get connection to view"));
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- g_free (view_path);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_view_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- return res;
+ g_object_unref (simple);
}
/**
* e_cal_client_get_view_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @view: (out) an #ECalClientView
+ * @out_view: (out) an #ECalClientView
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_view().
- * If successful, then the @view is set to newly allocated #ECalClientView,
+ * If successful, then the @out_view is set to newly allocated #ECalClientView,
* which should be freed with g_object_unref().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_view_finish (ECalClient *client,
GAsyncResult *result,
- ECalClientView **view,
+ ECalClientView **out_view,
GError **error)
{
- gboolean res;
- gchar *view_path = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_view), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
- g_return_val_if_fail (view != NULL, FALSE);
+ g_return_val_if_fail (async_context->client_view != NULL, FALSE);
- res = e_client_proxy_call_finish_string (E_CLIENT (client), result, &view_path, error, e_cal_client_get_view);
+ if (out_view != NULL)
+ *out_view = g_object_ref (async_context->client_view);
- return complete_get_view (client, res, view_path, view, error);
+ return TRUE;
}
/**
* e_cal_client_get_view_sync:
* @client: an #ECalClient
* @sexp: an S-expression representing the query.
- * @view: (out) an #ECalClientView
+ * @out_view: (out) an #ECalClientView
* @cancellable: a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
* Query @client with @sexp, creating an #ECalClientView.
- * If successful, then the @view is set to newly allocated #ECalClientView,
+ * If successful, then the @out_view is set to newly allocated #ECalClientView,
* which should be freed with g_object_unref().
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_view_sync (ECalClient *client,
const gchar *sexp,
- ECalClientView **view,
+ ECalClientView **out_view,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *gdbus_sexp = NULL;
- gchar *view_path = NULL;
+ gchar *utf8_sexp;
+ gchar *object_path = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (sexp != NULL, FALSE);
- g_return_val_if_fail (view != NULL, FALSE);
+ g_return_val_if_fail (out_view != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- res = e_client_proxy_call_sync_string__string (E_CLIENT (client), e_util_ensure_gdbus_string (sexp, &gdbus_sexp), &view_path, cancellable, error, e_gdbus_cal_call_get_view_sync);
+ utf8_sexp = e_util_utf8_make_valid (sexp);
- g_free (gdbus_sexp);
+ success = e_dbus_calendar_call_get_view_sync (
+ client->priv->dbus_proxy, utf8_sexp,
+ &object_path, cancellable, error);
- return complete_get_view (client, res, view_path, view, error);
-}
+ g_free (utf8_sexp);
-static gboolean
-cal_client_get_timezone_from_cache_finish (ECalClient *client,
- GAsyncResult *result,
- icaltimezone **zone,
- GError **error)
-{
- GSimpleAsyncResult *simple;
- GError *local_error = NULL;
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (object_path != NULL)) ||
+ (!success && (object_path == NULL)), FALSE);
- g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (zone != NULL, FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (client), e_timezone_cache_get_timezone), FALSE);
+ if (object_path != NULL) {
+ GDBusConnection *connection;
+ ECalClientView *client_view;
- simple = G_SIMPLE_ASYNC_RESULT (result);
+ connection = g_dbus_proxy_get_connection (
+ G_DBUS_PROXY (client->priv->dbus_proxy));
- if (g_simple_async_result_propagate_error (simple, &local_error)) {
- e_client_unwrap_dbus_error (E_CLIENT (client), local_error, error);
- return FALSE;
+ client_view = g_initable_new (
+ E_TYPE_CAL_CLIENT_VIEW,
+ cancellable, error,
+ "client", client,
+ "connection", connection,
+ "object-path", object_path,
+ NULL);
+
+ /* XXX Would have been easier to return the
+ * EBookClientView directly rather than
+ * through an "out" parameter. */
+ if (client_view != NULL)
+ *out_view = client_view;
+ else
+ success = FALSE;
+
+ g_free (object_path);
}
- *zone = g_simple_async_result_get_op_res_gpointer (simple);
+ return success;
+}
+
+/* Helper for e_cal_client_get_timezone() */
+static void
+cal_client_get_timezone_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
+
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ e_cal_client_get_timezone_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->tzid,
+ &async_context->zone,
+ cancellable, &error);
- return *zone != NULL;
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
GAsyncReadyCallback callback,
gpointer user_data)
{
- gchar *gdbus_tzid = NULL;
- icaltimezone *zone;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (tzid != NULL);
- zone = e_timezone_cache_get_timezone (
- E_TIMEZONE_CACHE (client), tzid);
- if (zone) {
- e_client_finish_async_without_dbus (E_CLIENT (client), cancellable, callback, user_data, e_timezone_cache_get_timezone, zone, NULL);
- } else {
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (tzid, &gdbus_tzid), cancellable, callback, user_data, e_cal_client_get_timezone,
- e_gdbus_cal_call_get_timezone,
- NULL, NULL, e_gdbus_cal_call_get_timezone_finish, NULL, NULL);
-
- g_free (gdbus_tzid);
- }
-}
-
-static gboolean
-complete_get_timezone (ECalClient *client,
- gboolean res,
- gchar *out_string,
- icaltimezone **zone,
- GError **error)
-{
- g_return_val_if_fail (zone != NULL, FALSE);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->tzid = g_strdup (tzid);
- *zone = NULL;
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_get_timezone);
- if (res && out_string) {
- icalcomponent *icalcomp;
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
- icalcomp = icalparser_parse_string (out_string);
- if (icalcomp) {
- *zone = icaltimezone_new ();
- if (!icaltimezone_set_component (*zone, icalcomp)) {
- icaltimezone_free (*zone, 1);
- icalcomponent_free (icalcomp);
- res = FALSE;
- g_propagate_error (error, e_cal_client_error_create (E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
- } else {
- const gchar *tzid;
-
- tzid = icaltimezone_get_tzid (*zone);
-
- /* Add the timezone to the cache directly,
- * otherwise we'd have to free this struct
- * and fetch the cached copy. */
- g_mutex_lock (&client->priv->zone_cache_lock);
- g_hash_table_insert (
- client->priv->zone_cache,
- g_strdup (tzid), *zone);
- g_mutex_unlock (&client->priv->zone_cache_lock);
- }
- } else {
- res = FALSE;
- g_propagate_error (error, e_cal_client_error_create (E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
- }
- } else {
- res = FALSE;
- }
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
- g_free (out_string);
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_get_timezone_thread,
+ G_PRIORITY_DEFAULT, cancellable);
- return res;
+ g_object_unref (simple);
}
/**
* e_cal_client_get_timezone_finish:
* @client: an #ECalClient
* @result: a #GAsyncResult
- * @zone: (out): Return value for the timezone
+ * @out_zone: (out): Return value for the timezone
* @error: (out): a #GError to set an error, if any
*
* Finishes previous call of e_cal_client_get_timezone() and
- * sets @zone to a retrieved timezone object from the calendar backend.
+ * sets @out_zone to a retrieved timezone object from the calendar backend.
* This object is owned by the @client, thus do not free it.
*
* Returns: %TRUE if successful, %FALSE otherwise.
gboolean
e_cal_client_get_timezone_finish (ECalClient *client,
GAsyncResult *result,
- icaltimezone **zone,
+ icaltimezone **out_zone,
GError **error)
{
- gboolean res;
- gchar *out_string = NULL;
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
- g_return_val_if_fail (zone != NULL, FALSE);
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_get_timezone), FALSE);
- if (g_simple_async_result_get_source_tag (G_SIMPLE_ASYNC_RESULT (result)) == e_timezone_cache_get_timezone) {
- res = cal_client_get_timezone_from_cache_finish (client, result, zone, error);
- } else {
- res = e_client_proxy_call_finish_string (E_CLIENT (client), result, &out_string, error, e_cal_client_get_timezone);
- res = complete_get_timezone (client, res, out_string, zone, error);
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
+
+ if (g_simple_async_result_propagate_error (simple, error))
+ return FALSE;
+
+ g_return_val_if_fail (async_context->zone != NULL, FALSE);
+
+ if (out_zone != NULL) {
+ *out_zone = async_context->zone;
+ async_context->zone = NULL;
}
- return res;
+ return TRUE;
}
/**
* e_cal_client_get_timezone_sync:
* @client: an #ECalClient
* @tzid: ID of the timezone to retrieve
- * @zone: (out): Return value for the timezone
+ * @out_zone: (out): Return value for the timezone
* @cancellable: a #GCancellable; can be %NULL
* @error: (out): a #GError to set an error, if any
*
gboolean
e_cal_client_get_timezone_sync (ECalClient *client,
const gchar *tzid,
- icaltimezone **zone,
+ icaltimezone **out_zone,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
- gchar *gdbus_tzid = NULL, *out_string = NULL;
+ icalcomponent *icalcomp;
+ icaltimezone *zone;
+ gchar *utf8_tzid;
+ gchar *string = NULL;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (tzid != NULL, FALSE);
- g_return_val_if_fail (zone != NULL, FALSE);
+ g_return_val_if_fail (out_zone != NULL, FALSE);
if (client->priv->dbus_proxy == NULL) {
set_proxy_gone_error (error);
return FALSE;
}
- *zone = e_timezone_cache_get_timezone (
+ zone = e_timezone_cache_get_timezone (
E_TIMEZONE_CACHE (client), tzid);
- if (*zone)
+ if (zone != NULL) {
+ *out_zone = zone;
return TRUE;
+ }
+
+ utf8_tzid = e_util_utf8_make_valid (tzid);
+
+ success = e_dbus_calendar_call_get_timezone_sync (
+ client->priv->dbus_proxy, utf8_tzid,
+ &string, cancellable, error);
+
+ g_free (utf8_tzid);
+
+ /* Sanity check. */
+ g_return_val_if_fail (
+ (success && (string != NULL)) ||
+ (!success && (string == NULL)), FALSE);
+
+ if (!success)
+ return FALSE;
+
+ icalcomp = icalparser_parse_string (string);
+
+ g_free (string);
+
+ if (icalcomp == NULL) {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ return FALSE;
+ }
+
+ zone = icaltimezone_new ();
+ if (!icaltimezone_set_component (zone, icalcomp)) {
+ g_propagate_error (
+ error, e_cal_client_error_create (
+ E_CAL_CLIENT_ERROR_INVALID_OBJECT, NULL));
+ icalcomponent_free (icalcomp);
+ icaltimezone_free (zone, 1);
+ return FALSE;
+ }
+
+ /* Add the timezone to the cache directly,
+ * otherwise we'd have to free this struct
+ * and fetch the cached copy. */
+ g_mutex_lock (&client->priv->zone_cache_lock);
+ g_hash_table_insert (
+ client->priv->zone_cache, g_strdup (tzid), zone);
+ g_mutex_unlock (&client->priv->zone_cache_lock);
+
+ *out_zone = zone;
+
+ return TRUE;
+}
+
+/* Helper for e_cal_client_add_timezone() */
+static void
+cal_client_add_timezone_thread (GSimpleAsyncResult *simple,
+ GObject *source_object,
+ GCancellable *cancellable)
+{
+ AsyncContext *async_context;
+ GError *error = NULL;
- res = e_client_proxy_call_sync_string__string (E_CLIENT (client), e_util_ensure_gdbus_string (tzid, &gdbus_tzid), &out_string, cancellable, error, e_gdbus_cal_call_get_timezone_sync);
+ async_context = g_simple_async_result_get_op_res_gpointer (simple);
- g_free (gdbus_tzid);
+ e_cal_client_add_timezone_sync (
+ E_CAL_CLIENT (source_object),
+ async_context->zone,
+ cancellable, &error);
- return complete_get_timezone (client, res, out_string, zone, error);
+ if (error != NULL)
+ g_simple_async_result_take_error (simple, error);
}
/**
**/
void
e_cal_client_add_timezone (ECalClient *client,
- /* const */ icaltimezone *zone,
+ icaltimezone *zone,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
+ GSimpleAsyncResult *simple;
+ AsyncContext *async_context;
icalcomponent *icalcomp;
- gchar *zone_str, *gdbus_zone = NULL;
+ g_return_if_fail (E_IS_CAL_CLIENT (client));
g_return_if_fail (zone != NULL);
- if (zone == icaltimezone_get_utc_timezone ())
- return;
-
icalcomp = icaltimezone_get_component (zone);
g_return_if_fail (icalcomp != NULL);
- zone_str = icalcomponent_as_ical_string_r (icalcomp);
+ async_context = g_slice_new0 (AsyncContext);
+ async_context->zone = icaltimezone_new ();
+
+ icalcomp = icalcomponent_new_clone (icalcomp);
+ icaltimezone_set_component (async_context->zone, icalcomp);
- e_client_proxy_call_string (
- E_CLIENT (client), e_util_ensure_gdbus_string (zone_str, &gdbus_zone), cancellable, callback, user_data, e_cal_client_add_timezone,
- e_gdbus_cal_call_add_timezone,
- e_gdbus_cal_call_add_timezone_finish, NULL, NULL, NULL, NULL);
+ simple = g_simple_async_result_new (
+ G_OBJECT (client), callback, user_data,
+ e_cal_client_add_timezone);
- g_free (zone_str);
- g_free (gdbus_zone);
+ g_simple_async_result_set_check_cancellable (simple, cancellable);
+
+ g_simple_async_result_set_op_res_gpointer (
+ simple, async_context, (GDestroyNotify) async_context_free);
+
+ if (zone == icaltimezone_get_utc_timezone ())
+ g_simple_async_result_complete_in_idle (simple);
+ else
+ g_simple_async_result_run_in_thread (
+ simple, cal_client_add_timezone_thread,
+ G_PRIORITY_DEFAULT, cancellable);
+
+ g_object_unref (simple);
}
/**
GAsyncResult *result,
GError **error)
{
- return e_client_proxy_call_finish_void (E_CLIENT (client), result, error, e_cal_client_add_timezone);
+ GSimpleAsyncResult *simple;
+
+ g_return_val_if_fail (
+ g_simple_async_result_is_valid (
+ result, G_OBJECT (client),
+ e_cal_client_add_timezone), FALSE);
+
+ simple = G_SIMPLE_ASYNC_RESULT (result);
+
+ /* Assume success unless a GError is set. */
+ return !g_simple_async_result_propagate_error (simple, error);
}
/**
**/
gboolean
e_cal_client_add_timezone_sync (ECalClient *client,
- /* const */ icaltimezone *zone,
+ icaltimezone *zone,
GCancellable *cancellable,
GError **error)
{
- gboolean res;
icalcomponent *icalcomp;
- gchar *zone_str, *gdbus_zone = NULL;
+ gchar *zone_str;
+ gchar *utf8_zone_str;
+ gboolean success;
g_return_val_if_fail (E_IS_CAL_CLIENT (client), FALSE);
g_return_val_if_fail (zone != NULL, FALSE);
return TRUE;
icalcomp = icaltimezone_get_component (zone);
- if (!icalcomp) {
- g_propagate_error (error, e_client_error_create (E_CLIENT_ERROR_INVALID_ARG, NULL));
+ if (icalcomp == NULL) {
+ g_propagate_error (
+ error, e_client_error_create (
+ E_CLIENT_ERROR_INVALID_ARG, NULL));
return FALSE;
}
}
zone_str = icalcomponent_as_ical_string_r (icalcomp);
+ utf8_zone_str = e_util_utf8_make_valid (zone_str);
- res = e_client_proxy_call_sync_string__void (E_CLIENT (client), e_util_ensure_gdbus_string (zone_str, &gdbus_zone), cancellable, error, e_gdbus_cal_call_add_timezone_sync);
+ success = e_dbus_calendar_call_add_timezone_sync (
+ client->priv->dbus_proxy, utf8_zone_str, cancellable, error);
g_free (zone_str);
- g_free (gdbus_zone);
+ g_free (utf8_zone_str);
- return res;
+ return success;
}
#include <glib/gi18n-lib.h>
#include <unistd.h>
+/* Private D-Bus classes. */
+#include <e-dbus-calendar.h>
+
#include <libedataserver/libedataserver.h>
#include "e-data-cal.h"
-#include "e-gdbus-cal.h"
#include "e-cal-backend.h"
#include "e-cal-backend-sexp.h"
struct _EDataCalPrivate {
GDBusConnection *connection;
- EGdbusCal *dbus_interface;
+ EDBusCalendar *dbus_interface;
ECalBackend *backend;
gchar *object_path;
guint watcher_id;
union {
- /* OP_OPEN */
- gboolean only_if_exists;
/* OP_GET_OBJECT */
/* OP_GET_ATTACHMENT_URIS */
struct _ur {
/* OP_ADD_TIMEZONE */
gchar *tzobject;
/* OP_GET_BACKEND_PROPERTY */
- gchar *prop_name;
+ const gchar *prop_name;
/* OP_REFRESH */
/* OP_CLOSE */
data->cal = g_object_ref (cal);
data->cancellable = g_cancellable_new ();
+ /* This is optional so we can fake client requests. */
if (invocation != NULL) {
GDBusConnection *connection;
const gchar *sender;
case OP_ADD_TIMEZONE:
g_free (data->d.tzobject);
break;
- case OP_GET_BACKEND_PROPERTY:
- g_free (data->d.prop_name);
- break;
default:
break;
}
g_mutex_unlock (&cal->priv->open_lock);
}
+static OperationData *
+op_claim (EDataCal *cal,
+ guint32 opid)
+{
+ OperationData *data;
+
+ g_return_val_if_fail (E_IS_DATA_CAL (cal), NULL);
+
+ e_operation_pool_release_opid (ops_pool, opid);
+
+ g_rec_mutex_lock (&cal->priv->pending_ops_lock);
+ data = g_hash_table_lookup (
+ cal->priv->pending_ops,
+ GUINT_TO_POINTER (opid));
+ if (data != NULL) {
+ /* Steal the hash table's reference. */
+ g_hash_table_steal (
+ cal->priv->pending_ops,
+ GUINT_TO_POINTER (opid));
+ }
+ g_rec_mutex_unlock (&cal->priv->pending_ops_lock);
+
+ return data;
+}
+
static void
op_complete (EDataCal *cal,
guint32 opid)
{
- g_return_if_fail (cal != NULL);
+ g_return_if_fail (E_IS_DATA_CAL (cal));
e_operation_pool_release_opid (ops_pool, opid);
}
static void
+data_cal_convert_to_client_error (GError *error)
+{
+ g_return_if_fail (error != NULL);
+
+ if (error->domain != E_DATA_CAL_ERROR)
+ return;
+
+ switch (error->code) {
+ case RepositoryOffline:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_REPOSITORY_OFFLINE;
+ break;
+
+ case PermissionDenied:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_PERMISSION_DENIED;
+ break;
+
+ case InvalidRange:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_INVALID_RANGE;
+ break;
+
+ case ObjectNotFound:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_OBJECT_NOT_FOUND;
+ break;
+
+ case InvalidObject:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_INVALID_OBJECT;
+ break;
+
+ case ObjectIdAlreadyExists:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_OBJECT_ID_ALREADY_EXISTS;
+ break;
+
+ case AuthenticationFailed:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_AUTHENTICATION_FAILED;
+ break;
+
+ case AuthenticationRequired:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_AUTHENTICATION_REQUIRED;
+ break;
+
+ case UnsupportedAuthenticationMethod:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_UNSUPPORTED_AUTHENTICATION_METHOD;
+ break;
+
+ case TLSNotAvailable:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_TLS_NOT_AVAILABLE;
+ break;
+
+ case NoSuchCal:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR;
+ break;
+
+ case UnknownUser:
+ error->domain = E_CAL_CLIENT_ERROR;
+ error->code = E_CAL_CLIENT_ERROR_UNKNOWN_USER;
+ break;
+
+ case OfflineUnavailable:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_OFFLINE_UNAVAILABLE;
+ break;
+
+ case SearchSizeLimitExceeded:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_SEARCH_SIZE_LIMIT_EXCEEDED;
+ break;
+
+ case SearchTimeLimitExceeded:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_SEARCH_TIME_LIMIT_EXCEEDED;
+ break;
+
+ case InvalidQuery:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_INVALID_QUERY;
+ break;
+
+ case QueryRefused:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_QUERY_REFUSED;
+ break;
+
+ case CouldNotCancel:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_COULD_NOT_CANCEL;
+ break;
+
+ case InvalidArg:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_INVALID_ARG;
+ break;
+
+ case NotSupported:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_NOT_SUPPORTED;
+ break;
+
+ case NotOpened:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_NOT_OPENED;
+ break;
+
+ case UnsupportedField:
+ case UnsupportedMethod:
+ case OtherError:
+ case InvalidServerVersion:
+ error->domain = E_CLIENT_ERROR;
+ error->code = E_CLIENT_ERROR_OTHER_ERROR;
+ break;
+
+ default:
+ g_warn_if_reached ();
+ }
+}
+
+static void
operation_thread (gpointer data,
gpointer user_data)
{
OperationData *op = data;
- OperationData *cancel_op;
ECalBackend *backend;
GHashTableIter iter;
gpointer value;
case OP_OPEN:
e_cal_backend_open (
backend, op->cal, op->id,
- op->cancellable, op->d.only_if_exists);
+ op->cancellable, FALSE);
break;
case OP_REFRESH:
obj_sexp = e_cal_backend_sexp_new (op->d.sexp);
if (!obj_sexp) {
- g_free (op->d.sexp);
- e_data_cal_respond_get_view (op->cal, op->id, EDC_ERROR (InvalidQuery), NULL);
+ g_dbus_method_invocation_return_error_literal (
+ op->invocation,
+ E_CLIENT_ERROR,
+ E_CLIENT_ERROR_INVALID_QUERY,
+ _("Invalid query"));
+
+ op_complete (op->cal, op->id);
break;
}
((view == NULL) && (error != NULL)));
if (error != NULL) {
- g_free (op->d.sexp);
- e_data_cal_respond_get_view (op->cal, op->id, EDC_ERROR_EX (OtherError, error->message), NULL);
- g_error_free (error);
+ /* Translators: This is a prefix to a detailed error message *
+ */
+ g_prefix_error (&error, "%s", _("Invalid query: "));
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ op->invocation, error);
+
+ op_complete (op->cal, op->id);
g_free (object_path);
break;
}
e_cal_backend_add_view (backend, view);
- e_data_cal_respond_get_view (op->cal, op->id, EDC_ERROR (Success), object_path);
+ e_dbus_calendar_complete_get_view (
+ op->cal->priv->dbus_interface,
+ op->invocation,
+ object_path);
+ op_complete (op->cal, op->id);
g_free (object_path);
}
break;
g_hash_table_iter_init (&iter, op->cal->priv->pending_ops);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
- cancel_op = (OperationData *) value;
+ OperationData *cancel_op = value;
g_cancellable_cancel (cancel_op->cancellable);
}
g_rec_mutex_unlock (&op->cal->priv->pending_ops_lock);
+
+ e_dbus_calendar_complete_close (
+ op->cal->priv->dbus_interface,
+ op->invocation);
+
+ op_complete (op->cal, op->id);
break;
}
}
static gboolean
-data_cal_handle_open_cb (EGdbusCal *interface,
+data_cal_handle_open_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- gboolean in_only_if_exists,
EDataCal *cal)
{
OperationData *op;
op = op_new (OP_OPEN, cal, invocation);
- op->d.only_if_exists = in_only_if_exists;
-
- e_gdbus_cal_complete_open (interface, invocation, op->id);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_refresh_cb (EGdbusCal *interface,
+data_cal_handle_refresh_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
EDataCal *cal)
{
op = op_new (OP_REFRESH, cal, invocation);
- e_gdbus_cal_complete_refresh (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_get_backend_property_cb (EGdbusCal *interface,
- GDBusMethodInvocation *invocation,
- const gchar *in_prop_name,
- EDataCal *cal)
-{
- OperationData *op;
-
- op = op_new (OP_GET_BACKEND_PROPERTY, cal, invocation);
- op->d.prop_name = g_strdup (in_prop_name);
-
- e_gdbus_cal_complete_get_backend_property (interface, invocation, op->id);
-
- /* This operation is never queued. */
- e_operation_pool_push (ops_pool, op);
-
- return TRUE;
-}
-
-static gboolean
-data_cal_handle_get_object_cb (EGdbusCal *interface,
+data_cal_handle_get_object_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_uid_rid,
+ const gchar *in_uid,
+ const gchar *in_rid,
EDataCal *cal)
{
OperationData *op;
- op = op_new (OP_GET_OBJECT, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_get_object (in_uid_rid, &op->d.ur.uid, &op->d.ur.rid), FALSE);
+ /* Recurrence ID is optional. Its omission is denoted
+ * via D-Bus by an emptry string. Convert it to NULL. */
+ if (in_rid != NULL && *in_rid == '\0')
+ in_rid = NULL;
- e_gdbus_cal_complete_get_object (interface, invocation, op->id);
+ op = op_new (OP_GET_OBJECT, cal, invocation);
+ op->d.ur.uid = g_strdup (in_uid);
+ op->d.ur.rid = g_strdup (in_rid);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_get_object_list_cb (EGdbusCal *interface,
+data_cal_handle_get_object_list_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_sexp,
EDataCal *cal)
op = op_new (OP_GET_OBJECT_LIST, cal, invocation);
op->d.sexp = g_strdup (in_sexp);
- e_gdbus_cal_complete_get_object_list (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_get_free_busy_cb (EGdbusCal *interface,
+data_cal_handle_get_free_busy_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_start_end_userlist,
+ gint64 in_start,
+ gint64 in_end,
+ const gchar **in_users,
EDataCal *cal)
{
OperationData *op;
- guint start, end;
+ GSList *tmp = NULL;
+ gint ii;
- op = op_new (OP_GET_FREE_BUSY, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_get_free_busy (in_start_end_userlist, &start, &end, &op->d.fb.users), FALSE);
-
- op->d.fb.start = (time_t) start;
- op->d.fb.end = (time_t) end;
+ for (ii = 0; in_users[ii] != NULL; ii++)
+ tmp = g_slist_prepend (tmp, g_strdup (in_users[ii]));
- e_gdbus_cal_complete_get_free_busy (interface, invocation, op->id);
+ op = op_new (OP_GET_FREE_BUSY, cal, invocation);
+ op->d.fb.start = (time_t) in_start;
+ op->d.fb.end = (time_t) in_end;
+ op->d.fb.users = g_slist_reverse (tmp);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_create_objects_cb (EGdbusCal *interface,
+data_cal_handle_create_objects_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_calobjs,
+ const gchar **in_calobjs,
EDataCal *cal)
{
OperationData *op;
+ GSList *tmp = NULL;
+ gint ii;
- op = op_new (OP_CREATE_OBJECTS, cal, invocation);
- op->d.calobjs = e_util_strv_to_slist (in_calobjs);
+ for (ii = 0; in_calobjs[ii] != NULL; ii++)
+ tmp = g_slist_prepend (tmp, g_strdup (in_calobjs[ii]));
- e_gdbus_cal_complete_create_objects (interface, invocation, op->id);
+ op = op_new (OP_CREATE_OBJECTS, cal, invocation);
+ op->d.calobjs = g_slist_reverse (tmp);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_modify_objects_cb (EGdbusCal *interface,
+data_cal_handle_modify_objects_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_mod_calobjs,
+ const gchar **in_ics_objects,
+ const gchar *in_mod_type,
EDataCal *cal)
{
+ GEnumClass *enum_class;
+ GEnumValue *enum_value;
OperationData *op;
- guint mod;
+ GSList *tmp = NULL;
+ gint ii;
- op = op_new (OP_MODIFY_OBJECTS, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_modify_objects (in_mod_calobjs, &op->d.mo.calobjs, &mod), FALSE);
- op->d.mo.mod = mod;
+ enum_class = g_type_class_ref (E_TYPE_CAL_OBJ_MOD_TYPE);
+ enum_value = g_enum_get_value_by_nick (enum_class, in_mod_type);
+ g_return_val_if_fail (enum_value != NULL, FALSE);
- e_gdbus_cal_complete_modify_objects (interface, invocation, op->id);
+ for (ii = 0; in_ics_objects[ii] != NULL; ii++)
+ tmp = g_slist_prepend (tmp, g_strdup (in_ics_objects[ii]));
+
+ op = op_new (OP_MODIFY_OBJECTS, cal, invocation);
+ op->d.mo.calobjs = g_slist_reverse (tmp);
+ op->d.mo.mod = enum_value->value;
op_dispatch (cal, op);
+ g_type_class_unref (enum_class);
+
return TRUE;
}
static gboolean
-data_cal_handle_remove_objects_cb (EGdbusCal *interface,
+data_cal_handle_remove_objects_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_mod_ids,
+ GVariant *in_uid_rid_array,
+ const gchar *in_mod_type,
EDataCal *cal)
{
+ GEnumClass *enum_class;
+ GEnumValue *enum_value;
OperationData *op;
- guint mod = 0;
+ GSList *tmp = NULL;
+ gsize n_children, ii;
- op = op_new (OP_REMOVE_OBJECTS, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_remove_objects (in_mod_ids, &op->d.ro.ids, &mod), FALSE);
- op->d.ro.mod = mod;
+ enum_class = g_type_class_ref (E_TYPE_CAL_OBJ_MOD_TYPE);
+ enum_value = g_enum_get_value_by_nick (enum_class, in_mod_type);
+ g_return_val_if_fail (enum_value != NULL, FALSE);
+
+ n_children = g_variant_n_children (in_uid_rid_array);
+ for (ii = 0; ii < n_children; ii++) {
+ ECalComponentId *id;
+
+ /* e_cal_component_free_id() uses g_free(),
+ * not g_slice_free(). Therefore allocate
+ * with g_malloc(), not g_slice_new(). */
+ id = g_malloc (sizeof (ECalComponentId));
+
+ g_variant_get_child (
+ in_uid_rid_array, ii, "ss", &id->uid, &id->rid);
+
+ if (id->uid != NULL && *id->uid == '\0') {
+ e_cal_component_free_id (id);
+ continue;
+ }
- e_gdbus_cal_complete_remove_objects (interface, invocation, op->id);
+ /* Recurrence ID is optional. Its omission is denoted
+ * via D-Bus by an empty string. Convert it to NULL. */
+ if (id->rid != NULL && *id->rid == '\0') {
+ g_free (id->rid);
+ id->rid = NULL;
+ }
+
+ tmp = g_slist_prepend (tmp, id);
+ }
+
+ op = op_new (OP_REMOVE_OBJECTS, cal, invocation);
+ op->d.ro.ids = g_slist_reverse (tmp);
+ op->d.ro.mod = enum_value->value;
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_receive_objects_cb (EGdbusCal *interface,
+data_cal_handle_receive_objects_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_calobj,
EDataCal *cal)
op = op_new (OP_RECEIVE_OBJECTS, cal, invocation);
op->d.co.calobj = g_strdup (in_calobj);
- e_gdbus_cal_complete_receive_objects (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_send_objects_cb (EGdbusCal *interface,
+data_cal_handle_send_objects_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_calobj,
EDataCal *cal)
op = op_new (OP_SEND_OBJECTS, cal, invocation);
op->d.co.calobj = g_strdup (in_calobj);
- e_gdbus_cal_complete_send_objects (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_get_attachment_uris_cb (EGdbusCal *interface,
+data_cal_handle_get_attachment_uris_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_uid_rid,
+ const gchar *in_uid,
+ const gchar *in_rid,
EDataCal *cal)
{
OperationData *op;
- op = op_new (OP_GET_ATTACHMENT_URIS, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_get_attachment_uris (in_uid_rid, &op->d.ur.uid, &op->d.ur.rid), FALSE);
+ /* Recurrence ID is optional. Its omission is denoted
+ * via D-Bus by an empty string. Convert it to NULL. */
+ if (in_rid != NULL && *in_rid == '\0')
+ in_rid = NULL;
- e_gdbus_cal_complete_get_attachment_uris (interface, invocation, op->id);
+ op = op_new (OP_GET_ATTACHMENT_URIS, cal, invocation);
+ op->d.ur.uid = g_strdup (in_uid);
+ op->d.ur.rid = g_strdup (in_rid);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_discard_alarm_cb (EGdbusCal *interface,
+data_cal_handle_discard_alarm_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
- const gchar * const *in_uid_rid_auid,
+ const gchar *in_uid,
+ const gchar *in_rid,
+ const gchar *in_alarm_uid,
EDataCal *cal)
{
OperationData *op;
- op = op_new (OP_DISCARD_ALARM, cal, invocation);
- g_return_val_if_fail (e_gdbus_cal_decode_discard_alarm (in_uid_rid_auid, &op->d.ura.uid, &op->d.ura.rid, &op->d.ura.auid), FALSE);
+ /* Recurrence ID is optional. Its omission is denoted
+ * via D-Bus by an empty string. Convert it to NULL. */
+ if (in_rid != NULL && *in_rid == '\0')
+ in_rid = NULL;
- e_gdbus_cal_complete_discard_alarm (interface, invocation, op->id);
+ op = op_new (OP_DISCARD_ALARM, cal, invocation);
+ op->d.ura.uid = g_strdup (in_uid);
+ op->d.ura.rid = g_strdup (in_rid);
+ op->d.ura.auid = g_strdup (in_alarm_uid);
op_dispatch (cal, op);
}
static gboolean
-data_cal_handle_get_view_cb (EGdbusCal *interface,
+data_cal_handle_get_view_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_sexp,
EDataCal *cal)
op = op_new (OP_GET_VIEW, cal, invocation);
op->d.sexp = g_strdup (in_sexp);
- e_gdbus_cal_complete_get_view (interface, invocation, op->id);
-
/* This operation is never queued. */
e_operation_pool_push (ops_pool, op);
}
static gboolean
-data_cal_handle_get_timezone_cb (EGdbusCal *interface,
+data_cal_handle_get_timezone_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_tzid,
EDataCal *cal)
op = op_new (OP_GET_TIMEZONE, cal, invocation);
op->d.tzid = g_strdup (in_tzid);
- e_gdbus_cal_complete_get_timezone (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_add_timezone_cb (EGdbusCal *interface,
+data_cal_handle_add_timezone_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
const gchar *in_tzobject,
EDataCal *cal)
op = op_new (OP_ADD_TIMEZONE, cal, invocation);
op->d.tzobject = g_strdup (in_tzobject);
- e_gdbus_cal_complete_add_timezone (interface, invocation, op->id);
-
op_dispatch (cal, op);
return TRUE;
}
static gboolean
-data_cal_handle_close_cb (EGdbusCal *interface,
+data_cal_handle_close_cb (EDBusCalendar *interface,
GDBusMethodInvocation *invocation,
EDataCal *cal)
{
/* unref here makes sure the cal is freed in a separate thread */
g_object_unref (cal);
- e_gdbus_cal_complete_close (interface, invocation, NULL);
-
/* This operation is never queued. */
e_operation_pool_push (ops_pool, op);
return TRUE;
}
-/* free returned pointer with g_strfreev() */
-static gchar **
-gslist_to_strv (const GSList *lst)
-{
- gchar **seq;
- const GSList *l;
- gint i;
-
- seq = g_new0 (gchar *, g_slist_length ((GSList *) lst) + 1);
- for (l = lst, i = 0; l; l = l->next, i++) {
- seq[i] = e_util_utf8_make_valid (l->data);
- }
-
- return seq;
-}
-
/**
* e_data_cal_respond_open:
* @cal: A calendar client interface.
guint32 opid,
GError *error)
{
+ OperationData *data;
GError *copy = NULL;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot open calendar: "));
copy = g_error_copy (error);
e_cal_backend_notify_opened (cal->priv->backend, copy);
- e_gdbus_cal_emit_open_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_open (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error != NULL)
- g_error_free (error);
+ op_unref (data);
/* Dispatch any pending operations. */
guint32 opid,
GError *error)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot refresh calendar: "));
- e_gdbus_cal_emit_refresh_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_refresh (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error)
- g_error_free (error);
+ op_unref (data);
}
/**
GError *error,
const gchar *prop_value)
{
- gchar *gdbus_prop_value = NULL;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot retrieve backend property: "));
- e_gdbus_cal_emit_get_backend_property_done (cal->priv->dbus_interface, opid, error, e_util_ensure_gdbus_string (prop_value, &gdbus_prop_value));
-
- g_free (gdbus_prop_value);
- if (error)
+ if (error == NULL) {
+ e_data_cal_report_backend_property_changed (
+ cal, data->d.prop_name, prop_value);
+ } else {
+ /* This should never happen, since all backend property
+ * requests now originate from our constructed() method. */
+ g_warning ("%s: %s", G_STRFUNC, error->message);
g_error_free (error);
+ }
+
+ op_unref (data);
}
/**
GError *error,
const gchar *object)
{
- gchar *gdbus_object = NULL;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot retrieve calendar object path: "));
- e_gdbus_cal_emit_get_object_done (cal->priv->dbus_interface, opid, error, e_util_ensure_gdbus_string (object, &gdbus_object));
+ if (error == NULL) {
+ gchar *utf8_object;
- g_free (gdbus_object);
- if (error)
- g_error_free (error);
+ utf8_object = e_util_utf8_make_valid (object);
+
+ e_dbus_calendar_complete_get_object (
+ cal->priv->dbus_interface,
+ data->invocation,
+ utf8_object);
+
+ g_free (utf8_object);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
+
+ op_unref (data);
}
/**
GError *error,
const GSList *objects)
{
- gchar **strv_objects;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot retrieve calendar object list: "));
- strv_objects = gslist_to_strv (objects);
+ if (error == NULL) {
+ gchar **strv;
+ guint length;
+ gint ii = 0;
- e_gdbus_cal_emit_get_object_list_done (cal->priv->dbus_interface, opid, error, (const gchar * const *) strv_objects);
+ length = g_slist_length ((GSList *) objects);
+ strv = g_new0 (gchar *, length + 1);
- g_strfreev (strv_objects);
- if (error)
- g_error_free (error);
+ while (objects != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (objects->data);
+ objects = g_slist_next (objects);
+ }
+
+ g_strfreev (strv);
+ }
+
+ op_unref (data);
}
/**
guint32 opid,
GError *error)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot retrieve calendar free/busy list: "));
- e_gdbus_cal_emit_get_free_busy_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_get_free_busy (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error)
- g_error_free (error);
+ op_unref (data);
}
/**
guint32 opid,
GError *error,
const GSList *uids,
- /* const */ GSList *new_components)
+ GSList *new_components)
{
- gchar **array = NULL;
- const GSList *l;
- gint i = 0;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
-
- array = g_new0 (gchar *, g_slist_length ((GSList *) uids) + 1);
- for (l = uids; l != NULL; l = l->next) {
- array[i++] = e_util_utf8_make_valid (l->data);
- }
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot create calendar object: "));
- e_gdbus_cal_emit_create_objects_done (cal->priv->dbus_interface, opid, error, (const gchar * const *) array);
+ if (error == NULL) {
+ ECalBackend *backend;
+ gchar **strv;
+ guint length;
+ gint ii = 0;
- g_strfreev (array);
- if (error)
- g_error_free (error);
- else {
- for (l = new_components; l; l = l->next) {
- e_cal_backend_notify_component_created (cal->priv->backend, l->data);
+ backend = e_data_cal_get_backend (cal);
+
+ length = g_slist_length ((GSList *) uids);
+ strv = g_new0 (gchar *, length + 1);
+
+ while (uids != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (uids->data);
+ uids = g_slist_next ((GSList *) uids);
+ }
+
+ e_dbus_calendar_complete_create_objects (
+ cal->priv->dbus_interface,
+ data->invocation,
+ (const gchar * const *) strv);
+
+ g_strfreev (strv);
+
+ while (new_components != NULL) {
+ ECalComponent *component;
+
+ component = E_CAL_COMPONENT (new_components->data);
+ e_cal_backend_notify_component_created (
+ backend, component);
+
+ new_components = g_slist_next (new_components);
}
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
}
+
+ op_unref (data);
}
/**
e_data_cal_respond_modify_objects (EDataCal *cal,
guint32 opid,
GError *error,
- /* const */ GSList *old_components,
- /* const */ GSList *new_components)
+ GSList *old_components,
+ GSList *new_components)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot modify calendar object: "));
- e_gdbus_cal_emit_modify_objects_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ ECalBackend *backend;
- if (error)
- g_error_free (error);
- else {
- const GSList *lold = old_components, *lnew = new_components;
- while (lold && lnew) {
- e_cal_backend_notify_component_modified (cal->priv->backend, lold->data, lnew->data);
- lold = lold->next;
- lnew = lnew->next;
+ backend = e_data_cal_get_backend (cal);
+
+ e_dbus_calendar_complete_modify_objects (
+ cal->priv->dbus_interface,
+ data->invocation);
+
+ while (old_components != NULL && new_components != NULL) {
+ ECalComponent *old_component;
+ ECalComponent *new_component;
+
+ old_component = E_CAL_COMPONENT (old_components->data);
+ new_component = E_CAL_COMPONENT (new_components->data);
+
+ e_cal_backend_notify_component_modified (
+ backend, old_component, new_component);
+
+ old_components = g_slist_next (old_components);
+ new_components = g_slist_next (new_components);
}
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
}
+
+ op_unref (data);
}
/**
guint32 opid,
GError *error,
const GSList *ids,
- /* const */ GSList *old_components,
- /* const */ GSList *new_components)
+ GSList *old_components,
+ GSList *new_components)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot remove calendar object: "));
- e_gdbus_cal_emit_remove_objects_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ ECalBackend *backend;
- if (error)
- g_error_free (error);
- else {
- const GSList *lid = ids, *lold = old_components, *lnew = new_components;
- while (lid && lold) {
- e_cal_backend_notify_component_removed (cal->priv->backend, lid->data, lold->data, lnew ? lnew->data : NULL);
+ backend = e_data_cal_get_backend (cal);
+
+ e_dbus_calendar_complete_remove_objects (
+ cal->priv->dbus_interface,
+ data->invocation);
- lid = lid->next;
- lold = lold->next;
+ while (ids != NULL && old_components != NULL) {
+ ECalComponentId *id;
+ ECalComponent *old_component;
+ ECalComponent *new_component = NULL;
- if (lnew)
- lnew = lnew->next;
+ id = ids->data;
+ old_component = E_CAL_COMPONENT (old_components->data);
+ new_component = (new_components != NULL) ?
+ E_CAL_COMPONENT (new_components->data) : NULL;
+
+ e_cal_backend_notify_component_removed (
+ backend, id, old_component, new_component);
+
+ ids = g_slist_next ((GSList *) ids);
+ old_components = g_slist_next (old_components);
+
+ if (new_components != NULL)
+ new_components = g_slist_next (new_components);
}
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
}
+
+ op_unref (data);
}
/**
guint32 opid,
GError *error)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot receive calendar objects: "));
- e_gdbus_cal_emit_receive_objects_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_receive_objects (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error)
- g_error_free (error);
+ op_unref (data);
}
/**
const GSList *users,
const gchar *calobj)
{
- gchar **strv_users_calobj;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Cannot send calendar objects: "));
- strv_users_calobj = e_gdbus_cal_encode_send_objects (calobj, users);
+ if (error == NULL) {
+ gchar *utf8_calobj;
+ gchar **strv;
+ guint length;
+ gint ii = 0;
- e_gdbus_cal_emit_send_objects_done (cal->priv->dbus_interface, opid, error, (const gchar * const *) strv_users_calobj);
+ length = g_slist_length ((GSList *) users);
+ strv = g_new0 (gchar *, length + 1);
- g_strfreev (strv_users_calobj);
- if (error)
- g_error_free (error);
+ while (users != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (users->data);
+ users = g_slist_next ((GSList *) users);
+ }
+
+ utf8_calobj = e_util_utf8_make_valid (calobj);
+
+ e_dbus_calendar_complete_send_objects (
+ cal->priv->dbus_interface,
+ data->invocation,
+ (const gchar *const *) strv,
+ utf8_calobj);
+
+ g_free (utf8_calobj);
+
+ g_strfreev (strv);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
+
+ op_unref (data);
}
/**
GError *error,
const GSList *attachment_uris)
{
- gchar **strv_attachment_uris;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Could not retrieve attachment uris: "));
- strv_attachment_uris = gslist_to_strv (attachment_uris);
+ if (error != NULL) {
+ gchar **strv;
+ guint length;
+ gint ii = 0;
- e_gdbus_cal_emit_get_attachment_uris_done (cal->priv->dbus_interface, opid, error, (const gchar * const *) strv_attachment_uris);
+ length = g_slist_length ((GSList *) attachment_uris);
+ strv = g_new0 (gchar *, length + 1);
- g_strfreev (strv_attachment_uris);
- if (error)
- g_error_free (error);
+ while (attachment_uris != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (attachment_uris->data);
+ attachment_uris = g_slist_next ((GSList *) attachment_uris);
+ }
+
+ e_dbus_calendar_complete_get_attachment_uris (
+ cal->priv->dbus_interface,
+ data->invocation,
+ (const gchar * const *) strv);
+
+ g_strfreev (strv);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
}
/**
guint32 opid,
GError *error)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Could not discard reminder: "));
- e_gdbus_cal_emit_discard_alarm_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_discard_alarm (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error)
- g_error_free (error);
+ op_unref (data);
}
/**
GError *error,
const gchar *view_path)
{
- gchar *gdbus_view_path = NULL;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Could not get calendar view path: "));
- e_gdbus_cal_emit_get_view_done (cal->priv->dbus_interface, opid, error, e_util_ensure_gdbus_string (view_path, &gdbus_view_path));
+ if (error == NULL) {
+ gchar *utf8_view_path;
- g_free (gdbus_view_path);
- if (error)
- g_error_free (error);
+ utf8_view_path = e_util_utf8_make_valid (view_path);
+
+ e_dbus_calendar_complete_get_view (
+ cal->priv->dbus_interface,
+ data->invocation,
+ utf8_view_path);
+
+ g_free (utf8_view_path);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
+
+ op_unref (data);
}
/**
GError *error,
const gchar *tzobject)
{
- gchar *gdbus_tzobject = NULL;
+ OperationData *data;
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Could not retrieve calendar time zone: "));
- e_gdbus_cal_emit_get_timezone_done (cal->priv->dbus_interface, opid, error, e_util_ensure_gdbus_string (tzobject, &gdbus_tzobject));
+ if (error == NULL) {
+ gchar *utf8_tz_object;
- g_free (gdbus_tzobject);
- if (error)
- g_error_free (error);
+ utf8_tz_object = e_util_utf8_make_valid (tzobject);
+
+ e_dbus_calendar_complete_get_timezone (
+ cal->priv->dbus_interface,
+ data->invocation,
+ utf8_tz_object);
+
+ g_free (utf8_tz_object);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
+
+ op_unref (data);
}
/**
guint32 opid,
GError *error)
{
+ OperationData *data;
+
g_return_if_fail (E_IS_DATA_CAL (cal));
- op_complete (cal, opid);
+ data = op_claim (cal, opid);
+ g_return_if_fail (data != NULL);
/* Translators: This is prefix to a detailed error message */
g_prefix_error (&error, "%s", _("Could not add calendar time zone: "));
- e_gdbus_cal_emit_add_timezone_done (cal->priv->dbus_interface, opid, error);
+ if (error == NULL) {
+ e_dbus_calendar_complete_add_timezone (
+ cal->priv->dbus_interface,
+ data->invocation);
+ } else {
+ data_cal_convert_to_client_error (error);
+ g_dbus_method_invocation_take_error (
+ data->invocation, error);
+ }
- if (error)
- g_error_free (error);
+ op_unref (data);
}
/**
g_return_if_fail (E_IS_DATA_CAL (cal));
g_return_if_fail (message != NULL);
- e_gdbus_cal_emit_backend_error (cal->priv->dbus_interface, message);
+ e_dbus_calendar_emit_error (cal->priv->dbus_interface, message);
}
/**
* FIXME: Document me.
*
* Since: 3.2
+ *
+ * Deprecated: 3.8: Use e_cal_backend_set_writable() instead.
**/
void
e_data_cal_report_readonly (EDataCal *cal,
{
g_return_if_fail (E_IS_DATA_CAL (cal));
- e_gdbus_cal_emit_readonly (cal->priv->dbus_interface, readonly);
+ e_cal_backend_set_writable (cal->priv->backend, !readonly);
}
/**
* FIXME: Document me.
*
* Since: 3.2
+ *
+ * Deprecated: 3.8: Use e_backend_set_online() instead.
**/
void
e_data_cal_report_online (EDataCal *cal,
{
g_return_if_fail (E_IS_DATA_CAL (cal));
- e_gdbus_cal_emit_online (cal->priv->dbus_interface, is_online);
+ e_backend_set_online (E_BACKEND (cal->priv->backend), is_online);
}
/**
e_data_cal_report_free_busy_data (EDataCal *cal,
const GSList *freebusy)
{
- gchar **strv_freebusy;
+ gchar **strv;
+ guint length;
+ gint ii = 0;
g_return_if_fail (E_IS_DATA_CAL (cal));
- strv_freebusy = gslist_to_strv (freebusy);
+ length = g_slist_length ((GSList *) freebusy);
+ strv = g_new0 (gchar *, length + 1);
+
+ while (freebusy != NULL) {
+ strv[ii++] = e_util_utf8_make_valid (freebusy->data);
+ freebusy = g_slist_next ((GSList *) freebusy);
+ }
- e_gdbus_cal_emit_free_busy_data (cal->priv->dbus_interface, (const gchar * const *) strv_freebusy);
+ e_dbus_calendar_emit_free_busy_data (
+ cal->priv->dbus_interface,
+ (const gchar * const *) strv);
- g_strfreev (strv_freebusy);
+ g_strfreev (strv);
}
/**
const gchar *prop_name,
const gchar *prop_value)
{
+ EDBusCalendar *dbus_interface;
gchar **strv;
g_return_if_fail (E_IS_DATA_CAL (cal));
g_return_if_fail (prop_name != NULL);
- g_return_if_fail (*prop_name != '\0');
- g_return_if_fail (prop_value != NULL);
- strv = e_gdbus_templates_encode_two_strings (prop_name, prop_value);
- g_return_if_fail (strv != NULL);
+ if (prop_value == NULL)
+ prop_value = "";
- e_gdbus_cal_emit_backend_property_changed (cal->priv->dbus_interface, (const gchar * const *) strv);
+ dbus_interface = cal->priv->dbus_interface;
- g_strfreev (strv);
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_CAPABILITIES)) {
+ strv = g_strsplit (prop_value, ",", -1);
+ e_dbus_calendar_set_capabilities (
+ dbus_interface, (const gchar * const *) strv);
+ g_strfreev (strv);
+ }
+
+ if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_REVISION))
+ e_dbus_calendar_set_revision (dbus_interface, prop_value);
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS))
+ e_dbus_calendar_set_cal_email_address (dbus_interface, prop_value);
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS))
+ e_dbus_calendar_set_alarm_email_address (dbus_interface, prop_value);
+
+ if (g_str_equal (prop_name, CAL_BACKEND_PROPERTY_DEFAULT_OBJECT))
+ e_dbus_calendar_set_default_object (dbus_interface, prop_value);
+
+ /* Disregard anything else. */
}
static void
G_OBJECT_CLASS (e_data_cal_parent_class)->finalize (object);
}
+static void
+data_cal_constructed (GObject *object)
+{
+ EDataCal *cal = E_DATA_CAL (object);
+ OperationData *op;
+
+ /* Chain up to parent's constructed() method. */
+ G_OBJECT_CLASS (e_data_cal_parent_class)->constructed (object);
+
+ g_object_bind_property (
+ cal->priv->backend, "cache-dir",
+ cal->priv->dbus_interface, "cache-dir",
+ G_BINDING_SYNC_CREATE);
+
+ g_object_bind_property (
+ cal->priv->backend, "online",
+ cal->priv->dbus_interface, "online",
+ G_BINDING_SYNC_CREATE);
+
+ g_object_bind_property (
+ cal->priv->backend, "writable",
+ cal->priv->dbus_interface, "writable",
+ G_BINDING_SYNC_CREATE);
+
+ /* XXX Initialize the rest of the properties by faking client
+ * requests. At present it's the only way to fish values
+ * from ECalBackend's antiquated API. */
+
+ op = op_new (OP_GET_BACKEND_PROPERTY, cal, NULL);
+ op->d.prop_name = CLIENT_BACKEND_PROPERTY_CAPABILITIES;
+ e_cal_backend_get_backend_property (
+ cal->priv->backend, cal, op->id,
+ op->cancellable, op->d.prop_name);
+ op_unref (op);
+
+ op = op_new (OP_GET_BACKEND_PROPERTY, cal, NULL);
+ op->d.prop_name = CLIENT_BACKEND_PROPERTY_REVISION;
+ e_cal_backend_get_backend_property (
+ cal->priv->backend, cal, op->id,
+ op->cancellable, op->d.prop_name);
+ op_unref (op);
+
+ op = op_new (OP_GET_BACKEND_PROPERTY, cal, NULL);
+ op->d.prop_name = CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS;
+ e_cal_backend_get_backend_property (
+ cal->priv->backend, cal, op->id,
+ op->cancellable, op->d.prop_name);
+ op_unref (op);
+
+ op = op_new (OP_GET_BACKEND_PROPERTY, cal, NULL);
+ op->d.prop_name = CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS;
+ e_cal_backend_get_backend_property (
+ cal->priv->backend, cal, op->id,
+ op->cancellable, op->d.prop_name);
+ op_unref (op);
+
+ op = op_new (OP_GET_BACKEND_PROPERTY, cal, NULL);
+ op->d.prop_name = CAL_BACKEND_PROPERTY_DEFAULT_OBJECT;
+ e_cal_backend_get_backend_property (
+ cal->priv->backend, cal, op->id,
+ op->cancellable, op->d.prop_name);
+ op_unref (op);
+}
+
static gboolean
data_cal_initable_init (GInitable *initable,
GCancellable *cancellable,
cal = E_DATA_CAL (initable);
- return e_gdbus_cal_register_object (
- cal->priv->dbus_interface,
+ return g_dbus_interface_skeleton_export (
+ G_DBUS_INTERFACE_SKELETON (cal->priv->dbus_interface),
cal->priv->connection,
cal->priv->object_path,
error);
object_class->get_property = data_cal_get_property;
object_class->dispose = data_cal_dispose;
object_class->finalize = data_cal_finalize;
+ object_class->constructed = data_cal_constructed;
g_object_class_install_property (
object_class,
static void
e_data_cal_init (EDataCal *ecal)
{
- EGdbusCal *dbus_interface;
+ EDBusCalendar *dbus_interface;
ecal->priv = E_DATA_CAL_GET_PRIVATE (ecal);
- ecal->priv->dbus_interface = e_gdbus_cal_stub_new ();
+ dbus_interface = e_dbus_calendar_skeleton_new ();
+ ecal->priv->dbus_interface = dbus_interface;
+
ecal->priv->pending_ops = g_hash_table_new_full (
(GHashFunc) g_direct_hash,
(GEqualFunc) g_direct_equal,
g_mutex_init (&ecal->priv->open_lock);
- dbus_interface = ecal->priv->dbus_interface;
g_signal_connect (
dbus_interface, "handle-open",
G_CALLBACK (data_cal_handle_open_cb), ecal);
dbus_interface, "handle-refresh",
G_CALLBACK (data_cal_handle_refresh_cb), ecal);
g_signal_connect (
- dbus_interface, "handle-get-backend-property",
- G_CALLBACK (data_cal_handle_get_backend_property_cb), ecal);
- g_signal_connect (
dbus_interface, "handle-get-object",
G_CALLBACK (data_cal_handle_get_object_cb), ecal);
g_signal_connect (
+++ /dev/null
-/*
- * e-gdbus-cal.c
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with the program; if not, see <http://www.gnu.org/licenses/>
- *
- *
- * Copyright (C) 2011 Red Hat, Inc. (www.redhat.com)
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <gio/gio.h>
-
-#include "e-gdbus-cal.h"
-
-#define E_GDBUS_CAL_PROXY_GET_PRIVATE(obj) \
- (G_TYPE_INSTANCE_GET_PRIVATE \
- ((obj), E_TYPE_GDBUS_CAL_PROXY, EGdbusCalProxyPrivate))
-
-#define GDBUS_CAL_INTERFACE_NAME "org.gnome.evolution.dataserver.Calendar"
-
-typedef EGdbusCalIface EGdbusCalInterface;
-G_DEFINE_INTERFACE (EGdbusCal, e_gdbus_cal, G_TYPE_OBJECT);
-
-enum
-{
- _0_SIGNAL,
- __BACKEND_ERROR_SIGNAL,
- __READONLY_SIGNAL,
- __ONLINE_SIGNAL,
- __OPENED_SIGNAL,
- __FREE_BUSY_DATA_SIGNAL,
- __BACKEND_PROPERTY_CHANGED_SIGNAL,
- __OPEN_METHOD,
- __OPEN_DONE_SIGNAL,
- __REFRESH_METHOD,
- __REFRESH_DONE_SIGNAL,
- __GET_BACKEND_PROPERTY_METHOD,
- __GET_BACKEND_PROPERTY_DONE_SIGNAL,
- __SET_BACKEND_PROPERTY_METHOD,
- __SET_BACKEND_PROPERTY_DONE_SIGNAL,
- __GET_OBJECT_METHOD,
- __GET_OBJECT_DONE_SIGNAL,
- __GET_OBJECT_LIST_METHOD,
- __GET_OBJECT_LIST_DONE_SIGNAL,
- __GET_FREE_BUSY_METHOD,
- __GET_FREE_BUSY_DONE_SIGNAL,
- __CREATE_OBJECTS_METHOD,
- __CREATE_OBJECTS_DONE_SIGNAL,
- __MODIFY_OBJECTS_METHOD,
- __MODIFY_OBJECTS_DONE_SIGNAL,
- __REMOVE_OBJECTS_METHOD,
- __REMOVE_OBJECTS_DONE_SIGNAL,
- __RECEIVE_OBJECTS_METHOD,
- __RECEIVE_OBJECTS_DONE_SIGNAL,
- __SEND_OBJECTS_METHOD,
- __SEND_OBJECTS_DONE_SIGNAL,
- __GET_ATTACHMENT_URIS_METHOD,
- __GET_ATTACHMENT_URIS_DONE_SIGNAL,
- __DISCARD_ALARM_METHOD,
- __DISCARD_ALARM_DONE_SIGNAL,
- __GET_VIEW_METHOD,
- __GET_VIEW_DONE_SIGNAL,
- __GET_TIMEZONE_METHOD,
- __GET_TIMEZONE_DONE_SIGNAL,
- __ADD_TIMEZONE_METHOD,
- __ADD_TIMEZONE_DONE_SIGNAL,
- __CANCEL_OPERATION_METHOD,
- __CANCEL_ALL_METHOD,
- __CLOSE_METHOD,
- __LAST_SIGNAL
-};
-
-/* This is also defined in e-cal-component.h */
-typedef struct {
- gchar *uid;
- gchar *rid;
-} ECalComponentId;
-
-static guint signals[__LAST_SIGNAL] = {0};
-
-struct _EGdbusCalProxyPrivate
-{
- GHashTable *pending_ops;
-};
-
-/* ------------------------------------------------------------------------- */
-
-/* Various lookup tables */
-
-static GHashTable *_method_name_to_id = NULL;
-static GHashTable *_method_name_to_type = NULL;
-static GHashTable *_signal_name_to_id = NULL;
-static GHashTable *_signal_name_to_type = NULL;
-
-static guint
-lookup_method_id_from_method_name (const gchar *method_name)
-{
- return GPOINTER_TO_UINT (g_hash_table_lookup (_method_name_to_id, method_name));
-}
-
-static guint
-lookup_method_type_from_method_name (const gchar *method_name)
-{
- return GPOINTER_TO_UINT (g_hash_table_lookup (_method_name_to_type, method_name));
-}
-
-static guint
-lookup_signal_id_from_signal_name (const gchar *signal_name)
-{
- return GPOINTER_TO_UINT (g_hash_table_lookup (_signal_name_to_id, signal_name));
-}
-
-static guint
-lookup_signal_type_from_signal_name (const gchar *signal_name)
-{
- return GPOINTER_TO_UINT (g_hash_table_lookup (_signal_name_to_type, signal_name));
-}
-
-/* ------------------------------------------------------------------------- */
-
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRING (GDBUS_CAL_INTERFACE_NAME,
- backend_error)
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_BOOLEAN (GDBUS_CAL_INTERFACE_NAME,
- readonly)
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_BOOLEAN (GDBUS_CAL_INTERFACE_NAME,
- online)
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV (GDBUS_CAL_INTERFACE_NAME,
- opened)
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV (GDBUS_CAL_INTERFACE_NAME,
- free_busy_data)
-E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV (GDBUS_CAL_INTERFACE_NAME,
- backend_property_changed)
-
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- open)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- refresh)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING (GDBUS_CAL_INTERFACE_NAME,
- get_backend_property)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- set_backend_property)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING (GDBUS_CAL_INTERFACE_NAME,
- get_object)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV (GDBUS_CAL_INTERFACE_NAME,
- get_object_list)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- get_free_busy)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV (GDBUS_CAL_INTERFACE_NAME,
- create_objects)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- modify_objects)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- remove_objects)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- receive_objects)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV (GDBUS_CAL_INTERFACE_NAME,
- send_objects)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV (GDBUS_CAL_INTERFACE_NAME,
- get_attachment_uris)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- discard_alarm)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING (GDBUS_CAL_INTERFACE_NAME,
- get_view)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING (GDBUS_CAL_INTERFACE_NAME,
- get_timezone)
-E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID (GDBUS_CAL_INTERFACE_NAME,
- add_timezone)
-
-static void
-e_gdbus_cal_default_init (EGdbusCalIface *iface)
-{
- /* Build lookup structures */
- _method_name_to_id = g_hash_table_new (g_str_hash, g_str_equal);
- _method_name_to_type = g_hash_table_new (g_str_hash, g_str_equal);
- _signal_name_to_id = g_hash_table_new (g_str_hash, g_str_equal);
- _signal_name_to_type = g_hash_table_new (g_str_hash, g_str_equal);
-
- /* GObject signals definitions for D-Bus signals: */
- E_INIT_GDBUS_SIGNAL_STRING (
- EGdbusCalIface,
- "backend_error",
- backend_error,
- __BACKEND_ERROR_SIGNAL)
- E_INIT_GDBUS_SIGNAL_BOOLEAN (
- EGdbusCalIface,
- "readonly",
- readonly,
- __READONLY_SIGNAL)
- E_INIT_GDBUS_SIGNAL_BOOLEAN (
- EGdbusCalIface,
- "online",
- online,
- __ONLINE_SIGNAL)
- E_INIT_GDBUS_SIGNAL_STRV (
- EGdbusCalIface,
- "opened",
- opened,
- __OPENED_SIGNAL)
- E_INIT_GDBUS_SIGNAL_STRV (
- EGdbusCalIface,
- "free_busy_data",
- free_busy_data,
- __FREE_BUSY_DATA_SIGNAL)
- E_INIT_GDBUS_SIGNAL_STRV (
- EGdbusCalIface,
- "backend_property_changed",
- backend_property_changed,
- __BACKEND_PROPERTY_CHANGED_SIGNAL)
-
- /* GObject signals definitions for D-Bus methods: */
- E_INIT_GDBUS_METHOD_ASYNC_BOOLEAN__VOID (
- EGdbusCalIface,
- "open",
- open,
- __OPEN_METHOD,
- __OPEN_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_VOID__VOID (
- EGdbusCalIface,
- "refresh",
- refresh,
- __REFRESH_METHOD,
- __REFRESH_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING (
- EGdbusCalIface,
- "get_backend_property",
- get_backend_property,
- __GET_BACKEND_PROPERTY_METHOD,
- __GET_BACKEND_PROPERTY_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID (
- EGdbusCalIface,
- "set_backend_property",
- set_backend_property,
- __SET_BACKEND_PROPERTY_METHOD,
- __SET_BACKEND_PROPERTY_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__STRING (
- EGdbusCalIface,
- "get_object",
- get_object,
- __GET_OBJECT_METHOD,
- __GET_OBJECT_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__STRV (
- EGdbusCalIface,
- "get_object_list",
- get_object_list,
- __GET_OBJECT_LIST_METHOD,
- __GET_OBJECT_LIST_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID (
- EGdbusCalIface,
- "get_free_busy",
- get_free_busy,
- __GET_FREE_BUSY_METHOD,
- __GET_FREE_BUSY_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__STRV (
- EGdbusCalIface,
- "create_objects",
- create_objects,
- __CREATE_OBJECTS_METHOD,
- __CREATE_OBJECTS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID (
- EGdbusCalIface,
- "modify_objects",
- modify_objects,
- __MODIFY_OBJECTS_METHOD,
- __MODIFY_OBJECTS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID (
- EGdbusCalIface,
- "remove_objects",
- remove_objects,
- __REMOVE_OBJECTS_METHOD,
- __REMOVE_OBJECTS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__VOID (
- EGdbusCalIface,
- "receive_objects",
- receive_objects,
- __RECEIVE_OBJECTS_METHOD,
- __RECEIVE_OBJECTS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__STRV (
- EGdbusCalIface,
- "send_objects",
- send_objects,
- __SEND_OBJECTS_METHOD,
- __SEND_OBJECTS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__STRV (
- EGdbusCalIface,
- "get_attachment_uris",
- get_attachment_uris,
- __GET_ATTACHMENT_URIS_METHOD,
- __GET_ATTACHMENT_URIS_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID (
- EGdbusCalIface,
- "discard_alarm",
- discard_alarm,
- __DISCARD_ALARM_METHOD,
- __DISCARD_ALARM_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING (
- EGdbusCalIface,
- "get_view",
- get_view,
- __GET_VIEW_METHOD,
- __GET_VIEW_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING (
- EGdbusCalIface,
- "get_timezone",
- get_timezone,
- __GET_TIMEZONE_METHOD,
- __GET_TIMEZONE_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_ASYNC_STRING__VOID (
- EGdbusCalIface,
- "add_timezone",
- add_timezone,
- __ADD_TIMEZONE_METHOD,
- __ADD_TIMEZONE_DONE_SIGNAL)
- E_INIT_GDBUS_METHOD_UINT (
- EGdbusCalIface,
- "cancel_operation",
- cancel_operation,
- __CANCEL_OPERATION_METHOD)
- E_INIT_GDBUS_METHOD_VOID (
- EGdbusCalIface,
- "cancel_all",
- cancel_all,
- __CANCEL_ALL_METHOD)
- E_INIT_GDBUS_METHOD_VOID (
- EGdbusCalIface,
- "close",
- close,
- __CLOSE_METHOD)
-}
-
-void
-e_gdbus_cal_call_open (GDBusProxy *proxy,
- gboolean in_only_if_exists,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_boolean ("open", e_gdbus_cal_call_open, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_only_if_exists, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_open_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_open);
-}
-
-gboolean
-e_gdbus_cal_call_open_sync (GDBusProxy *proxy,
- gboolean in_only_if_exists,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_boolean__void (
- proxy, in_only_if_exists, cancellable, error,
- e_gdbus_cal_call_open,
- e_gdbus_cal_call_open_finish);
-}
-
-void
-e_gdbus_cal_call_refresh (GDBusProxy *proxy,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_void ("refresh", e_gdbus_cal_call_refresh, E_GDBUS_ASYNC_OP_KEEPER (proxy), cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_refresh_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_refresh);
-}
-
-gboolean
-e_gdbus_cal_call_refresh_sync (GDBusProxy *proxy,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_void__void (
- proxy, cancellable, error,
- e_gdbus_cal_call_refresh,
- e_gdbus_cal_call_refresh_finish);
-}
-
-void
-e_gdbus_cal_call_get_backend_property (GDBusProxy *proxy,
- const gchar *in_prop_name,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("get_backend_property", e_gdbus_cal_call_get_backend_property, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_prop_name, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_backend_property_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar **out_prop_value,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_string (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_prop_value, error, e_gdbus_cal_call_get_backend_property);
-}
-
-gboolean
-e_gdbus_cal_call_get_backend_property_sync (GDBusProxy *proxy,
- const gchar *in_prop_name,
- gchar **out_prop_value,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__string (
- proxy, in_prop_name, out_prop_value, cancellable, error,
- e_gdbus_cal_call_get_backend_property,
- e_gdbus_cal_call_get_backend_property_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_set_backend_property (const gchar *in_prop_name,
- const gchar *in_prop_value)
-{
- return e_gdbus_templates_encode_two_strings (in_prop_name, in_prop_value);
-}
-
-/* free out_prop_name and out_prop_value with g_free() */
-gboolean
-e_gdbus_cal_decode_set_backend_property (const gchar * const *in_strv,
- gchar **out_prop_name,
- gchar **out_prop_value)
-{
- return e_gdbus_templates_decode_two_strings (in_strv, out_prop_name, out_prop_value);
-}
-
-void
-e_gdbus_cal_call_set_backend_property (GDBusProxy *proxy,
- const gchar * const *in_prop_name_value,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("set_backend_property", e_gdbus_cal_call_set_backend_property, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_prop_name_value, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_set_backend_property_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_set_backend_property);
-}
-
-gboolean
-e_gdbus_cal_call_set_backend_property_sync (GDBusProxy *proxy,
- const gchar * const *in_prop_name_value,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__void (
- proxy, in_prop_name_value, cancellable, error,
- e_gdbus_cal_call_set_backend_property,
- e_gdbus_cal_call_set_backend_property_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_get_object (const gchar *in_uid,
- const gchar *in_rid)
-{
- return e_gdbus_templates_encode_two_strings (in_uid, in_rid);
-}
-
-/* free out_uid and out_rid with g_free() */
-gboolean
-e_gdbus_cal_decode_get_object (const gchar * const *in_strv,
- gchar **out_uid,
- gchar **out_rid)
-{
- return e_gdbus_templates_decode_two_strings (in_strv, out_uid, out_rid);
-}
-
-void
-e_gdbus_cal_call_get_object (GDBusProxy *proxy,
- const gchar * const *in_uid_rid,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("get_object", e_gdbus_cal_call_get_object, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_uid_rid, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_object_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar **out_object,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_string (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_object, error, e_gdbus_cal_call_get_object);
-}
-
-gboolean
-e_gdbus_cal_call_get_object_sync (GDBusProxy *proxy,
- const gchar * const *in_uid_rid,
- gchar **out_object,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__string (
- proxy, in_uid_rid, out_object, cancellable, error,
- e_gdbus_cal_call_get_object,
- e_gdbus_cal_call_get_object_finish);
-}
-
-void
-e_gdbus_cal_call_get_object_list (GDBusProxy *proxy,
- const gchar *in_sexp,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("get_object_list", e_gdbus_cal_call_get_object_list, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_sexp, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_object_list_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar ***out_objects,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_strv (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_objects, error, e_gdbus_cal_call_get_object_list);
-}
-
-gboolean
-e_gdbus_cal_call_get_object_list_sync (GDBusProxy *proxy,
- const gchar *in_sexp,
- gchar ***out_objects,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__strv (
- proxy, in_sexp, out_objects, cancellable, error,
- e_gdbus_cal_call_get_object_list,
- e_gdbus_cal_call_get_object_list_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_get_free_busy (guint in_start,
- guint in_end,
- const GSList *in_users)
-{
- gchar **strv;
- gint ii;
-
- strv = g_new0 (gchar *, g_slist_length ((GSList *) in_users) + 3);
- strv[0] = g_strdup_printf ("%u", in_start);
- strv[1] = g_strdup_printf ("%u", in_end);
-
- for (ii = 0; in_users; ii++, in_users = in_users->next) {
- strv[ii + 2] = e_util_utf8_make_valid (in_users->data);
- }
-
- strv[ii + 2] = NULL;
-
- return strv;
-}
-
-/* free out_users with g_slist_foreach (out_users, (GFunc) g_free, NULL), g_slist_free (out_users); */
-gboolean
-e_gdbus_cal_decode_get_free_busy (const gchar * const *in_strv,
- guint *out_start,
- guint *out_end,
- GSList **out_users)
-{
- gint ii;
-
- g_return_val_if_fail (in_strv != NULL, FALSE);
- g_return_val_if_fail (in_strv[0] != NULL, FALSE);
- g_return_val_if_fail (in_strv[1] != NULL, FALSE);
- g_return_val_if_fail (out_start != NULL, FALSE);
- g_return_val_if_fail (out_end != NULL, FALSE);
- g_return_val_if_fail (out_users != NULL, FALSE);
-
- *out_users = NULL;
-
- for (ii = 0; in_strv[ii + 2]; ii++) {
- *out_users = g_slist_prepend (*out_users, g_strdup (in_strv[ii + 2]));
- }
-
- *out_start = atoi (in_strv[0]);
- *out_end = atoi (in_strv[1]);
- *out_users = g_slist_reverse (*out_users);
-
- return TRUE;
-}
-
-void
-e_gdbus_cal_call_get_free_busy (GDBusProxy *proxy,
- const gchar * const *in_start_end_userlist,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("get_free_busy", e_gdbus_cal_call_get_free_busy, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_start_end_userlist, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_free_busy_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_get_free_busy);
-}
-
-gboolean
-e_gdbus_cal_call_get_free_busy_sync (GDBusProxy *proxy,
- const gchar * const *in_start_end_userlist,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__void (
- proxy, in_start_end_userlist, cancellable, error,
- e_gdbus_cal_call_get_free_busy,
- e_gdbus_cal_call_get_free_busy_finish);
-}
-
-void
-e_gdbus_cal_call_create_objects (GDBusProxy *proxy,
- const gchar * const *in_calobjs,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("create_objects", e_gdbus_cal_call_create_objects, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_calobjs, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_create_objects_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar ***out_uids,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_strv (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_uids, error, e_gdbus_cal_call_create_objects);
-}
-
-gboolean
-e_gdbus_cal_call_create_objects_sync (GDBusProxy *proxy,
- const gchar * const *in_calobjs,
- gchar ***out_uids,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__strv (
- proxy, in_calobjs, out_uids, cancellable, error,
- e_gdbus_cal_call_create_objects,
- e_gdbus_cal_call_create_objects_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_modify_objects (const GSList *in_calobjs,
- guint in_mod)
-{
- gchar **strv;
- const GSList *l;
- gint i = 0;
-
- g_return_val_if_fail (in_calobjs != NULL, NULL);
-
- strv = g_new0 (gchar *, g_slist_length ((GSList *) in_calobjs) + 2);
- strv[i++] = g_strdup_printf ("%u", (guint32) in_mod);
-
- for (l = in_calobjs; l; l = l->next) {
- strv[i++] = e_util_utf8_make_valid ((gchar *) l->data);
- }
-
- strv[i] = NULL;
-
- return strv;
-}
-
-/* free calobjs with g_slist_free_full(calobjs, g_free) */
-gboolean
-e_gdbus_cal_decode_modify_objects (const gchar * const *in_strv,
- GSList **calobjs,
- guint *out_mod)
-{
- gint ii;
-
- g_return_val_if_fail (in_strv != NULL, FALSE);
- g_return_val_if_fail (in_strv[0] != NULL, FALSE);
- g_return_val_if_fail (in_strv[1] != NULL, FALSE);
- g_return_val_if_fail (calobjs != NULL, FALSE);
- g_return_val_if_fail (out_mod != NULL, FALSE);
-
- *out_mod = atoi (in_strv[0]);
- *calobjs = NULL;
-
- for (ii = 1; in_strv[ii]; ii++) {
- *calobjs = g_slist_prepend (*calobjs, g_strdup (in_strv[ii]));
- }
-
- *calobjs = g_slist_reverse (*calobjs);
-
- return TRUE;
-}
-
-void
-e_gdbus_cal_call_modify_objects (GDBusProxy *proxy,
- const gchar * const *in_mod_calobjs,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("modify_objects", e_gdbus_cal_call_modify_objects, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_mod_calobjs, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_modify_objects_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_modify_objects);
-}
-
-gboolean
-e_gdbus_cal_call_modify_objects_sync (GDBusProxy *proxy,
- const gchar * const *in_mod_calobjs,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__void (
- proxy, in_mod_calobjs, cancellable, error,
- e_gdbus_cal_call_modify_objects,
- e_gdbus_cal_call_modify_objects_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_remove_objects (const GSList *in_ids,
- guint in_mod)
-{
- gchar **strv;
- const GSList *l;
- gint i = 0;
-
- g_return_val_if_fail (in_ids != NULL, NULL);
-
- strv = g_new0 (gchar *, 2 + 2 * g_slist_length ((GSList *) in_ids));
- strv[i++] = g_strdup_printf ("%u", (guint32) in_mod);
-
- for (l = in_ids; l; l = l->next) {
- ECalComponentId *id = l->data;
-
- strv[i++] = e_util_utf8_make_valid (id->uid);
- strv[i++] = e_util_utf8_make_valid (id->rid ? id->rid : "");
- }
-
- strv[i] = NULL;
-
- return strv;
-}
-
-/* free ids g_slist_free_full(ids, g_free) */
-gboolean
-e_gdbus_cal_decode_remove_objects (const gchar * const *in_strv,
- GSList **out_ids,
- guint *out_mod)
-{
- gint ii;
-
- g_return_val_if_fail (in_strv != NULL, FALSE);
- g_return_val_if_fail (in_strv[0] != NULL, FALSE);
- g_return_val_if_fail (in_strv[1] != NULL, FALSE);
- g_return_val_if_fail (in_strv[2] != NULL, FALSE);
- g_return_val_if_fail (out_ids != NULL, FALSE);
- g_return_val_if_fail (out_mod != NULL, FALSE);
-
- *out_mod = atoi (in_strv[0]);
-
- *out_ids = NULL;
-
- for (ii = 1; in_strv[ii] && in_strv[ii + 1]; ii += 2) {
- ECalComponentId *id = g_new (ECalComponentId, 1);
- id->uid = g_strdup (in_strv[ii]);
- id->rid = *in_strv[ii + 1] ? g_strdup (in_strv[ii + 1]) : NULL;
-
- *out_ids = g_slist_prepend (*out_ids, id);
- }
-
- *out_ids = g_slist_reverse (*out_ids);
-
- return TRUE;
-}
-
-void
-e_gdbus_cal_call_remove_objects (GDBusProxy *proxy,
- const gchar * const *in_mod_ids,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("remove_objects", e_gdbus_cal_call_remove_objects, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_mod_ids, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_remove_objects_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_remove_objects);
-}
-
-gboolean
-e_gdbus_cal_call_remove_objects_sync (GDBusProxy *proxy,
- const gchar * const *in_mod_ids,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__void (
- proxy, in_mod_ids, cancellable, error,
- e_gdbus_cal_call_remove_objects,
- e_gdbus_cal_call_remove_objects_finish);
-}
-
-void
-e_gdbus_cal_call_receive_objects (GDBusProxy *proxy,
- const gchar *in_calobj,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("receive_objects", e_gdbus_cal_call_receive_objects, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_calobj, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_receive_objects_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_receive_objects);
-}
-
-gboolean
-e_gdbus_cal_call_receive_objects_sync (GDBusProxy *proxy,
- const gchar *in_calobj,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__void (
- proxy, in_calobj, cancellable, error,
- e_gdbus_cal_call_receive_objects,
- e_gdbus_cal_call_receive_objects_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_send_objects (const gchar *in_calobj,
- const GSList *in_users)
-{
- gint ii;
- gchar **strv;
-
- g_return_val_if_fail (in_calobj != NULL, NULL);
-
- strv = g_new0 (gchar *, g_slist_length ((GSList *) in_users) + 2);
- strv[0] = e_util_utf8_make_valid (in_calobj);
- for (ii = 0; in_users; ii++, in_users = in_users->next) {
- strv[ii + 1] = e_util_utf8_make_valid (in_users->data);
- }
- strv[ii + 1] = NULL;
-
- return strv;
-}
-
-/* free out_calobj with g_free() and out_users with g_strfreev() */
-gboolean
-e_gdbus_cal_decode_send_objects (const gchar * const *in_strv,
- gchar **out_calobj,
- GSList **out_users)
-{
- gint ii;
-
- g_return_val_if_fail (in_strv != NULL, FALSE);
- g_return_val_if_fail (in_strv[0] != NULL, FALSE);
- g_return_val_if_fail (out_calobj != NULL, FALSE);
- g_return_val_if_fail (out_users != NULL, FALSE);
-
- *out_users = NULL;
-
- for (ii = 0; in_strv[ii + 1]; ii++) {
- *out_users = g_slist_prepend (*out_users, g_strdup (in_strv[ii + 1]));
- }
-
- *out_calobj = g_strdup (in_strv[0]);
- *out_users = g_slist_reverse (*out_users);
-
- return TRUE;
-}
-
-void
-e_gdbus_cal_call_send_objects (GDBusProxy *proxy,
- const gchar *in_calobj,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("send_objects", e_gdbus_cal_call_send_objects, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_calobj, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_send_objects_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar ***out_calobj_users,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_strv (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_calobj_users, error, e_gdbus_cal_call_send_objects);
-}
-
-gboolean
-e_gdbus_cal_call_send_objects_sync (GDBusProxy *proxy,
- const gchar *in_calobj,
- gchar ***out_calobj_users,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__strv (
- proxy, in_calobj, out_calobj_users, cancellable, error,
- e_gdbus_cal_call_send_objects,
- e_gdbus_cal_call_send_objects_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_get_attachment_uris (const gchar *in_uid,
- const gchar *in_rid)
-{
- return e_gdbus_templates_encode_two_strings (in_uid, in_rid);
-}
-
-/* free out_uid and out_rid with g_free() */
-gboolean
-e_gdbus_cal_decode_get_attachment_uris (const gchar * const *in_strv,
- gchar **out_uid,
- gchar **out_rid)
-{
- return e_gdbus_templates_decode_two_strings (in_strv, out_uid, out_rid);
-}
-
-void
-e_gdbus_cal_call_get_attachment_uris (GDBusProxy *proxy,
- const gchar * const *in_uid_rid,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("get_attachment_uris", e_gdbus_cal_call_get_attachment_uris, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_uid_rid, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_attachment_uris_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar ***out_attachments,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_strv (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_attachments, error, e_gdbus_cal_call_get_attachment_uris);
-}
-
-gboolean
-e_gdbus_cal_call_get_attachment_uris_sync (GDBusProxy *proxy,
- const gchar * const *in_uid_rid,
- gchar ***out_attachments,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__strv (
- proxy, in_uid_rid, out_attachments, cancellable, error,
- e_gdbus_cal_call_get_attachment_uris,
- e_gdbus_cal_call_get_attachment_uris_finish);
-}
-
-/* free returned pointer with g_strfreev() */
-gchar **
-e_gdbus_cal_encode_discard_alarm (const gchar *in_uid,
- const gchar *in_rid,
- const gchar *in_auid)
-{
- gchar **strv;
-
- strv = g_new0 (gchar *, 4);
- strv[0] = e_util_utf8_make_valid (in_uid ? in_uid : "");
- strv[1] = e_util_utf8_make_valid (in_rid ? in_rid : "");
- strv[2] = e_util_utf8_make_valid (in_auid ? in_auid : "");
- strv[3] = NULL;
-
- return strv;
-}
-
-/* free out_uid, out_rid and out_auid with g_free() */
-gboolean
-e_gdbus_cal_decode_discard_alarm (const gchar * const *in_strv,
- gchar **out_uid,
- gchar **out_rid,
- gchar **out_auid)
-{
- g_return_val_if_fail (in_strv != NULL, FALSE);
- g_return_val_if_fail (in_strv[0] != NULL, FALSE);
- g_return_val_if_fail (in_strv[1] != NULL, FALSE);
- g_return_val_if_fail (in_strv[2] != NULL, FALSE);
- g_return_val_if_fail (in_strv[3] == NULL, FALSE);
- g_return_val_if_fail (out_uid != NULL, FALSE);
- g_return_val_if_fail (out_rid != NULL, FALSE);
- g_return_val_if_fail (out_auid != NULL, FALSE);
-
- *out_uid = g_strdup (in_strv[0]);
- *out_rid = g_strdup (in_strv[1]);
- *out_auid = g_strdup (in_strv[2]);
-
- return TRUE;
-}
-
-void
-e_gdbus_cal_call_discard_alarm (GDBusProxy *proxy,
- const gchar * const *in_uid_rid_auid,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_strv ("discard_alarm", e_gdbus_cal_call_discard_alarm, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_uid_rid_auid, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_discard_alarm_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_discard_alarm);
-}
-
-gboolean
-e_gdbus_cal_call_discard_alarm_sync (GDBusProxy *proxy,
- const gchar * const *in_uid_rid_auid,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_strv__void (
- proxy, in_uid_rid_auid, cancellable, error,
- e_gdbus_cal_call_discard_alarm,
- e_gdbus_cal_call_discard_alarm_finish);
-}
-
-void
-e_gdbus_cal_call_get_view (GDBusProxy *proxy,
- const gchar *in_sexp,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("get_view", e_gdbus_cal_call_get_view, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_sexp, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_view_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar **out_view_path,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_string (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_view_path, error, e_gdbus_cal_call_get_view);
-}
-
-gboolean
-e_gdbus_cal_call_get_view_sync (GDBusProxy *proxy,
- const gchar *in_sexp,
- gchar **out_view_path,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__string (
- proxy, in_sexp, out_view_path, cancellable, error,
- e_gdbus_cal_call_get_view,
- e_gdbus_cal_call_get_view_finish);
-}
-
-void
-e_gdbus_cal_call_get_timezone (GDBusProxy *proxy,
- const gchar *in_tzid,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("get_timezone", e_gdbus_cal_call_get_timezone, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_tzid, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_get_timezone_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- gchar **out_tzobject,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_string (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, out_tzobject, error, e_gdbus_cal_call_get_timezone);
-}
-
-gboolean
-e_gdbus_cal_call_get_timezone_sync (GDBusProxy *proxy,
- const gchar *in_tzid,
- gchar **out_tzobject,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__string (
- proxy, in_tzid, out_tzobject, cancellable, error,
- e_gdbus_cal_call_get_timezone,
- e_gdbus_cal_call_get_timezone_finish);
-}
-
-void
-e_gdbus_cal_call_add_timezone (GDBusProxy *proxy,
- const gchar *in_tzobject,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_call_string ("add_timezone", e_gdbus_cal_call_add_timezone, E_GDBUS_ASYNC_OP_KEEPER (proxy), in_tzobject, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_add_timezone_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_finish_call_void (E_GDBUS_ASYNC_OP_KEEPER (proxy), result, error, e_gdbus_cal_call_add_timezone);
-}
-
-gboolean
-e_gdbus_cal_call_add_timezone_sync (GDBusProxy *proxy,
- const gchar *in_tzobject,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_call_sync_string__void (
- proxy, in_tzobject, cancellable, error,
- e_gdbus_cal_call_add_timezone,
- e_gdbus_cal_call_add_timezone_finish);
-}
-
-void
-e_gdbus_cal_call_cancel_operation (GDBusProxy *proxy,
- guint in_opid,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_method_call_uint ("cancel_operation", proxy, in_opid, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_cancel_operation_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_method_call_finish_void (proxy, result, error);
-}
-
-gboolean
-e_gdbus_cal_call_cancel_operation_sync (GDBusProxy *proxy,
- guint in_opid,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_method_call_sync_uint__void ("cancel_operation", proxy, in_opid, cancellable, error);
-}
-
-void
-e_gdbus_cal_call_cancel_all (GDBusProxy *proxy,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_method_call_void ("cancel_all", proxy, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_cancel_all_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_method_call_finish_void (proxy, result, error);
-}
-
-gboolean
-e_gdbus_cal_call_cancel_all_sync (GDBusProxy *proxy,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_method_call_sync_void__void ("cancel_all", proxy, cancellable, error);
-}
-
-void
-e_gdbus_cal_call_close (GDBusProxy *proxy,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- e_gdbus_proxy_method_call_void ("close", proxy, cancellable, callback, user_data);
-}
-
-gboolean
-e_gdbus_cal_call_close_finish (GDBusProxy *proxy,
- GAsyncResult *result,
- GError **error)
-{
- return e_gdbus_proxy_method_call_finish_void (proxy, result, error);
-}
-
-gboolean
-e_gdbus_cal_call_close_sync (GDBusProxy *proxy,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_proxy_method_call_sync_void__void ("close", proxy, cancellable, error);
-}
-
-#define DECLARE_EMIT_DONE_SIGNAL_0(_mname, _sig_id) \
-void \
-e_gdbus_cal_emit_ ## _mname ## _done (EGdbusCal *object, guint arg_opid, const GError *arg_error) \
-{ \
- g_signal_emit (object, signals[_sig_id], 0, arg_opid, arg_error); \
-}
-
-#define DECLARE_EMIT_DONE_SIGNAL_1(_mname, _sig_id, _par_type) \
-void \
-e_gdbus_cal_emit_ ## _mname ## _done (EGdbusCal *object, guint arg_opid, const GError *arg_error, _par_type out_par) \
-{ \
- g_signal_emit (object, signals[_sig_id], 0, arg_opid, arg_error, out_par); \
-}
-
-DECLARE_EMIT_DONE_SIGNAL_0 (open,
- __OPEN_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_0 (refresh,
- __REFRESH_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_backend_property,
- __GET_BACKEND_PROPERTY_DONE_SIGNAL,
- const gchar *)
-DECLARE_EMIT_DONE_SIGNAL_0 (set_backend_property,
- __SET_BACKEND_PROPERTY_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_object,
- __GET_OBJECT_DONE_SIGNAL,
- const gchar *)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_object_list,
- __GET_OBJECT_LIST_DONE_SIGNAL,
- const gchar * const *)
-DECLARE_EMIT_DONE_SIGNAL_0 (get_free_busy,
- __GET_FREE_BUSY_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_1 (create_objects,
- __CREATE_OBJECTS_DONE_SIGNAL,
- const gchar * const *)
-DECLARE_EMIT_DONE_SIGNAL_0 (modify_objects,
- __MODIFY_OBJECTS_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_0 (remove_objects,
- __REMOVE_OBJECTS_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_0 (receive_objects,
- __RECEIVE_OBJECTS_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_1 (send_objects,
- __SEND_OBJECTS_DONE_SIGNAL,
- const gchar * const *)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_attachment_uris,
- __GET_ATTACHMENT_URIS_DONE_SIGNAL,
- const gchar * const *)
-DECLARE_EMIT_DONE_SIGNAL_0 (discard_alarm,
- __DISCARD_ALARM_DONE_SIGNAL)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_view,
- __GET_VIEW_DONE_SIGNAL,
- const gchar *)
-DECLARE_EMIT_DONE_SIGNAL_1 (get_timezone,
- __GET_TIMEZONE_DONE_SIGNAL,
- const gchar *)
-DECLARE_EMIT_DONE_SIGNAL_0 (add_timezone,
- __ADD_TIMEZONE_DONE_SIGNAL)
-
-void
-e_gdbus_cal_emit_backend_error (EGdbusCal *object,
- const gchar *arg_message)
-{
- g_return_if_fail (object != NULL);
- g_return_if_fail (arg_message != NULL);
-
- g_signal_emit (object, signals[__BACKEND_ERROR_SIGNAL], 0, arg_message);
-}
-
-void
-e_gdbus_cal_emit_readonly (EGdbusCal *object,
- gboolean arg_is_readonly)
-{
- g_signal_emit (object, signals[__READONLY_SIGNAL], 0, arg_is_readonly);
-}
-
-void
-e_gdbus_cal_emit_online (EGdbusCal *object,
- gboolean arg_is_online)
-{
- g_signal_emit (object, signals[__ONLINE_SIGNAL], 0, arg_is_online);
-}
-
-void
-e_gdbus_cal_emit_opened (EGdbusCal *object,
- const gchar * const *arg_error)
-{
- g_signal_emit (object, signals[__OPENED_SIGNAL], 0, arg_error);
-}
-
-void
-e_gdbus_cal_emit_free_busy_data (EGdbusCal *object,
- const gchar * const *arg_free_busy)
-{
- g_signal_emit (object, signals[__FREE_BUSY_DATA_SIGNAL], 0, arg_free_busy);
-}
-
-void
-e_gdbus_cal_emit_backend_property_changed (EGdbusCal *object,
- const gchar * const *arg_name_value)
-{
- g_signal_emit (object, signals[__BACKEND_PROPERTY_CHANGED_SIGNAL], 0, arg_name_value);
-}
-
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- backend_error,
- message,
- "s")
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- readonly,
- is_readonly,
- "b")
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- online,
- is_online,
- "b")
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- opened,
- error,
- "as")
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- free_busy_data,
- free_busy_data,
- "as")
-E_DECLARE_GDBUS_NOTIFY_SIGNAL_1 (cal,
- backend_property_changed,
- name_value,
- "as")
-
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- open,
- only_if_exists,
- "b")
-E_DECLARE_GDBUS_ASYNC_METHOD_0 (cal,
- refresh)
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_backend_property,
- propname,
- "s",
- propvalue,
- "s")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- set_backend_property,
- propnamevalue,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_object,
- uid_rid,
- "as",
- object,
- "s")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_object_list,
- sexp,
- "s",
- objects,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- get_free_busy,
- start_stop_users,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- create_objects,
- objects,
- "as",
- uids,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- modify_objects,
- object_mod,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- remove_objects,
- mod_ids,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- receive_objects,
- object,
- "s")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- send_objects,
- object,
- "s",
- object_users,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_attachment_uris,
- uid_rid,
- "as",
- attachments,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- discard_alarm,
- uid_rid_auid,
- "as")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_view,
- sexp,
- "s",
- view_path,
- "s")
-E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN (cal,
- get_timezone,
- tzid,
- "s",
- tzobject,
- "s")
-E_DECLARE_GDBUS_ASYNC_METHOD_1 (cal,
- add_timezone,
- tzobject,
- "s")
-
-E_DECLARE_GDBUS_SYNC_METHOD_1 (cal,
- cancel_operation,
- opid,
- "u")
-E_DECLARE_GDBUS_SYNC_METHOD_0 (cal,
- cancel_all)
-E_DECLARE_GDBUS_SYNC_METHOD_0 (cal,
- close)
-
-static const GDBusMethodInfo * const e_gdbus_cal_method_info_pointers[] =
-{
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, open),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, refresh),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_backend_property),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, set_backend_property),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_object),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_object_list),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_free_busy),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, create_objects),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, modify_objects),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, remove_objects),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, receive_objects),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, send_objects),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_attachment_uris),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, discard_alarm),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_view),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, get_timezone),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, add_timezone),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, cancel_operation),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, cancel_all),
- &E_DECLARED_GDBUS_METHOD_INFO_NAME (cal, close),
- NULL
-};
-
-static const GDBusSignalInfo * const e_gdbus_cal_signal_info_pointers[] =
-{
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, backend_error),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, readonly),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, online),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, opened),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, free_busy_data),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, backend_property_changed),
-
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, open_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, refresh_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_backend_property_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, set_backend_property_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_object_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_object_list_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_free_busy_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, create_objects_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, modify_objects_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, remove_objects_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, receive_objects_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, send_objects_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_attachment_uris_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, discard_alarm_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_view_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, get_timezone_done),
- &E_DECLARED_GDBUS_SIGNAL_INFO_NAME (cal, add_timezone_done),
- NULL
-};
-
-static const GDBusInterfaceInfo _e_gdbus_cal_interface_info =
-{
- -1,
- (gchar *) GDBUS_CAL_INTERFACE_NAME,
- (GDBusMethodInfo **) &e_gdbus_cal_method_info_pointers,
- (GDBusSignalInfo **) &e_gdbus_cal_signal_info_pointers,
- (GDBusPropertyInfo **) NULL
-};
-
-static void
-handle_method_call (GDBusConnection *connection,
- const gchar *sender,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *method_name,
- GVariant *parameters,
- GDBusMethodInvocation *invocation,
- gpointer user_data)
-{
- guint method_id, method_type;
-
- method_id = lookup_method_id_from_method_name (method_name);
- method_type = lookup_method_type_from_method_name (method_name);
-
- g_return_if_fail (method_id != 0);
- g_return_if_fail (method_type != 0);
-
- e_gdbus_stub_handle_method_call (user_data, invocation, parameters, method_name, signals[method_id], method_type);
-}
-
-static GVariant *
-get_property (GDBusConnection *connection,
- const gchar *sender,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *property_name,
- GError **error,
- gpointer user_data)
-{
- g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "This implementation does not support property `%s'", property_name);
- return NULL;
-}
-
-static gboolean
-set_property (GDBusConnection *connection,
- const gchar *sender,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *property_name,
- GVariant *value,
- GError **error,
- gpointer user_data)
-{
- g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "This implementation does not support property `%s'", property_name);
- return FALSE;
-}
-
-static const GDBusInterfaceVTable e_gdbus_cal_interface_vtable =
-{
- handle_method_call,
- get_property,
- set_property
-};
-
-static gboolean
-emit_notifications_in_idle (gpointer user_data)
-{
- GObject *object = G_OBJECT (user_data);
- GDBusConnection *connection;
- const gchar *path;
- GHashTable *notification_queue;
- GHashTableIter iter;
- const gchar *property_name;
- GVariant *value;
- GVariantBuilder *builder;
- GVariantBuilder *invalidated_builder;
- GHashTable *pvc;
- gboolean has_changes;
-
- notification_queue = g_object_get_data (object, "gdbus-codegen-notification-queue");
- path = g_object_get_data (object, "gdbus-codegen-path");
- connection = g_object_get_data (object, "gdbus-codegen-connection");
- pvc = g_object_get_data (object, "gdbus-codegen-pvc");
- g_assert (notification_queue != NULL && path != NULL && connection != NULL && pvc != NULL);
-
- builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
- invalidated_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
- g_hash_table_iter_init (&iter, notification_queue);
- has_changes = FALSE;
- while (g_hash_table_iter_next (&iter, (gpointer) &property_name, (gpointer) &value)) {
- GVariant *cached_value;
- cached_value = g_hash_table_lookup (pvc, property_name);
- if (cached_value == NULL || !g_variant_equal (cached_value, value)) {
- g_hash_table_insert (pvc, (gpointer) property_name, (gpointer) g_variant_ref (value));
- g_variant_builder_add (builder, "{sv}", property_name, value);
- has_changes = TRUE;
- }
- }
-
- if (has_changes) {
- g_dbus_connection_emit_signal (
- connection,
- NULL,
- path,
- "org.freedesktop.DBus.Properties",
- "PropertiesChanged",
- g_variant_new (
- "(sa{sv}as)",
- GDBUS_CAL_INTERFACE_NAME,
- builder,
- invalidated_builder),
- NULL);
- } else {
- g_variant_builder_unref (builder);
- g_variant_builder_unref (invalidated_builder);
- }
-
- g_hash_table_remove_all (notification_queue);
- g_object_set_data (object, "gdbus-codegen-notification-idle-id", GUINT_TO_POINTER (0));
- return FALSE;
-}
-
-/**
- * e_gdbus_cal_drain_notify:
- * @object: A #EGdbusCal that is exported.
- *
- * If @object has queued notifications, empty the queue forcing
- * the <literal>PropertiesChanged</literal> signal to be emitted.
- * See <xref linkend="EGdbusCal.description"/> for more background information.
- */
-void
-e_gdbus_cal_drain_notify (EGdbusCal *object)
-{
- gint idle_id;
- idle_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (object), "gdbus-codegen-notification-idle-id"));
- if (idle_id > 0) {
- emit_notifications_in_idle (object);
- g_source_remove (idle_id);
- }
-}
-
-static void
-on_object_unregistered (GObject *object)
-{
- gint idle_id;
- idle_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (object), "gdbus-codegen-notification-idle-id"));
- if (idle_id > 0) {
- g_source_remove (idle_id);
- }
- g_object_set_data (G_OBJECT (object), "gdbus-codegen-path", NULL);
- g_object_set_data (G_OBJECT (object), "gdbus-codegen-connection", NULL);
-}
-
-/**
- * e_gdbus_cal_register_object:
- * @object: An instance of a #GObject<!-- -->-derived type implementing the #EGdbusCal interface.
- * @connection: A #GDBusConnection.
- * @object_path: The object to register the object at.
- * @error: Return location for error or %NULL.
- *
- * Registers @object at @object_path on @connection.
- *
- * See <xref linkend="EGdbusCal.description"/>
- * for how properties, methods and signals are handled.
- *
- * Returns: 0 if @error is set, otherwise a registration id (never 0) that can be used with g_dbus_connection_unregister_object().
- */
-guint
-e_gdbus_cal_register_object (EGdbusCal *object,
- GDBusConnection *connection,
- const gchar *object_path,
- GError **error)
-{
- GHashTable *pvc;
-
- pvc = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_variant_unref);
-
- g_object_set_data_full (G_OBJECT (object), "gdbus-codegen-path", (gpointer) g_strdup (object_path), g_free);
- g_object_set_data (G_OBJECT (object), "gdbus-codegen-connection", (gpointer) connection);
- g_object_set_data_full (G_OBJECT (object), "gdbus-codegen-pvc", (gpointer) pvc, (GDestroyNotify) g_hash_table_unref);
-
- return g_dbus_connection_register_object (
- connection,
- object_path,
- (GDBusInterfaceInfo *) &_e_gdbus_cal_interface_info,
- &e_gdbus_cal_interface_vtable,
- object,
- (GDestroyNotify) on_object_unregistered,
- error);
-}
-
-/**
- * e_gdbus_cal_interface_info:
- *
- * Gets interface description for the <literal>org.gnome.evolution.dataserver.Calendar</literal> D-Bus interface.
- *
- * Returns: A #GDBusInterfaceInfo. Do not free, the object is statically allocated.
- */
-const GDBusInterfaceInfo *
-e_gdbus_cal_interface_info (void)
-{
- return &_e_gdbus_cal_interface_info;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static void proxy_iface_init (EGdbusCalIface *iface);
-static void async_op_keeper_iface_init (EGdbusAsyncOpKeeperInterface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (EGdbusCalProxy, e_gdbus_cal_proxy, G_TYPE_DBUS_PROXY,
- G_IMPLEMENT_INTERFACE (E_TYPE_GDBUS_CAL, proxy_iface_init)
- G_IMPLEMENT_INTERFACE (E_TYPE_GDBUS_ASYNC_OP_KEEPER, async_op_keeper_iface_init));
-
-static void
-e_gdbus_cal_proxy_init (EGdbusCalProxy *proxy)
-{
- g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), (GDBusInterfaceInfo *) &_e_gdbus_cal_interface_info);
-
- proxy->priv = E_GDBUS_CAL_PROXY_GET_PRIVATE (proxy);
- proxy->priv->pending_ops = e_gdbus_async_op_keeper_create_pending_ops (E_GDBUS_ASYNC_OP_KEEPER (proxy));
-
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (open);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (refresh);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING (get_backend_property);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (set_backend_property);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING (get_object);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV (get_object_list);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (get_free_busy);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV (create_objects);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (modify_objects);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (remove_objects);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (receive_objects);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV (send_objects);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV (get_attachment_uris);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (discard_alarm);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING (get_view);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING (get_timezone);
- E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID (add_timezone);
-}
-
-static void
-g_signal (GDBusProxy *proxy,
- const gchar *sender_name,
- const gchar *signal_name,
- GVariant *parameters)
-{
- guint signal_id, signal_type;
-
- signal_id = lookup_signal_id_from_signal_name (signal_name);
- signal_type = lookup_signal_type_from_signal_name (signal_name);
-
- g_return_if_fail (signal_id != 0);
- g_return_if_fail (signal_type != 0);
-
- e_gdbus_proxy_emit_signal (proxy, parameters, signals[signal_id], signal_type);
-}
-
-static void
-gdbus_cal_proxy_finalize (GObject *object)
-{
- EGdbusCalProxy *proxy = E_GDBUS_CAL_PROXY (object);
-
- if (g_hash_table_size (proxy->priv->pending_ops))
- g_debug ("%s: Kept %d items in pending_ops", G_STRFUNC, g_hash_table_size (proxy->priv->pending_ops));
-
- g_hash_table_destroy (proxy->priv->pending_ops);
-
- G_OBJECT_CLASS (e_gdbus_cal_proxy_parent_class)->finalize (object);
-}
-
-static void
-e_gdbus_cal_proxy_class_init (EGdbusCalProxyClass *class)
-{
- GObjectClass *object_class;
- GDBusProxyClass *proxy_class;
-
- g_type_class_add_private (class, sizeof (EGdbusCalProxyPrivate));
-
- object_class = G_OBJECT_CLASS (class);
- object_class->finalize = gdbus_cal_proxy_finalize;
-
- proxy_class = G_DBUS_PROXY_CLASS (class);
- proxy_class->g_signal = g_signal;
-}
-
-static void
-proxy_iface_init (EGdbusCalIface *iface)
-{
-}
-
-static GHashTable *
-gdbus_cal_get_pending_ops (EGdbusAsyncOpKeeper *object)
-{
- EGdbusCalProxy *proxy;
-
- g_return_val_if_fail (E_IS_GDBUS_CAL_PROXY (object), NULL);
-
- proxy = E_GDBUS_CAL_PROXY (object);
-
- return proxy->priv->pending_ops;
-}
-
-static gboolean
-gdbus_cal_call_cancel_operation_sync (EGdbusAsyncOpKeeper *object,
- guint in_opid,
- GCancellable *cancellable,
- GError **error)
-{
- return e_gdbus_cal_call_cancel_operation_sync (G_DBUS_PROXY (object), in_opid, cancellable, error);
-}
-
-static void
-async_op_keeper_iface_init (EGdbusAsyncOpKeeperInterface *iface)
-{
- g_return_if_fail (iface != NULL);
-
- iface->get_pending_ops = gdbus_cal_get_pending_ops;
- iface->cancel_op_sync = gdbus_cal_call_cancel_operation_sync;
-}
-
-/**
- * e_gdbus_cal_proxy_new:
- * @connection: A #GDBusConnection.
- * @flags: Flags used when constructing the proxy.
- * @name: A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
- * @object_path: An object path.
- * @cancellable: A #GCancellable or %NULL.
- * @callback: Callback function to invoke when the proxy is ready.
- * @user_data: User data to pass to @callback.
- *
- * Like g_dbus_proxy_new() but returns a #EGdbusCalProxy.
- *
- * This is a failable asynchronous constructor - when the proxy is ready, callback will be invoked and you can use e_gdbus_cal_proxy_new_finish() to get the result.
- */
-void
-e_gdbus_cal_proxy_new (GDBusConnection *connection,
- GDBusProxyFlags flags,
- const gchar *name,
- const gchar *object_path,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- g_async_initable_new_async (
- E_TYPE_GDBUS_CAL_PROXY,
- G_PRIORITY_DEFAULT,
- cancellable,
- callback,
- user_data,
- "g-flags", flags,
- "g-name", name,
- "g-connection", connection,
- "g-object-path", object_path,
- "g-interface-name", GDBUS_CAL_INTERFACE_NAME,
- NULL);
-}
-
-/**
- * e_gdbus_cal_proxy_new_finish:
- * @result: A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to e_gdbus_cal_proxy_new().
- * @error: Return location for error or %NULL.
- *
- * Finishes creating a #EGdbusCalProxy.
- *
- * Returns: A #EGdbusCalProxy or %NULL if @error is set. Free with g_object_unref().
- */
-EGdbusCal *
-e_gdbus_cal_proxy_new_finish (GAsyncResult *result,
- GError **error)
-{
- GObject *object;
- GObject *source_object;
- source_object = g_async_result_get_source_object (result);
- g_assert (source_object != NULL);
- object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), result, error);
- g_object_unref (source_object);
- if (object != NULL)
- return E_GDBUS_CAL (object);
- else
- return NULL;
-}
-
-/**
- * e_gdbus_cal_proxy_new_sync:
- * @connection: A #GDBusConnection.
- * @flags: Flags used when constructing the proxy.
- * @name: A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
- * @object_path: An object path.
- * @cancellable: A #GCancellable or %NULL.
- * @error: Return location for error or %NULL.
- *
- * Like g_dbus_proxy_new_sync() but returns a #EGdbusCalProxy.
- *
- * This is a synchronous failable constructor. See e_gdbus_cal_proxy_new() and e_gdbus_cal_proxy_new_finish() for the asynchronous version.
- *
- * Returns: A #EGdbusCalProxy or %NULL if error is set. Free with g_object_unref().
- */
-EGdbusCal *
-e_gdbus_cal_proxy_new_sync (GDBusConnection *connection,
- GDBusProxyFlags flags,
- const gchar *name,
- const gchar *object_path,
- GCancellable *cancellable,
- GError **error)
-{
- GInitable *initable;
- initable = g_initable_new (
- E_TYPE_GDBUS_CAL_PROXY,
- cancellable,
- error,
- "g-flags", flags,
- "g-name", name,
- "g-connection", connection,
- "g-object-path", object_path,
- "g-interface-name", GDBUS_CAL_INTERFACE_NAME,
- NULL);
- if (initable != NULL)
- return E_GDBUS_CAL (initable);
- else
- return NULL;
-}
-
-/**
- * e_gdbus_cal_proxy_new_for_bus:
- * @bus_type: A #GBusType.
- * @flags: Flags used when constructing the proxy.
- * @name: A bus name (well-known or unique).
- * @object_path: An object path.
- * @cancellable: A #GCancellable or %NULL.
- * @callback: Callback function to invoke when the proxy is ready.
- * @user_data: User data to pass to @callback.
- *
- * Like g_dbus_proxy_new_for_bus() but returns a #EGdbusCalProxy.
- *
- * This is a failable asynchronous constructor - when the proxy is ready, callback will be invoked and you can use e_gdbus_cal_proxy_new_for_bus_finish() to get the result.
- */
-void
-e_gdbus_cal_proxy_new_for_bus (GBusType bus_type,
- GDBusProxyFlags flags,
- const gchar *name,
- const gchar *object_path,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
-{
- g_async_initable_new_async (
- E_TYPE_GDBUS_CAL_PROXY,
- G_PRIORITY_DEFAULT,
- cancellable,
- callback,
- user_data,
- "g-flags", flags,
- "g-name", name,
- "g-bus-type", bus_type,
- "g-object-path", object_path,
- "g-interface-name", GDBUS_CAL_INTERFACE_NAME,
- NULL);
-}
-
-/**
- * e_gdbus_cal_proxy_new_for_bus_finish:
- * @result: A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to e_gdbus_cal_proxy_new_for_bus().
- * @error: Return location for error or %NULL.
- *
- * Finishes creating a #EGdbusCalProxy.
- *
- * Returns: A #EGdbusCalProxy or %NULL if @error is set. Free with g_object_unref().
- */
-EGdbusCal *
-e_gdbus_cal_proxy_new_for_bus_finish (GAsyncResult *result,
- GError **error)
-{
- GObject *object;
- GObject *source_object;
- source_object = g_async_result_get_source_object (result);
- g_assert (source_object != NULL);
- object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), result, error);
- g_object_unref (source_object);
- if (object != NULL)
- return E_GDBUS_CAL (object);
- else
- return NULL;
-}
-
-/**
- * e_gdbus_cal_proxy_new_for_bus_sync:
- * @bus_type: A #GBusType.
- * @flags: Flags used when constructing the proxy.
- * @name: A bus name (well-known or unique).
- * @object_path: An object path.
- * @cancellable: A #GCancellable or %NULL.
- * @error: Return location for error or %NULL.
- *
- * Like g_dbus_proxy_new_for_bus_sync() but returns a #EGdbusCalProxy.
- *
- * This is a synchronous failable constructor. See e_gdbus_cal_proxy_new_for_bus() and e_gdbus_cal_proxy_new_for_bus_finish() for the asynchronous version.
- *
- * Returns: A #EGdbusCalProxy or %NULL if error is set. Free with g_object_unref().
- */
-EGdbusCal *
-e_gdbus_cal_proxy_new_for_bus_sync (GBusType bus_type,
- GDBusProxyFlags flags,
- const gchar *name,
- const gchar *object_path,
- GCancellable *cancellable,
- GError **error)
-{
- GInitable *initable;
- initable = g_initable_new (
- E_TYPE_GDBUS_CAL_PROXY,
- cancellable,
- error,
- "g-flags", flags,
- "g-name", name,
- "g-bus-type", bus_type,
- "g-object-path", object_path,
- "g-interface-name", GDBUS_CAL_INTERFACE_NAME,
- NULL);
- if (initable != NULL)
- return E_GDBUS_CAL (initable);
- else
- return NULL;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static void stub_iface_init (EGdbusCalIface *iface);
-
-G_DEFINE_TYPE_WITH_CODE (EGdbusCalStub, e_gdbus_cal_stub, G_TYPE_OBJECT,
- G_IMPLEMENT_INTERFACE (E_TYPE_GDBUS_CAL, stub_iface_init));
-
-static void
-e_gdbus_cal_stub_init (EGdbusCalStub *stub)
-{
-}
-
-static void
-e_gdbus_cal_stub_class_init (EGdbusCalStubClass *klass)
-{
-}
-
-static void
-stub_iface_init (EGdbusCalIface *iface)
-{
-}
-
-/**
- * e_gdbus_cal_stub_new:
- *
- * Creates a new stub object that can be exported via e_gdbus_cal_register_object().
- *
- * Returns: A #EGdbusCalStub instance. Free with g_object_unref().
- */
-EGdbusCal *
-e_gdbus_cal_stub_new (void)
-{
- return E_GDBUS_CAL (g_object_new (E_TYPE_GDBUS_CAL_STUB, NULL));
-}
-
-/* Returns GDBus connection associated with the stub object */
-GDBusConnection *
-e_gdbus_cal_stub_get_connection (EGdbusCal *stub)
-{
- g_return_val_if_fail (stub != NULL, NULL);
- g_return_val_if_fail (E_IS_GDBUS_CAL_STUB (stub), NULL);
-
- return g_object_get_data (G_OBJECT (stub), "gdbus-codegen-connection");
-}
projects / platform / upstream / evolution-data-server.git / commitdiff