1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 /* modest-identity-mgr.c */
34 #include "modest-marshal.h"
35 #include "modest-identity-mgr.h"
37 /* 'private'/'protected' functions */
38 static void modest_identity_mgr_class_init (ModestIdentityMgrClass * klass);
39 static void modest_identity_mgr_init (ModestIdentityMgr * obj);
40 static void modest_identity_mgr_finalize (GObject * obj);
42 static gchar *get_identity_keyname (const gchar * accname,
47 IDENTITY_CHANGE_SIGNAL,
48 IDENTITY_REMOVE_SIGNAL,
53 typedef struct _ModestIdentityMgrPrivate ModestIdentityMgrPrivate;
54 struct _ModestIdentityMgrPrivate {
55 ModestConf *modest_conf;
56 GSList *current_identities;
59 #define MODEST_IDENTITY_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
60 MODEST_TYPE_IDENTITY_MGR, \
61 ModestIdentityMgrPrivate))
63 static GObjectClass *parent_class = NULL;
65 /* uncomment the following if you have defined any signals */
66 static guint signals[LAST_SIGNAL] = {0};
70 delete_account_from_list (GSList *list, const gchar *name)
72 GSList *iter, *result;
77 if (!strcmp (name, iter->data)) {
78 result = g_slist_delete_link (list, iter);
82 iter = g_slist_next (iter);
88 find_account_in_list (GSList *list, const gchar *name)
90 GSList *iter, *result;
95 if (!strcmp (name, iter->data)) {
100 iter = g_slist_next (iter);
107 modest_identity_mgr_check_change (ModestConf *conf,
109 const gchar *new_value,
112 ModestIdentityMgr *id_mgr = userdata;
113 ModestIdentityMgrPrivate *priv = MODEST_IDENTITY_MGR_GET_PRIVATE(id_mgr);
117 if ((strlen(key) > strlen(MODEST_IDENTITY_NAMESPACE "/")
118 && g_str_has_prefix(key, MODEST_IDENTITY_NAMESPACE))) {
119 subkey = g_strdup(key + strlen(MODEST_IDENTITY_NAMESPACE "/"));
120 if (! strstr(subkey, "/")) { /* no more '/' means an entry was modified */
122 priv->current_identities =
123 delete_account_from_list (priv->current_identities, subkey);
124 g_signal_emit(id_mgr, signals[IDENTITY_REMOVE_SIGNAL], 0, subkey);
128 param = strstr(subkey, "/");
132 if (!find_account_in_list(priv->current_identities, subkey)) {
133 priv->current_identities =
134 g_slist_prepend(priv->current_identities, g_strdup(subkey));
135 g_signal_emit(id_mgr, signals[IDENTITY_ADD_SIGNAL], 0, subkey);
137 g_signal_emit(id_mgr, signals[IDENTITY_CHANGE_SIGNAL], 0, subkey, param, new_value);
144 modest_identity_mgr_get_type (void)
146 static GType my_type = 0;
149 static const GTypeInfo my_info = {
150 sizeof (ModestIdentityMgrClass),
151 NULL, /* base init */
152 NULL, /* base finalize */
153 (GClassInitFunc) modest_identity_mgr_class_init,
154 NULL, /* class finalize */
155 NULL, /* class data */
156 sizeof (ModestIdentityMgr),
158 (GInstanceInitFunc) modest_identity_mgr_init,
161 my_type = g_type_register_static (G_TYPE_OBJECT,
169 modest_identity_mgr_class_init (ModestIdentityMgrClass * klass)
171 GObjectClass *gobject_class;
172 GType paramtypes[3] = {G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER};
174 gobject_class = (GObjectClass *) klass;
176 parent_class = g_type_class_peek_parent (klass);
177 gobject_class->finalize = modest_identity_mgr_finalize;
179 g_type_class_add_private (gobject_class,
180 sizeof (ModestIdentityMgrPrivate));
182 /* signal definitions */
183 signals[IDENTITY_ADD_SIGNAL] =
184 g_signal_newv ("identity-add",
185 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
187 g_cclosure_marshal_VOID__POINTER,
188 G_TYPE_NONE, 1, paramtypes);
190 signals[IDENTITY_REMOVE_SIGNAL] =
191 g_signal_newv ("identity-remove",
192 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
194 g_cclosure_marshal_VOID__POINTER,
195 G_TYPE_NONE, 1, paramtypes);
196 signals[IDENTITY_CHANGE_SIGNAL] =
197 g_signal_newv ("identity-change",
198 G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
200 modest_marshal_VOID__POINTER_POINTER_POINTER,
201 G_TYPE_NONE, 3, paramtypes);
206 modest_identity_mgr_init (ModestIdentityMgr * obj)
208 ModestIdentityMgrPrivate *priv =
209 MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
210 priv->modest_conf = NULL;
214 modest_identity_mgr_finalize (GObject * obj)
216 ModestIdentityMgr *self = MODEST_IDENTITY_MGR (obj);
217 ModestIdentityMgrPrivate *priv =
218 MODEST_IDENTITY_MGR_GET_PRIVATE (self);
220 g_object_unref (G_OBJECT (priv->modest_conf));
221 priv->modest_conf = NULL;
225 modest_identity_mgr_new (ModestConf * conf)
228 ModestIdentityMgrPrivate *priv;
230 g_return_val_if_fail (conf, NULL);
232 obj = G_OBJECT (g_object_new (MODEST_TYPE_IDENTITY_MGR, NULL));
233 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
236 * increase the ref count on the modest_conf. Normally, the
237 * ModestConf should outlive the ModestIdentityMgr though
239 g_object_ref (G_OBJECT (priv->modest_conf = conf));
241 priv->current_identities = modest_identity_mgr_identity_names (MODEST_IDENTITY_MGR(obj), NULL);
243 g_signal_connect(G_OBJECT(conf),
245 G_CALLBACK (modest_identity_mgr_check_change),
252 modest_identity_mgr_remove_identity (ModestIdentityMgr * self,
253 const gchar * name, GError ** err)
255 ModestIdentityMgrPrivate *priv;
259 g_return_val_if_fail (self, FALSE);
260 g_return_val_if_fail (name, FALSE);
262 if (!modest_identity_mgr_identity_exists (self, name, err)) {
263 g_warning ("identity doest not exist");
267 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
268 key = get_identity_keyname (name, NULL);
270 retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
278 null_means_empty (const gchar * str)
280 return str ? str : "";
285 modest_identity_mgr_add_identity (ModestIdentityMgr * self,
287 const gchar * realname,
289 const gchar * replyto,
290 const gchar * signature,
291 const gboolean use_signature,
292 const gchar * id_via,
293 const gboolean use_id_via)
295 ModestIdentityMgrPrivate *priv;
298 g_return_val_if_fail (self, FALSE);
299 g_return_val_if_fail (name, FALSE);
301 /* TODO: check already exists */
303 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
304 id_key = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/", name, NULL);
306 if (modest_conf_key_exists (priv->modest_conf, id_key, NULL)) {
307 g_warning ("identity %s already exists", name);
313 key = g_strconcat (id_key, "/", MODEST_IDENTITY_REALNAME, NULL);
314 modest_conf_set_string (priv->modest_conf, key,
315 null_means_empty (realname), NULL);
319 key = g_strconcat (id_key, "/", MODEST_IDENTITY_EMAIL, NULL);
320 modest_conf_set_string (priv->modest_conf, key,
321 null_means_empty (email), NULL);
325 key = g_strconcat (id_key, "/", MODEST_IDENTITY_REPLYTO, NULL);
326 modest_conf_set_string (priv->modest_conf, key,
327 null_means_empty (replyto), NULL);
331 key = g_strconcat (id_key, "/", MODEST_IDENTITY_SIGNATURE, NULL);
332 modest_conf_set_string (priv->modest_conf, key,
333 null_means_empty (signature), NULL);
337 key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_SIGNATURE, NULL);
338 modest_conf_set_bool (priv->modest_conf, key, use_signature, NULL);
342 key = g_strconcat (id_key, "/", MODEST_IDENTITY_ID_VIA, NULL);
343 modest_conf_set_string (priv->modest_conf, key,
344 null_means_empty (id_via), NULL);
348 key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_ID_VIA, NULL);
349 modest_conf_set_bool (priv->modest_conf, key, use_id_via, NULL);
354 return TRUE; /* FIXME: better error checking */
357 /* strip the first /n/ character from each element */
358 /* caller must make sure all elements are strings with
359 * length >= n, and also that data can be freed.
361 /* this function is copied from modest-account-mgr. Maybe it should be moved
362 * to modest-list-utils or the like...
365 strip_prefix_from_elements (GSList * lst, guint n)
367 GSList *cursor = lst;
370 gchar *str = (gchar *) cursor->data;
372 cursor->data = g_strdup (str + n);
374 cursor = cursor->next;
380 modest_identity_mgr_identity_names (ModestIdentityMgr * self, GError ** err)
383 ModestIdentityMgrPrivate *priv;
384 const size_t prefix_len = strlen (MODEST_IDENTITY_NAMESPACE "/");
387 g_return_val_if_fail (self, NULL);
389 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
391 identities = modest_conf_list_subkeys (priv->modest_conf,
392 MODEST_IDENTITY_NAMESPACE,
394 return strip_prefix_from_elements (identities, prefix_len);
399 modest_identity_mgr_get_identity_string (ModestIdentityMgr * self,
401 const gchar * key, GError ** err)
403 ModestIdentityMgrPrivate *priv;
408 g_return_val_if_fail (self, NULL);
409 g_return_val_if_fail (name, NULL);
410 g_return_val_if_fail (key, NULL);
412 keyname = get_identity_keyname (name, key);
414 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
415 retval = modest_conf_get_string (priv->modest_conf, keyname, err);
423 modest_identity_mgr_get_identity_int (ModestIdentityMgr * self,
424 const gchar * name, const gchar * key,
427 ModestIdentityMgrPrivate *priv;
432 g_return_val_if_fail (self, -1);
433 g_return_val_if_fail (name, -1);
434 g_return_val_if_fail (key, -1);
436 keyname = get_identity_keyname (name, key);
437 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
438 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
447 modest_identity_mgr_get_identity_bool (ModestIdentityMgr * self,
448 const gchar * name, const gchar * key,
451 ModestIdentityMgrPrivate *priv;
456 g_return_val_if_fail (self, FALSE);
457 g_return_val_if_fail (name, FALSE);
458 g_return_val_if_fail (key, FALSE);
460 keyname = get_identity_keyname (name, key);
462 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
463 retval = modest_conf_get_bool (priv->modest_conf, keyname, err);
471 modest_identity_mgr_set_identity_string (ModestIdentityMgr * self,
473 const gchar * key, const gchar * val,
476 ModestIdentityMgrPrivate *priv;
481 g_return_val_if_fail (self, FALSE);
482 g_return_val_if_fail (name, FALSE);
483 g_return_val_if_fail (key, FALSE);
485 keyname = get_identity_keyname (name, key);
487 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
489 retval = modest_conf_set_string (priv->modest_conf, keyname, val,
498 modest_identity_mgr_set_identity_int (ModestIdentityMgr * self,
499 const gchar * name, const gchar * key,
500 const gint val, GError ** err)
502 ModestIdentityMgrPrivate *priv;
507 g_return_val_if_fail (self, FALSE);
508 g_return_val_if_fail (name, FALSE);
509 g_return_val_if_fail (key, FALSE);
511 keyname = get_identity_keyname (name, key);
513 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
515 retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
523 modest_identity_mgr_set_identity_bool (ModestIdentityMgr * self,
524 const gchar * name, const gchar * key,
525 gboolean val, GError ** err)
527 ModestIdentityMgrPrivate *priv;
532 g_return_val_if_fail (self, FALSE);
533 g_return_val_if_fail (name, FALSE);
534 g_return_val_if_fail (key, FALSE);
536 keyname = get_identity_keyname (name, key);
538 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
540 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
548 modest_identity_mgr_identity_exists (ModestIdentityMgr * self,
549 const gchar * name, GError ** err)
551 ModestIdentityMgrPrivate *priv;
556 g_return_val_if_fail (self, FALSE);
557 g_return_val_if_fail (name, FALSE);
559 keyname = get_identity_keyname (name, NULL);
561 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
562 retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
569 /* must be freed by caller */
571 get_identity_keyname (const gchar * idname, const gchar * name)
575 (MODEST_IDENTITY_NAMESPACE, "/",
576 idname, "/", name, NULL);
579 (MODEST_IDENTITY_NAMESPACE, "/", idname, NULL);