/** 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);
}
