1 /* modest-identity-mgr.c */
3 /* insert (c)/licensing information) */
6 #include "modest-identity-mgr.h"
8 /* 'private'/'protected' functions */
9 static void modest_identity_mgr_class_init (ModestIdentityMgrClass * klass);
10 static void modest_identity_mgr_init (ModestIdentityMgr * obj);
11 static void modest_identity_mgr_finalize (GObject * obj);
13 static gchar *get_identity_keyname (const gchar * accname,
23 typedef struct _ModestIdentityMgrPrivate ModestIdentityMgrPrivate;
24 struct _ModestIdentityMgrPrivate {
25 ModestConf *modest_conf;
28 #define MODEST_IDENTITY_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
29 MODEST_TYPE_IDENTITY_MGR, \
30 ModestIdentityMgrPrivate))
32 static GObjectClass *parent_class = NULL;
34 /* uncomment the following if you have defined any signals */
35 /* static guint signals[LAST_SIGNAL] = {0}; */
38 modest_identity_mgr_get_type (void)
40 static GType my_type = 0;
43 static const GTypeInfo my_info = {
44 sizeof (ModestIdentityMgrClass),
46 NULL, /* base finalize */
47 (GClassInitFunc) modest_identity_mgr_class_init,
48 NULL, /* class finalize */
49 NULL, /* class data */
50 sizeof (ModestIdentityMgr),
52 (GInstanceInitFunc) modest_identity_mgr_init,
55 my_type = g_type_register_static (G_TYPE_OBJECT,
63 modest_identity_mgr_class_init (ModestIdentityMgrClass * klass)
65 GObjectClass *gobject_class;
67 gobject_class = (GObjectClass *) klass;
69 parent_class = g_type_class_peek_parent (klass);
70 gobject_class->finalize = modest_identity_mgr_finalize;
72 g_type_class_add_private (gobject_class,
73 sizeof (ModestIdentityMgrPrivate));
75 /* signal definitions go here, e.g.: */
76 /* signals[MY_SIGNAL_1] = */
77 /* g_signal_new ("my_signal_1",....); */
78 /* signals[MY_SIGNAL_2] = */
79 /* g_signal_new ("my_signal_2",....); */
85 modest_identity_mgr_init (ModestIdentityMgr * obj)
87 ModestIdentityMgrPrivate *priv =
88 MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
89 priv->modest_conf = NULL;
93 modest_identity_mgr_finalize (GObject * obj)
95 ModestIdentityMgr *self = MODEST_IDENTITY_MGR (obj);
96 ModestIdentityMgrPrivate *priv =
97 MODEST_IDENTITY_MGR_GET_PRIVATE (self);
99 g_object_unref (G_OBJECT (priv->modest_conf));
100 priv->modest_conf = NULL;
104 modest_identity_mgr_new (ModestConf * conf)
107 ModestIdentityMgrPrivate *priv;
109 g_return_val_if_fail (conf, NULL);
111 obj = G_OBJECT (g_object_new (MODEST_TYPE_IDENTITY_MGR, NULL));
112 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
115 * increase the ref count on the modest_conf. Normally, the
116 * ModestConf should outlive the ModestIdentityMgr though
118 g_object_ref (G_OBJECT (priv->modest_conf = conf));
124 modest_identity_mgr_remove_identity (ModestIdentityMgr * self,
125 const gchar * name, GError ** err)
127 ModestIdentityMgrPrivate *priv;
131 g_return_val_if_fail (self, FALSE);
132 g_return_val_if_fail (name, FALSE);
134 if (!modest_identity_mgr_identity_exists (self, name, err)) {
135 g_warning ("identity doest not exist");
139 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
140 key = get_identity_keyname (name, NULL);
142 retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
150 null_means_empty (const gchar * str)
152 return str ? str : "";
157 modest_identity_mgr_add_identity (ModestIdentityMgr * self,
160 const gchar * replyto,
161 const gchar * signature,
162 const gboolean use_signature,
163 const gchar * id_via,
164 const gboolean use_id_via)
166 ModestIdentityMgrPrivate *priv;
169 g_return_val_if_fail (self, FALSE);
170 g_return_val_if_fail (name, FALSE);
172 /* TODO: check already exists */
174 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
175 id_key = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/", name, NULL);
177 if (modest_conf_key_exists (priv->modest_conf, id_key, NULL)) {
178 g_warning ("identity %s already exists", name);
184 key = g_strconcat (id_key, "/", MODEST_IDENTITY_EMAIL, NULL);
185 modest_conf_set_string (priv->modest_conf, key,
186 null_means_empty (email), NULL);
190 key = g_strconcat (id_key, "/", MODEST_IDENTITY_REPLYTO, NULL);
191 modest_conf_set_string (priv->modest_conf, key,
192 null_means_empty (replyto), NULL);
196 key = g_strconcat (id_key, "/", MODEST_IDENTITY_SIGNATURE, NULL);
197 modest_conf_set_string (priv->modest_conf, key,
198 null_means_empty (signature), NULL);
202 key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_SIGNATURE, NULL);
203 modest_conf_set_bool (priv->modest_conf, key, use_signature, NULL);
207 key = g_strconcat (id_key, "/", MODEST_IDENTITY_ID_VIA, NULL);
208 modest_conf_set_string (priv->modest_conf, key,
209 null_means_empty (id_via), NULL);
213 key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_ID_VIA, NULL);
214 modest_conf_set_bool (priv->modest_conf, key, use_id_via, NULL);
218 return TRUE; /* FIXME: better error checking */
221 /* strip the first /n/ character from each element */
222 /* caller must make sure all elements are strings with
223 * length >= n, and also that data can be freed.
225 /* this function is copied from modest-account-mgr. Maybe it should be moved
226 * to modest-list-utils or the like...
229 strip_prefix_from_elements (GSList * lst, guint n)
231 GSList *cursor = lst;
234 gchar *str = (gchar *) cursor->data;
236 cursor->data = g_strdup (str + n);
238 cursor = cursor->next;
244 modest_identity_mgr_identity_names (ModestIdentityMgr * self, GError ** err)
247 ModestIdentityMgrPrivate *priv;
248 const size_t prefix_len = strlen (MODEST_IDENTITY_NAMESPACE "/");
251 g_return_val_if_fail (self, NULL);
253 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
255 identities = modest_conf_list_subkeys (priv->modest_conf,
256 MODEST_IDENTITY_NAMESPACE,
258 return strip_prefix_from_elements (identities, prefix_len);
263 modest_identity_mgr_get_identity_string (ModestIdentityMgr * self,
265 const gchar * key, GError ** err)
267 ModestIdentityMgrPrivate *priv;
272 g_return_val_if_fail (self, NULL);
273 g_return_val_if_fail (name, NULL);
274 g_return_val_if_fail (key, NULL);
276 keyname = get_identity_keyname (name, key);
278 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
279 retval = modest_conf_get_string (priv->modest_conf, keyname, err);
287 modest_identity_mgr_get_identity_int (ModestIdentityMgr * self,
288 const gchar * name, const gchar * key,
291 ModestIdentityMgrPrivate *priv;
296 g_return_val_if_fail (self, -1);
297 g_return_val_if_fail (name, -1);
298 g_return_val_if_fail (key, -1);
300 keyname = get_identity_keyname (name, key);
301 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
302 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
311 modest_identity_mgr_get_identity_bool (ModestIdentityMgr * self,
312 const gchar * name, const gchar * key,
315 ModestIdentityMgrPrivate *priv;
320 g_return_val_if_fail (self, -1);
321 g_return_val_if_fail (name, -1);
322 g_return_val_if_fail (key, -1);
324 keyname = get_identity_keyname (name, key);
326 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
327 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
335 modest_identity_mgr_set_identity_string (ModestIdentityMgr * self,
337 const gchar * key, const gchar * val,
340 ModestIdentityMgrPrivate *priv;
345 g_return_val_if_fail (self, FALSE);
346 g_return_val_if_fail (name, FALSE);
347 g_return_val_if_fail (key, FALSE);
349 keyname = get_identity_keyname (name, key);
351 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
353 retval = modest_conf_set_string (priv->modest_conf, keyname, val,
362 modest_identity_mgr_set_identity_int (ModestIdentityMgr * self,
363 const gchar * name, const gchar * key,
364 const gint val, GError ** err)
366 ModestIdentityMgrPrivate *priv;
371 g_return_val_if_fail (self, FALSE);
372 g_return_val_if_fail (name, FALSE);
373 g_return_val_if_fail (key, FALSE);
375 keyname = get_identity_keyname (name, key);
377 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
379 retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
387 modest_identy_mgr_set_identity_bool (ModestIdentityMgr * self,
388 const gchar * name, const gchar * key,
389 gboolean val, GError ** err)
391 ModestIdentityMgrPrivate *priv;
396 g_return_val_if_fail (self, FALSE);
397 g_return_val_if_fail (name, FALSE);
398 g_return_val_if_fail (key, FALSE);
400 keyname = get_identity_keyname (name, key);
402 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
404 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
412 modest_identity_mgr_identity_exists (ModestIdentityMgr * self,
413 const gchar * name, GError ** err)
415 ModestIdentityMgrPrivate *priv;
420 g_return_val_if_fail (self, FALSE);
421 g_return_val_if_fail (name, FALSE);
423 keyname = get_identity_keyname (name, NULL);
425 priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
426 retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
433 /* must be freed by caller */
435 get_identity_keyname (const gchar * idname, const gchar * name)
439 (MODEST_IDENTITY_NAMESPACE, "/",
440 idname, "/", name, NULL);
443 (MODEST_IDENTITY_NAMESPACE, "/", idname, NULL);