/** Load calendar name, owner and permission from the ESource. * * @param cb 3E calendar backend. * * @return TRUE on success, FALSE otherwise. */ gboolean e_cal_backend_3e_calendar_info_load(ECalBackend3e *cb) { ESource *source; const char *immediate_sync; source = e_cal_backend_get_source(E_CAL_BACKEND(cb)); immediate_sync = e_source_get_property(source, "eee-immediate-sync"); g_free(cb->priv->calname); g_free(cb->priv->owner); g_free(cb->priv->perm); cb->priv->calname = g_strdup(e_source_get_property(source, "eee-calname")); cb->priv->owner = g_strdup(e_source_get_property(source, "eee-owner")); cb->priv->perm = g_strdup(e_source_get_property(source, "eee-perm")); cb->priv->sync_immediately = (immediate_sync == NULL || !strcmp(immediate_sync, "1")); g_free(cb->priv->calspec); cb->priv->calspec = g_strdup_printf("%s:%s", cb->priv->owner, cb->priv->calname); if (cb->priv->calname == NULL || cb->priv->owner == NULL) { return FALSE; } return TRUE; }
static void on_unsubscribe_cb(GtkAction *action, EShellView *shell_view) { EShellSidebar *shell_sidebar = e_shell_view_get_shell_sidebar(shell_view); ESourceSelector *selector; g_object_get(shell_sidebar, "selector", &selector, NULL); ESource *source = e_source_selector_peek_primary_selection(selector); if (!e_source_is_3e (source)) { display_error_message (gtk_widget_get_toplevel (GTK_WIDGET (selector)), _("This action is available only for 3e calendars.")); g_object_unref (selector); return; } if (!eee_plugin_online) { display_error_message (gtk_widget_get_toplevel (GTK_WIDGET (selector)), _("This action is not available with 3e plugin in offline mode.")); g_object_unref (selector); return; } g_object_unref (selector); ESourceGroup *group = e_source_peek_group(source); const char *owner = e_source_get_property(source, "eee-owner"); const char *calname = e_source_get_property(source, "eee-calname"); EeeAccount *account; GError *err = NULL; account = eee_accounts_manager_find_account_by_source(mgr(), source); if (eee_account_unsubscribe_calendar(account, owner, calname)) { // get ECal and remove calendar from the server ECalClient *ecal = e_cal_client_new(source, E_CAL_CLIENT_SOURCE_TYPE_EVENTS, &err); if (!e_client_remove_sync((EClient *)ecal, NULL, &err)) { g_warning("** EEE ** ECal remove failed (%d:%s)", err->code, err->message); g_clear_error(&err); } g_object_unref(ecal); e_source_group_remove_source(group, source); } eee_account_disconnect(account); eee_accounts_manager_restart_sync(mgr()); }
static void process_removal_in_hash (const gchar *uri, gpointer value, ProcessRemovalsData *prd) { GSList *groups, *sources, *p, *q; gboolean found = FALSE; /* search the list of selected calendars */ groups = e_source_list_peek_groups (prd->source_list); for (p = groups; p != NULL; p = p->next) { ESourceGroup *group = E_SOURCE_GROUP (p->data); sources = e_source_group_peek_sources (group); for (q = sources; q != NULL; q = q->next) { ESource *source = E_SOURCE (q->data); gchar *source_uri; const gchar *completion = e_source_get_property (source, "alarm"); source_uri = e_source_get_uri (source); if (strcmp (source_uri, uri) == 0) if (!completion || !g_ascii_strcasecmp (completion, "true")) found = TRUE; g_free (source_uri); if (found) return; } } /* not found, so list it for removal */ prd->removals = g_list_prepend (prd->removals, (gpointer) uri); }
GtkWidget * org_gnome_default_cal (EPlugin *epl, EConfigHookItemFactoryData *data) { GtkWidget *widget; ESource *source; ECalConfigTargetSource *cal_target; int i; if (data->old) return data->old; cal_target = (ECalConfigTargetSource *) data->target; source = cal_target->source; widget = gtk_check_button_new_with_mnemonic (get_calendar_option_caption (cal_target->source_type)); if (e_source_get_property (source, "default")) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); i = ((GtkTable *)data->parent)->nrows; gtk_table_attach((GtkTable *)data->parent, widget, 1, 2, i, i+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect (GTK_TOGGLE_BUTTON (widget), "toggled", G_CALLBACK (default_source_changed), source); gtk_widget_show (widget); return widget; }
/* find EeeAccount for ESource object */ EeeAccount *eee_accounts_manager_find_account_by_source(EeeAccountsManager *self, ESource *source) { g_return_val_if_fail(IS_EEE_ACCOUNTS_MANAGER(self), NULL); g_return_val_if_fail(E_IS_SOURCE(source), NULL); g_return_val_if_fail(e_source_is_3e(source), NULL); return eee_accounts_manager_find_account_by_name(self, e_source_get_property(source, "eee-account")); }
static void addressbook_authenticate (EBook *book, gpointer data) { gchar *auth; gchar *user; gchar *passwd; gchar *str_uri; gchar *pass_key; gchar *auth_domain; gchar *component_name; EUri *e_uri; ESource *source = (ESource *)data; auth = (gchar *)e_source_get_property (source, "auth"); auth_domain = (gchar *)e_source_get_property (source, "auth-domain"); component_name = auth_domain ? auth_domain : "Addressbook"; if (auth && !strcmp ("plain/password", auth)) user = (gchar *)e_source_get_property (source, "user"); else user = (gchar *)e_source_get_property (source, "email_addr"); if (!user) user = ""; str_uri = e_source_get_uri (source); e_uri = e_uri_new (str_uri); pass_key = e_uri_to_string (e_uri, FALSE); e_uri_free (e_uri); passwd = e_passwords_get_password (component_name, pass_key); if (passwd) passwd = ""; if (book) if (!e_book_authenticate_user (book, user, passwd, auth, NULL)) LOG (g_warning ("Authentication failed")); g_free (pass_key); g_free (str_uri); return; }
void commit_default_calendar (EPlugin *epl, EConfigTarget *target) { ECalConfigTargetSource *cal_target; ESource *source; cal_target = (ECalConfigTargetSource *) target; source = cal_target->source; if (e_source_get_property (source, "default")) e_cal_set_default_source (source, cal_target->source_type, NULL); }
void commit_default_book (EPlugin *epl, EConfigTarget *target) { EABConfigTargetSource *book_target; ESource *source; book_target = (EABConfigTargetSource *) target; source = book_target->source; if (e_source_get_property (source, "default")) e_book_set_default_source (source, NULL); }
/** Setup 3E server connection information. * * @param cb 3E calendar backend. * @param username Username used for authentication. * @param password Password. * @param err Error pointer. */ gboolean e_cal_backend_3e_setup_connection(ECalBackend3e *cb, const char *username, const char *password) { ESource *source; g_return_val_if_fail(cb != NULL, FALSE); g_return_val_if_fail(username != NULL, FALSE); g_return_val_if_fail(password != NULL, FALSE); source = e_cal_backend_get_source(E_CAL_BACKEND(cb)); g_free(cb->priv->username); g_free(cb->priv->password); g_free(cb->priv->server_uri); cb->priv->server_uri = NULL; if (e_source_get_property(source, "eee-server")) { cb->priv->server_uri = g_strdup_printf("https://%s/RPC2", e_source_get_property(source, "eee-server")); } cb->priv->username = g_strdup(username); cb->priv->password = g_strdup(password); return TRUE; }
static char * auth_func_cb (ECal *ecal, const char *prompt, const char *key, gpointer user_data) { ESource *source; const gchar *auth_domain; const gchar *component_name; source = e_cal_get_source (ecal); auth_domain = e_source_get_property (source, "auth-domain"); component_name = auth_domain ? auth_domain : "Calendar"; return e_passwords_get_password (component_name, key); }
static void alarm_notify_load_calendars (AlarmNotify *an, ECalSourceType source_type) { ESourceList *source_list; GSList *groups, *sources, *p, *q; if (!e_cal_get_sources (&source_list, source_type, NULL)) { d (printf("%s:%d (load_calendars) - Cannont get sources\n ", __FILE__, __LINE__)); an->priv->source_lists[source_type] = NULL; return; } groups = e_source_list_peek_groups (source_list); for (p = groups; p != NULL; p = p->next) { ESourceGroup *group = E_SOURCE_GROUP (p->data); sources = e_source_group_peek_sources (group); for (q = sources; q != NULL; q = q->next) { ESource *source = E_SOURCE (q->data); gchar *uri; const gchar *completion = e_source_get_property (source, "alarm"); if (completion && (!g_ascii_strcasecmp (completion, "false") || !g_ascii_strcasecmp (completion, "never"))) continue; uri = e_source_get_uri (source); d (printf("%s:%d (load_calendars) - Loading Calendar %s \n", __FILE__, __LINE__, uri)); alarm_notify_add_calendar (an, source_type, source, FALSE); g_free (uri); } } g_signal_connect_object ( source_list, "changed", G_CALLBACK (alarm_notify_list_changed_cb), an, 0); an->priv->source_lists[source_type] = source_list; }
GtkWidget * org_gnome_default_book (EPlugin *epl, EConfigHookItemFactoryData *data) { GtkWidget *widget; ESource *source; EABConfigTargetSource *book_target; if (data->old) return data->old; widget = gtk_check_button_new_with_mnemonic (_("Mark as _default address book")); book_target = (EABConfigTargetSource *) data->target; source = book_target->source; if (e_source_get_property (source, "default")) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); gtk_container_add (GTK_CONTAINER (data->parent), widget); g_signal_connect (GTK_TOGGLE_BUTTON (widget), "toggled", G_CALLBACK (default_source_changed), source); gtk_widget_show (widget); return widget; }
gpointer check_username_filled (ESource *source) { gboolean res = TRUE; g_return_val_if_fail (source != NULL, NULL); if (g_ascii_strncasecmp ( GOOGLE_BASE_URI, e_source_group_peek_base_uri ( e_source_peek_group (source)), strlen (GOOGLE_BASE_URI)) == 0) { gchar *username; username = g_strdup (e_source_get_property (source, "username")); if (username) username = g_strstrip (username); res = username && *username; g_free (username); } return GINT_TO_POINTER (res ? 1 : 0); }
/* sync finish phase */ static gboolean eee_accounts_manager_sync_phase2(EeeAccountsManager *self) { GSList *iter, *iter2, *iter_next, *iter2_next; g_return_val_if_fail(IS_EEE_ACCOUNTS_MANAGER(self), FALSE); // unmark groups/sources for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter->next) { ESourceGroup *group = E_SOURCE_GROUP(iter->data); if (!e_source_group_is_3e(group)) { continue; } g_object_set_data(G_OBJECT(group), "synced", (gpointer)FALSE); for (iter2 = e_source_group_peek_sources(group); iter2; iter2 = iter2->next) { ESource *source = E_SOURCE(iter2->data); g_object_set_data(G_OBJECT(source), "synced", (gpointer)FALSE); } } // go through synced account description structures and update ESourceList // accordingly for (iter = self->priv->sync_accounts; iter; iter = iter->next) { EeeAccount *account = iter->data; EeeAccount *current_account; ESourceGroup *group; char *group_name = g_strdup_printf("3e: %s", account->name); // find ESourceGroup and EeeAccount #if EVOLUTION_VERSION >= 232 group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", group_name, NULL); #else group = e_source_list_peek_group_by_name(self->priv->eslist, group_name); #endif /* EVOLUTION_VERSION >= 232 */ current_account = eee_accounts_manager_find_account_by_name(self, account->name); if (account->state == EEE_ACCOUNT_STATE_DISABLED) { if (current_account) { eee_accounts_manager_remove_account(self, current_account); } if (group) { e_source_list_remove_group(self->priv->eslist, group); } g_object_unref(account); continue; } // create account if it does not exist if (current_account == NULL) { eee_accounts_manager_add_account(self, g_object_ref(account)); } else { eee_account_copy(current_account, account); } // create group if it does not exist if (group == NULL) { group = e_source_group_new(group_name, EEE_URI_PREFIX); e_source_list_add_group(self->priv->eslist, group, -1); g_object_unref(group); } g_free(group_name); // check group sources if account is available, otherwise just mark them as // synced if (account->state == EEE_ACCOUNT_STATE_NOTAVAIL) { GSList *iter_grp, *iter_src; for (iter_grp = e_source_list_peek_groups(self->priv->eslist); iter_grp; iter_grp = iter_grp->next) { ESourceGroup *group = iter_grp->data; for (iter_src = e_source_group_peek_sources(group); iter_src; iter_src = iter_src->next) { ESource *source = iter_src->data; const char *account_name = e_source_get_property(source, "eee-account"); if (account_name && !strcmp(account_name, account->name)) { g_object_set_data(G_OBJECT(source), "synced", (gpointer)TRUE); g_object_set_data(G_OBJECT(group), "synced", (gpointer)TRUE); } } } } else { GArray * cals = eee_account_peek_calendars (account); guint i; for (i = 0; i < cals->len; i++) { ESCalendarInfo *cal = g_array_index (cals, ESCalendarInfo *, i); ESource *source; if (!strcmp(cal->owner, account->name)) { // calendar owned by owner of account that represents current group source = e_source_group_peek_source_by_calname(group, cal->name); if (source == NULL) { source = e_source_new_3e_with_attrs(cal->name, cal->owner, account, cal->perm, cal->attrs); e_source_group_add_source(group, source, -1); g_object_unref(source); } else { e_source_set_3e_properties_with_attrs(source, cal->name, cal->owner, account, cal->perm, cal->attrs); } } else { char *owner_group_name = g_strdup_printf("3e: %s", cal->owner); // shared calendar, it should be put into another group #if EVOLUTION_VERSION >= 232 ESourceGroup *owner_group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", owner_group_name, NULL); #else ESourceGroup *owner_group = e_source_list_peek_group_by_name(self->priv->eslist, owner_group_name); #endif /* EVOLUTION_VERSION >= 232 */ if (owner_group == NULL) { owner_group = e_source_group_new(owner_group_name, EEE_URI_PREFIX); e_source_list_add_group(self->priv->eslist, owner_group, -1); g_object_unref(owner_group); } g_object_set_data(G_OBJECT(owner_group), "synced", (gpointer)TRUE); source = e_source_group_peek_source_by_calname(owner_group, cal->name); if (source == NULL) { source = e_source_new_3e_with_attrs(cal->name, cal->owner, account, cal->perm, cal->attrs); e_source_group_add_source(owner_group, source, -1); g_object_unref(source); } else { e_source_set_3e_properties_with_attrs(source, cal->name, cal->owner, account, cal->perm, cal->attrs); } } g_object_set_data(G_OBJECT(source), "synced", (gpointer)TRUE); } } g_object_set_data(G_OBJECT(group), "synced", (gpointer)TRUE); g_object_unref(account); } g_slist_free(self->priv->sync_accounts); self->priv->sync_accounts = NULL; // remove non-marked sources/groups for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter_next) { ESourceGroup *group = E_SOURCE_GROUP(iter->data); iter_next = iter->next; if (!e_source_group_is_3e(group)) { continue; } if (g_object_get_data(G_OBJECT(group), "synced")) { for (iter2 = e_source_group_peek_sources(group); iter2; iter2 = iter2_next) { ESource *source = E_SOURCE(iter2->data); iter2_next = iter2->next; if (!g_object_get_data(G_OBJECT(source), "synced")) { e_source_group_remove_source(group, source); } } } else { e_source_list_remove_group(self->priv->eslist, group); } } e_source_list_sync(self->priv->eslist, NULL); return TRUE; }
void eee_accounts_manager_activate_accounts(EeeAccountsManager *self) { GSList *iter, *iter2, *iter2_next, *iter_next; g_return_if_fail(IS_EEE_ACCOUNTS_MANAGER(self)); // for each accessible account for (iter = self->priv->access_accounts; iter; iter = iter->next) { EeeAccount *account; ESourceGroup *group; char *name = iter->data; char *group_name = g_strdup_printf("3e: %s", name); // find ESourceGroup and EeeAccount #if EVOLUTION_VERSION >= 232 group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", group_name, NULL); #else group = e_source_list_peek_group_by_name(self->priv->eslist, group_name); #endif /* EVOLUTION_VERSION >= 232 */ account = eee_accounts_manager_find_account_by_name(self, name); // create account if it does not exist if (account == NULL) { account = eee_account_new(name); eee_account_set_state(account, EEE_ACCOUNT_STATE_NOTAVAIL); eee_accounts_manager_add_account(self, account); } // create group if it does not exist if (group == NULL) { group = e_source_group_new(group_name, EEE_URI_PREFIX); e_source_list_add_group(self->priv->eslist, group, -1); g_object_unref(group); } else { // check group sources for (iter2 = e_source_group_peek_sources(group); iter2 != NULL; iter2 = iter2_next) { // we may be removing sources so ensure that we have valid next pointer iter2_next = iter2->next; ESource *source = iter2->data; if (e_source_is_3e(source)) { const char *calname = e_source_get_property(source, "eee-calname"); e_source_set_3e_properties(source, calname, account->name, account, NULL, NULL, 0); } else { // ESource without calname is useless, drop it e_source_group_remove_source(group, source); } } g_free(group_name); } g_object_set_data(G_OBJECT(group), "accessible", (gpointer)TRUE); } // for each ESourceGroup that does not represent accessible account for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter_next) { iter_next = iter->next; ESourceGroup *group = iter->data; gboolean contains_source = FALSE; // skip non-3E groups and accessible groups initialized above if (!e_source_group_is_3e(group) || g_object_get_data(G_OBJECT(group), "accessible")) { continue; } for (iter2 = e_source_group_peek_sources(group); iter2 != NULL; iter2 = iter2_next) { // we may be removing sources so ensure that we have valid next pointer iter2_next = iter2->next; ESource *source = iter2->data; // these ESources are probably for shared calendars, if we can't find // account for them, remove them if (eee_accounts_manager_find_account_by_source(self, source)) { contains_source = TRUE; } else { e_source_group_remove_source(group, source); } } if (!contains_source) { e_source_list_remove_group(self->priv->eslist, group); } } e_source_list_sync(self->priv->eslist, NULL); }
static void alarm_notify_list_changed_cb (ESourceList *source_list, AlarmNotify *an) { GSList *groups, *sources, *p, *q; ECalSourceType source_type = E_CAL_SOURCE_TYPE_LAST; ProcessRemovalsData prd; GList *l; gint i; g_signal_handlers_block_by_func ( source_list, alarm_notify_list_changed_cb, an); /* Figure out the source type */ for (i = 0; i < E_CAL_SOURCE_TYPE_LAST; i++) { if (source_list == an->priv->source_lists[i]) { source_type = i; break; } } if (source_type == E_CAL_SOURCE_TYPE_LAST) return; /* process the additions */ groups = e_source_list_peek_groups (source_list); for (p = groups; p != NULL; p = p->next) { ESourceGroup *group = E_SOURCE_GROUP (p->data); sources = e_source_group_peek_sources (group); for (q = sources; q != NULL; q = q->next) { ESource *source = E_SOURCE (q->data); gchar *uri; const gchar *completion = e_source_get_property (source, "alarm"); if (completion && (!g_ascii_strcasecmp (completion, "false") || !g_ascii_strcasecmp (completion, "never"))) continue; uri = e_source_get_uri (source); if (!g_hash_table_lookup (an->priv->uri_client_hash[source_type], uri)) { d (printf("%s:%d (list_changed_cb) - Adding Calendar %s\n", __FILE__, __LINE__, uri)); alarm_notify_add_calendar (an, source_type, source, FALSE); } g_free (uri); } } /* process the removals */ prd.an = an; prd.source_list = an->priv->source_lists[source_type]; prd.removals = NULL; g_hash_table_foreach (an->priv->uri_client_hash[source_type], (GHFunc) process_removal_in_hash, &prd); for (l = prd.removals; l; l = l->next) { d (printf("%s:%d (list_changed_cb) - Removing Calendar %s\n", __FILE__, __LINE__, (gchar *)l->data)); alarm_notify_remove_calendar (an, source_type, l->data); } g_list_free (prd.removals); g_signal_handlers_unblock_by_func ( source_list, alarm_notify_list_changed_cb, an); }
GtkWidget * plugin_google_contacts (EPlugin *epl, EConfigHookItemFactoryData *data) { EABConfigTargetSource *t = (EABConfigTargetSource *) data->target; ESource *source; ESourceGroup *group; const gchar *base_uri; const gchar *username; const gchar *refresh_interval_str; guint refresh_interval; const gchar *use_ssl_str; gchar *buff; gboolean use_ssl; GtkWidget *parent; GtkWidget *vbox; GtkWidget *section; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *spacer; GtkWidget *label; GtkWidget *username_entry; GtkWidget *interval_sb; GtkWidget *interval_combo; IntervalType type; gint time; GtkWidget *ssl_cb; struct ui_data *ui; source = t->source; group = e_source_peek_group (source); base_uri = e_source_group_peek_base_uri (group); g_object_set_data (G_OBJECT (epl), "gwidget", NULL); if (g_ascii_strncasecmp (GOOGLE_BASE_URI, base_uri, 9) != 0) return NULL; /* Build up the UI */ parent = data->parent; vbox = gtk_widget_get_ancestor ( gtk_widget_get_parent (parent), GTK_TYPE_VBOX); vbox2 = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); section = gtk_label_new (NULL); buff = g_strconcat ("<b>", _("Server"), "</b>", NULL); gtk_label_set_markup (GTK_LABEL (section), buff); g_free (buff); gtk_misc_set_alignment (GTK_MISC (section), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox2), section, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("User_name:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); username_entry = gtk_entry_new (); username = e_source_get_property (source, "username"); if (username) gtk_entry_set_text (GTK_ENTRY (username_entry), username); gtk_box_pack_start (GTK_BOX (hbox), username_entry, TRUE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); use_ssl_str = e_source_get_property (source, "use-ssl"); if (use_ssl_str && ('1' == use_ssl_str[0] || 0 == g_ascii_strcasecmp (use_ssl_str, "true"))) { use_ssl = 1; } else { use_ssl = 0; } ssl_cb = gtk_check_button_new_with_mnemonic (_("Use _secure connection")); gtk_box_pack_start (GTK_BOX (hbox), ssl_cb, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ssl_cb), use_ssl); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); spacer = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); refresh_interval_str = e_source_get_property (source, "refresh-interval"); if (refresh_interval_str && (1 == sscanf (refresh_interval_str, "%u", &refresh_interval))) { } else { refresh_interval = -1; } seconds_to_interval (refresh_interval, &type, &time); label = gtk_label_new_with_mnemonic (_("Re_fresh:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); interval_sb = gtk_spin_button_new_with_range (1, 100, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (interval_sb), time); gtk_box_pack_start (GTK_BOX (hbox), interval_sb, FALSE, FALSE, 0); interval_combo = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("minutes")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("hours")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("days")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (interval_combo), _("weeks")); gtk_combo_box_set_active (GTK_COMBO_BOX (interval_combo), type); gtk_box_pack_start (GTK_BOX (hbox), interval_combo, FALSE, FALSE, 0); gtk_widget_show_all (vbox2); g_object_set_data (G_OBJECT (interval_sb), "interval-combo", interval_combo); g_object_set_data (G_OBJECT (interval_combo), "interval-sb", interval_sb); ui = g_malloc0 (sizeof (struct ui_data)); ui->widget = vbox2; g_object_set_data_full(G_OBJECT(epl), "gwidget", ui, destroy_ui_data); g_signal_connect ( ui->widget, "destroy", G_CALLBACK (gtk_widget_destroyed), &ui->widget); g_signal_connect ( username_entry, "changed", G_CALLBACK (on_username_entry_changed), source); g_signal_connect ( interval_combo, "changed", G_CALLBACK (on_interval_combo_changed), source); g_signal_connect ( ssl_cb, "toggled", G_CALLBACK (on_ssl_cb_toggled), source); g_signal_connect ( interval_sb, "value-changed", G_CALLBACK (on_interval_sb_value_changed), source); return NULL; }
GtkWidget * plugin_couchdb_contacts (EPlugin *epl, EConfigHookItemFactoryData *data) { ESource *source; ESourceGroup *group; const gchar *base_uri; GtkWidget *parent; GtkWidget *table, *label, *parent_vbox; UIData *ui; const gchar *property; EABConfigTargetSource *t = (EABConfigTargetSource *) data->target; source = t->source; group = e_source_peek_group (source); base_uri = e_source_group_peek_base_uri (group); g_object_set_data (G_OBJECT (epl), "cwidget", NULL); if (strcmp (base_uri, COUCHDB_BASE_URI) != 0) return NULL; /* Build up the UI */ ui = g_new0 (UIData, 1); ui->source = t->source; parent = data->parent; parent_vbox = gtk_widget_get_ancestor (gtk_widget_get_parent (parent), GTK_TYPE_VBOX); ui->vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (parent_vbox), ui->vbox, FALSE, FALSE, 0); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), _("<b>Server</b>")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_box_pack_start (GTK_BOX (ui->vbox), label, FALSE, FALSE, 0); table = gtk_table_new (3, 3, FALSE); gtk_box_pack_start (GTK_BOX (ui->vbox), table, TRUE, TRUE, 0); label = gtk_label_new (" "); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); ui->user_db_button = gtk_radio_button_new_with_label (NULL, _("Desktop CouchDB")); gtk_table_attach (GTK_TABLE (table), ui->user_db_button, 1, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 3, 3); ui->system_db_button = gtk_radio_button_new_with_label ( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ui->user_db_button)), _("System-wide CouchDB")); gtk_table_attach (GTK_TABLE (table), ui->system_db_button, 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 3, 3); ui->remote_db_button = gtk_radio_button_new_with_label ( gtk_radio_button_get_group (GTK_RADIO_BUTTON (ui->user_db_button)), _("Remote CouchDB server")); gtk_table_attach (GTK_TABLE (table), ui->remote_db_button, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 3, 3); ui->remote_db_entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), ui->remote_db_entry, 2, 3, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 3, 3); gtk_widget_show_all (ui->vbox); /* Set values from the source */ property = e_source_get_property (ui->source, "couchdb_instance"); if (g_strcmp0 (property, "system") == 0) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->system_db_button), TRUE); gtk_widget_set_sensitive (ui->remote_db_entry, FALSE); } else if (g_strcmp0 (property, "remote") == 0) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->remote_db_button), TRUE); gtk_widget_set_sensitive (ui->remote_db_entry, TRUE); gtk_entry_set_text (GTK_ENTRY (ui->remote_db_entry), e_source_get_property (ui->source, "couchdb_remote_server")); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ui->user_db_button), TRUE); if (!property) e_source_set_property (ui->source, "couchdb_instance", "user"); gtk_widget_set_sensitive (ui->remote_db_entry, FALSE); } g_object_set_data_full (G_OBJECT (epl), "cwidget", ui, destroy_ui_data); g_signal_connect (ui->vbox, "destroy", G_CALLBACK (gtk_widget_destroyed), &ui->vbox); /* Signals */ g_signal_connect (G_OBJECT (ui->user_db_button), "toggled", G_CALLBACK (on_user_db_toggled), ui); g_signal_connect (G_OBJECT (ui->system_db_button), "toggled", G_CALLBACK (on_system_db_toggled), ui); g_signal_connect (G_OBJECT (ui->remote_db_button), "toggled", G_CALLBACK (on_remote_db_toggled), ui); g_signal_connect (G_OBJECT (ui->remote_db_entry), "changed", G_CALLBACK (on_remote_db_changed), ui); return NULL; }
void eee_calendar_properties_commit(EPlugin *epl, ECalConfigTargetSource *target) { ESource *source = target->source; ESourceGroup *group = e_source_peek_group(source); const char *color = e_source_peek_color_spec(source); GdkColor parsed_color; char converted_color[COLOR_COMPONENT_SIZE * 3 * 2 + 2]; //3 components, 2 hex chars in byte, 2 additional chars (# and \0) if (!gdk_color_parse(color, &parsed_color)) { g_warning("EEE: Unable to convert color \"%s\" from Evolution.", color); parsed_color.red = -1; parsed_color.green = 0; parsed_color.blue = 0; } parsed_color.red >>= (2 - COLOR_COMPONENT_SIZE) * 8; //GdkColor comonent is 2 byte integer, there are 8 bits in byte parsed_color.green >>= (2 - COLOR_COMPONENT_SIZE) * 8; parsed_color.blue >>= (2 - COLOR_COMPONENT_SIZE) * 8; snprintf(converted_color, COLOR_COMPONENT_SIZE * 3 * 2 + 2, "#%0*X%0*X%0*X", COLOR_COMPONENT_SIZE * 2, parsed_color.red, COLOR_COMPONENT_SIZE * 2, parsed_color.green, COLOR_COMPONENT_SIZE * 2, parsed_color.blue); converted_color[COLOR_COMPONENT_SIZE * 3 * 2 + 1] = '\0'; //g_debug("** EEE ** Properties Dialog Commit Hook Call:\n\n%s\n\n", e_source_to_standalone_xml(target->source)); if (!e_source_group_is_3e(group)) { return; } if (!eee_plugin_online) { return; } if (is_new_calendar_dialog(source)) { char *calname = NULL; EeeAccount *account = eee_accounts_manager_find_account_by_group(mgr(), group); if (account == NULL || account->state != EEE_ACCOUNT_STATE_ONLINE) { return; } if (eee_account_create_new_calendar(account, &calname)) { eee_account_update_calendar_settings(account, account->name, calname, e_source_peek_name(source), converted_color); } eee_account_disconnect(account); e_source_set_3e_properties(source, calname, account->name, account, "write", NULL, 0); // title and color are already set eee_accounts_manager_add_source(mgr(), account->name, g_object_ref(source)); g_free(calname); } else { EeeAccount *account = eee_accounts_manager_find_account_by_source(mgr(), source); if (account == NULL || account->state != EEE_ACCOUNT_STATE_ONLINE) { return; } const char *calname = e_source_get_property(source, "eee-calname"); const char *owner = e_source_get_property(source, "eee-owner"); eee_account_update_calendar_settings(account, owner, calname, e_source_peek_name(source), converted_color); eee_account_disconnect(account); struct acl_context * ctx = g_object_get_data (G_OBJECT (target->source), "eee-acl-context"); store_acl (ctx); acl_gui_destroy (); } eee_accounts_manager_restart_sync(mgr()); }
/* Pilot syncing callbacks */ static gint pre_sync (GnomePilotConduit *conduit, GnomePilotDBInfo *dbi, EAddrConduitContext *ctxt) { GnomePilotConduitSyncAbs *abs_conduit; EBookQuery *query; GList *l; int len; char *filename; char *change_id; char *auth; gint num_records, add_records = 0, mod_records = 0, del_records = 0; #ifdef PILOT_LINK_0_12 pi_buffer_t *buffer; #else unsigned char *buf; #endif abs_conduit = GNOME_PILOT_CONDUIT_SYNC_ABS (conduit); LOG (g_message ( "---------------------------------------------------------\n" )); LOG (g_message ( "pre_sync: Addressbook Conduit v.%s", CONDUIT_VERSION )); /* g_message ("Addressbook Conduit v.%s", CONDUIT_VERSION); */ ctxt->dbi = dbi; if (ctxt->cfg->source) { ctxt->ebook = e_book_new (ctxt->cfg->source, NULL); } else { ctxt->ebook = e_book_new_default_addressbook (NULL); } auth = (gchar *)e_source_get_property (ctxt->cfg->source, "auth"); if (auth) { LOG (g_message ("contacts needs authentication\n")); g_signal_connect (ctxt->ebook, "auth_required", G_CALLBACK (addressbook_authenticate), ctxt->cfg->source); } if (!ctxt->ebook || !e_book_open (ctxt->ebook, TRUE, NULL)) { WARN(_("Could not load addressbook")); gnome_pilot_conduit_error (conduit, _("Could not load addressbook")); return -1; } /* Load the uid <--> pilot id mappings */ filename = map_name (ctxt); e_pilot_map_read (filename, &ctxt->map); g_free (filename); /* Get a list of all contacts */ if (!(query = e_book_query_any_field_contains (""))) { LOG (g_warning ("Failed to get EBookQuery")); return -1; } if (!e_book_get_contacts (ctxt->ebook, query, &ctxt->cards, NULL)) { LOG (g_warning ("Failed to get Contacts")); e_book_query_unref (query); return -1; } e_book_query_unref (query); /* Count and hash the changes */ change_id = g_strdup_printf ("pilot-sync-evolution-addressbook-%d", ctxt->cfg->pilot_id); if (!e_book_get_changes (ctxt->ebook, change_id, &ctxt->changed, NULL)) return -1; ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal); g_free (change_id); for (l = ctxt->changed; l != NULL; l = l->next) { EBookChange *ebc = l->data; const char *uid; uid = e_contact_get_const (ebc->contact, E_CONTACT_UID); if (!e_pilot_map_uid_is_archived (ctxt->map, uid)) { g_hash_table_insert (ctxt->changed_hash, g_strdup (uid), ebc); switch (ebc->change_type) { case E_BOOK_CHANGE_CARD_ADDED: add_records++; break; case E_BOOK_CHANGE_CARD_MODIFIED: mod_records++; break; case E_BOOK_CHANGE_CARD_DELETED: del_records++; break; } } else if (ebc->change_type == E_BOOK_CHANGE_CARD_DELETED) { e_pilot_map_remove_by_uid (ctxt->map, uid); } } /* Set the count information */ num_records = g_list_length (ctxt->cards); gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records); gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records); gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records); gnome_pilot_conduit_sync_abs_set_num_deleted_local_records(abs_conduit, del_records); #ifdef PILOT_LINK_0_12 buffer = pi_buffer_new(DLP_BUF_SIZE); if(buffer == NULL){ return pi_set_error(dbi->pilot_socket, PI_ERR_GENERIC_MEMORY); } len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0, DLP_BUF_SIZE, buffer); #else buf = (unsigned char*)g_malloc (0xffff); len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0, (unsigned char *)buf, 0xffff); #endif if (len < 0) { WARN (_("Could not read pilot's Address application block")); WARN ("dlp_ReadAppBlock(...) = %d", len); gnome_pilot_conduit_error (conduit, _("Could not read pilot's Address application block")); return -1; } #ifdef PILOT_LINK_0_12 unpack_AddressAppInfo (&(ctxt->ai), buffer->data, len); pi_buffer_free (buffer); #else unpack_AddressAppInfo (&(ctxt->ai), buf, len); g_free (buf); #endif check_for_slow_setting (conduit, ctxt); if (ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyToPilot || ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyFromPilot) ctxt->map->write_touched_only = TRUE; return 0; }
/* ************************************************************************* */ static GNOME_Evolution_Addressbook_CallStatus e_book_backend_scalix_load_source (EBookBackend * backend, ESource * source, gboolean only_if_exists) { EBookBackendScalix *bs; EBookBackendScalixPrivate *priv; ScalixContainer *container; const char *prop_ssl; gchar *uri; bs = E_BOOK_BACKEND_SCALIX (backend); priv = E_BOOK_BACKEND_SCALIX_GET_PRIVATE (bs); if (priv->container != NULL) { /* Source already loaded! */ return GNOME_Evolution_Addressbook_Success; } uri = e_source_get_uri (source); if ((prop_ssl = e_source_get_property (source, "use_ssl"))) { CamelURL *url; url = camel_url_new (uri, NULL); camel_url_set_param (url, "use_ssl", prop_ssl); g_free (uri); uri = camel_url_to_string (url, 0); } container = scalix_container_open (uri); g_free (uri); if (container == NULL) { return GNOME_Evolution_Addressbook_OtherError; } e_book_backend_set_is_loaded (E_BOOK_BACKEND (backend), TRUE); e_book_backend_set_is_writable (E_BOOK_BACKEND (backend), TRUE); if (only_if_exists == FALSE) { GLOG_CAT_DEBUG (&slbook, "Only if exists == FALSE"); g_object_set (container, "only_if_exists", FALSE, "type", "Contacts", NULL); } priv->container = container; // go online here? if (priv->mode == GNOME_Evolution_Addressbook_MODE_REMOTE) { go_online (bs); } g_signal_connect (container, "object_added", G_CALLBACK (container_object_added_cb), (gpointer) backend); g_signal_connect (container, "object_removed", G_CALLBACK (container_object_removed_cb), (gpointer) backend); g_signal_connect (container, "object_changed", G_CALLBACK (container_object_changed_cb), (gpointer) backend); return GNOME_Evolution_Addressbook_Success; }
void e_sendoptions_utils_set_default_data (ESendOptionsDialog *sod, ESource *source, char * type) { ESendOptionsGeneral *gopts = NULL; ESendOptionsStatusTracking *sopts; GConfClient *gconf = gconf_client_get_default (); ESourceList *source_list; const char *uid; const char *value; gopts = sod->data->gopts; sopts = sod->data->sopts; if (!strcmp (type, "calendar")) source_list = e_source_list_new_for_gconf (gconf, "/apps/evolution/calendar/sources"); else source_list = e_source_list_new_for_gconf (gconf, "/apps/evolution/tasks/sources"); uid = e_source_peek_uid (source); source = e_source_list_peek_source_by_uid (source_list, uid); /* priority */ value = e_source_get_property (source, "priority"); if (value) { if (!strcmp (value, "high")) gopts->priority = E_PRIORITY_HIGH; else if (!strcmp (value, "standard")) gopts->priority = E_PRIORITY_STANDARD; else if (!strcmp (value, "low")) gopts->priority = E_PRIORITY_LOW; else gopts->priority = E_PRIORITY_UNDEFINED; } /* Reply requested */ value = e_source_get_property (source, "reply-requested"); if (value) { if (!strcmp (value, "none")) gopts->reply_enabled = FALSE; else if (!strcmp (value, "convinient")) { gopts->reply_enabled = TRUE; gopts->reply_convenient = TRUE; } else { gint i = atoi (value); gopts->reply_within = i; } } /* Delay delivery */ value = e_source_get_property (source, "delay-delivery"); if (value) { if (!strcmp (value, "none")) gopts->delay_enabled = FALSE; else { gopts->delay_enabled = TRUE; gopts->delay_until = icaltime_as_timet (icaltime_from_string (value)); } } /* Expiration Date */ value = e_source_get_property (source, "expiration"); if (value) { if (!strcmp (value, "none")) gopts->expiration_enabled = FALSE; else { gint i = atoi (value); if (i == 0) gopts->expiration_enabled = FALSE; else gopts->expiration_enabled = TRUE; gopts->expire_after = i; } } /* status tracking */ value = e_source_get_property (source, "status-tracking"); if (value) { if (!strcmp (value, "none")) sopts->tracking_enabled = FALSE; else { sopts->tracking_enabled = TRUE; if (!strcmp (value, "delivered")) sopts->track_when = E_DELIVERED; else if (!strcmp (value, "delivered-opened")) sopts->track_when = E_DELIVERED_OPENED; else sopts->track_when = E_ALL; } } /* Return Notifications */ value = e_source_get_property (source, "return-open"); if (value) { if (!strcmp (value, "none")) sopts->opened = E_RETURN_NOTIFY_NONE; else sopts->opened = E_RETURN_NOTIFY_MAIL; } value = e_source_get_property (source, "return-accept"); if (value) { if (!strcmp (value, "none")) sopts->accepted = E_RETURN_NOTIFY_NONE; else sopts->accepted = E_RETURN_NOTIFY_MAIL; } value = e_source_get_property (source, "return-decline"); if (value) { if (!strcmp (value, "none")) sopts->declined = E_RETURN_NOTIFY_NONE; else sopts->declined = E_RETURN_NOTIFY_MAIL; } value = e_source_get_property (source, "return-complete"); if (value) { if (!strcmp (value, "none")) sopts->completed = E_RETURN_NOTIFY_NONE; else sopts->completed = E_RETURN_NOTIFY_MAIL; } g_object_unref (gconf); }