1 /*
2 * RAL -- Rubrica Addressbook Library
3 * file: groups.c
4 *
5 * Copyright (C) Nicola Fragale <nicolafragale@libero.it>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21 #include <time.h>
22 #include <glib.h>
23 #include <glib-object.h>
24
25 #include "group.h"
26 #include "utils.h"
27
28
29 enum {
30 PROP_0,
31 GROUP_ID,
32 GROUP_NAME,
33 GROUP_LABEL,
34 GROUP_OWNER,
35 GROUP_PIXMAP,
36 GROUP_ENABLED
37 };
38
39
40 static gint id = 0;
41
42 struct _RGroupPrivate {
43 gint id;
44
45 gchar* name;
46 gchar* label;
47 gchar* owner;
48 gchar* pixmap;
49 gboolean enabled;
50
51 gboolean dispose_has_run;
52 };
53
54
55 #define R_GROUP_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
56 R_GROUP_TYPE, RGroupPrivate))
57
58
59 static void r_group_class_init (RGroupClass* klass);
60 static void r_group_init (RGroup* obj);
61
62 static void r_group_dispose (RGroup* obj);
63 static void r_group_finalize (RGroup* obj);
64
65
66 static void r_group_set_property (GObject* obj, guint property_id,
67 const GValue* value, GParamSpec* spec);
68 static void r_group_get_property (GObject* obj, guint property_id,
69 GValue* value, GParamSpec* spec);
70
71
72 GType
r_group_get_type()73 r_group_get_type()
74 {
75 static GType group_type = 0;
76
77 if (!group_type)
78 {
79 static const GTypeInfo group_info =
80 {
81 sizeof(RGroupClass),
82 NULL,
83 NULL,
84 (GClassInitFunc) r_group_class_init,
85 NULL,
86 NULL,
87 sizeof(RGroup),
88 0,
89 (GInstanceInitFunc) r_group_init
90 };
91
92 group_type = g_type_register_static (G_TYPE_OBJECT, "RGroup",
93 &group_info, 0);
94 }
95
96 return group_type;
97 }
98
99
100 static void
r_group_class_init(RGroupClass * klass)101 r_group_class_init(RGroupClass* klass)
102 {
103 GObjectClass *class;
104 GParamSpec* pspec;
105
106 class = G_OBJECT_CLASS (klass);
107 class->dispose = (GObjectFinalizeFunc) r_group_dispose;
108 class->finalize = (GObjectFinalizeFunc) r_group_finalize;
109
110 class->set_property = r_group_set_property;
111 class->get_property = r_group_get_property;
112
113 g_type_class_add_private (klass, sizeof(RGroupPrivate));
114
115 /* class property
116 */
117 pspec = g_param_spec_int("id",
118 "group's id",
119 "the id of the groups",
120 G_MININT,
121 G_MAXINT,
122 0,
123 G_PARAM_READABLE);
124 g_object_class_install_property(class, GROUP_ID, pspec);
125
126 /**
127 * RGroup:group-name
128 *
129 * the name of the group
130 */
131 pspec = g_param_spec_string("group-name",
132 "group name",
133 "the name of the group",
134 NULL,
135 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
136 g_object_class_install_property(class, GROUP_NAME, pspec);
137
138
139 /**
140 * RGroup:group-label
141 *
142 * the name of the group
143 */
144 pspec = g_param_spec_string("group-label",
145 "group label",
146 "the label of the group",
147 NULL,
148 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
149 g_object_class_install_property(class, GROUP_LABEL, pspec);
150
151
152 /**
153 * RGroup:group-owner
154 *
155 * the owner (creator) of the group. It can have two values:
156 * "r" for the default groups, and "user" for the
157 * user's defined groups
158 */
159 pspec = g_param_spec_string("group-owner",
160 "group's owner",
161 "the owner of the group. It can get "
162 "two values: \"rubrica\", if the owner of "
163 "the group is rubrica, \"user\" if the "
164 "group's owner is defined by user",
165 "rubrica", /* default */
166 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
167 g_object_class_install_property(class, GROUP_OWNER, pspec);
168
169 /**
170 * RGroup:group-pixmap
171 *
172 * a pixmap for the group
173 */
174 pspec = g_param_spec_string("group-pixmap",
175 "group's pixmap",
176 "the path or uri to the pixmap that will be"
177 "shown near group's name",
178 NULL,
179 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
180 g_object_class_install_property(class, GROUP_PIXMAP, pspec);
181
182 /**
183 * RGroup:enabled
184 *
185 * enabled/disabled
186 */
187 pspec = g_param_spec_boolean("enabled",
188 "enabled flag",
189 "check if group is enabled",
190 0,
191 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
192 g_object_class_install_property(class, GROUP_ENABLED, pspec);
193 }
194
195
196 static void
r_group_init(RGroup * self)197 r_group_init(RGroup* self)
198 {
199 self->priv = R_GROUP_GET_PRIVATE(self);
200
201 self->priv->id = 0;
202 self->priv->name = NULL;
203 self->priv->label = NULL;
204 self->priv->owner = NULL;
205 self->priv->pixmap = NULL;
206 self->priv->enabled = FALSE;
207
208 self->priv->dispose_has_run = FALSE;
209 }
210
211
212
213 static void
r_group_dispose(RGroup * self)214 r_group_dispose (RGroup* self)
215 {
216 g_return_if_fail(IS_R_GROUP(self));
217
218 if (self->priv->dispose_has_run)
219 return;
220
221 g_free(self->priv->name);
222 g_free(self->priv->label);
223 g_free(self->priv->owner);
224 g_free(self->priv->pixmap);
225
226 self->priv->dispose_has_run = TRUE;
227 }
228
229
230 static void
r_group_finalize(RGroup * self)231 r_group_finalize (RGroup* self)
232 {
233 g_return_if_fail(IS_R_GROUP(self));
234 }
235
236
237
238 static void
r_group_set_property(GObject * obj,guint property_id,const GValue * value,GParamSpec * spec)239 r_group_set_property (GObject* obj, guint property_id,
240 const GValue* value, GParamSpec* spec)
241 {
242 RGroup* self = (RGroup*) obj;
243
244 switch (property_id)
245 {
246 case GROUP_ID:
247 break;
248
249 case GROUP_NAME:
250 g_free(self->priv->name);
251 self->priv->name = g_value_dup_string(value);
252 break;
253
254 case GROUP_LABEL:
255 g_free(self->priv->label);
256 self->priv->label = g_value_dup_string(value);
257 break;
258
259 case GROUP_OWNER:
260 g_free(self->priv->owner);
261 self->priv->owner = g_value_dup_string(value);
262 break;
263
264 case GROUP_PIXMAP:
265 g_free(self->priv->pixmap);
266 self->priv->pixmap = g_value_dup_string(value);
267 break;
268
269 case GROUP_ENABLED:
270 self->priv->enabled = g_value_get_boolean(value);
271 break;
272
273 default:
274 break;
275 }
276 }
277
278
279 static void
r_group_get_property(GObject * obj,guint property_id,GValue * value,GParamSpec * spec)280 r_group_get_property (GObject* obj, guint property_id,
281 GValue* value, GParamSpec* spec)
282 {
283 RGroup* self = (RGroup*) obj;
284
285 switch (property_id)
286 {
287 case GROUP_ID:
288 g_value_set_int(value, self->priv->id);
289 break;
290
291 case GROUP_NAME:
292 g_value_set_string(value, self->priv->name);
293 break;
294
295 case GROUP_LABEL:
296 g_value_set_string(value, self->priv->label);
297 break;
298
299 case GROUP_OWNER:
300 g_value_set_string(value, self->priv->owner);
301 break;
302
303 case GROUP_PIXMAP:
304 g_value_set_string(value, self->priv->pixmap);
305 break;
306
307 case GROUP_ENABLED:
308 g_value_set_boolean(value, self->priv->enabled);
309 break;
310
311 default:
312 break;
313 }
314 }
315
316
317
318 /* ************************************* Public
319 */
320
321 /**
322 * r_group_new
323 *
324 * create a new #RGroup
325 *
326 * returns: a RGroup*
327 */
328 RGroup*
r_group_new(void)329 r_group_new(void)
330 {
331 RGroup* group;
332
333 group = g_object_new(r_group_get_type(), NULL);
334
335 group->priv->id = ++id;
336
337 return group;
338 }
339
340
341 /**
342 * r_group_free
343 * @group: a #RGroup
344 *
345 * free memory
346 */
347 void
r_group_free(RGroup * group)348 r_group_free(RGroup* group)
349 {
350 g_return_if_fail(IS_R_GROUP(group));
351
352 g_object_unref(group);
353 }
354
355
356 /**
357 * r_group_copy
358 * @group: a #RGroup
359 *
360 * copy the given group
361 *
362 * returns: a new allocated RGroup*
363 */
364 RGroup*
r_group_copy(RGroup * group)365 r_group_copy (RGroup* group)
366 {
367 RGroup* new;
368 gchar *name, *label, *owner, *pixmap;
369 gboolean enabled;
370
371 g_return_val_if_fail(IS_R_GROUP(group), NULL);
372
373 new = r_group_new();
374
375 g_object_get(G_OBJECT(group), "group-name", &name, "group-label", &label,
376 "group-owner", &owner, "group-pixmap", &pixmap,
377 "enabled", &enabled, NULL);
378
379 g_object_set(G_OBJECT(new), "group-name", name, "group-label", label,
380 "group-owner", owner, "group-pixmap", pixmap,
381 "enabled", enabled, NULL);
382
383
384 return new;
385 }
386
387
388 /**
389 * r_group_rename
390 * @group: a #RGroup
391 * @newname: a gchar
392 *
393 * rename the given group.
394 *
395 * returns: a gboolean. %TRUE if group has been renamed, %FALSE otherwise.
396 */
397 gboolean
r_group_rename(RGroup * group,gchar * newname)398 r_group_rename (RGroup* group, gchar* newname)
399 {
400 g_return_val_if_fail(IS_R_GROUP(group), FALSE);
401 g_return_val_if_fail(newname != NULL, FALSE);
402
403 g_object_set(group, "group-name", newname, NULL);
404
405 return TRUE;
406 }
407
408
409 /**
410 * r_group_change_pixmap
411 * @group: a #RGroup
412 * @newpix: a gchar*
413 *
414 * replace the pixmap's path with the new one
415 *
416 * returns: a gboolean. %TRUE if pixmap's path has been changed,
417 * %FALSE otherwise.
418 */
419 gboolean
r_group_change_pixmap(RGroup * group,gchar * newpix)420 r_group_change_pixmap (RGroup* group, gchar* newpix)
421 {
422 g_return_val_if_fail(IS_R_GROUP(group), FALSE);
423 g_return_val_if_fail(newpix != NULL, FALSE);
424
425 g_object_set(group, "group-pixmap", newpix, NULL);
426
427 return TRUE;
428 }
429
430
431 /**
432 * r_group_is
433 * @group: a #RGroup
434 * @name: a gchar*
435 *
436 * test if the group has the given name
437 *
438 * returns: a gboolean. %TRUE if group's name and name coincide,
439 * %FALSE otherwise.
440 */
441 gboolean
r_group_has_name(RGroup * group,const gchar * name)442 r_group_has_name (RGroup* group, const gchar* name)
443 {
444 g_return_val_if_fail(IS_R_GROUP(group), FALSE);
445 g_return_val_if_fail(name != NULL, FALSE);
446
447 return (g_ascii_strcasecmp(group->priv->name, name) == 0);
448 }
449
450
451 /**
452 * r_group_has_owner
453 * @group: a #RGroup
454 * @owner: a gchar*
455 *
456 * check group's owner
457 *
458 * Returns: %TRUE if "owner" is the group's owner, %FALSE otherwise
459 */
460 gboolean
r_group_has_owner(RGroup * group,const gchar * owner)461 r_group_has_owner (RGroup* group, const gchar* owner)
462 {
463 g_return_val_if_fail(IS_R_GROUP(group), FALSE);
464 g_return_val_if_fail(owner != NULL, FALSE);
465
466 return (g_ascii_strcasecmp(group->priv->owner, owner) == 0);
467 }
468
469
470 /**
471 * r_group_check
472 * @group: a #RGroup
473 * @property: an #RGroup's property
474 * @value: the property's value (if set)
475 *
476 * check if the given property is set.
477 *
478 * returns: %FALSE if the property is %NULL, otherwise it return %TRUE and
479 * the content of the property is copied into value
480 **/
481 gboolean
r_group_check(RGroup * group,const gchar * property,gchar ** value)482 r_group_check (RGroup* group, const gchar* property, gchar** value)
483 {
484 gchar* tmp;
485
486 g_return_val_if_fail(IS_R_GROUP(group), FALSE);
487
488 g_object_get(group, property, &tmp, NULL);
489
490 if (tmp)
491 {
492 if (value)
493 *value = tmp;
494
495 return TRUE;
496 }
497
498 return FALSE;
499 }
500