?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2007-12-30 Johannes Schmid <jhs@gnome.org>
[anjuta-git-plugin.git] / libanjuta / anjuta-preferences.c
blob67cd99e37a0682a0809813b8c1803edbad304e2a
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * preferences.c
4 * Copyright (C) 2000 - 2003 Naba Kumar <naba@gnome.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * SECTION:anjuta-preferences
23 * @short_description: Anjuta Prefereces system.
24 * @see_also: #AnjutaPreferencesDialog
25 * @stability: Unstable
26 * @include: libanjuta/anjuta-preferences.h
27 *
28 * #AnjutaPreferences is a way to let plugins register their preferences. There
29 * are mainly two ways a plugin could register its preferences in Anjuta.
30 *
31 * First is to not use #AnjutaPreferences at all. Simply register a
32 * preferences page in #AnjutaPreferencesDialog using the function
33 * anjuta_preferences_dialog_add_page(). The plugin should take
34 * care of loading, saving and widgets synchronization of the
35 * preferences values. It is particularly useful if the plugin
36 * uses gconf system for its preferences. Also no "changed"
37 * signal will be emitted from it.
38 *
39 * Second is to use anjuta_preferences_add_page(), which will
40 * automatically register the preferences keys and values from
41 * a glade xml file. The glade xml file contains a preferences
42 * page of the plugin. The widget names in the page are
43 * given in a particular way (see anjuta_preferences_add_page()) to
44 * let it know property key details. Loading, saving and
45 * widget synchronization are automatically done. "changed" signal is
46 * emitted when a preference is changed.
47 *
48 * anjuta_preferences_register_all_properties_from_glade_xml() only registers
49 * the preferences propery keys for automatic loading, saving and widget
50 * syncrhronization, but does not add the page in preferences dialog. It
51 * is useful if the plugin wants to show the preferences page somewhere else.
52 *
53 * anjuta_preferences_register_property_from_string() is similar to
54 * anjuta_preferences_register_all_properties_from_glade_xml(), but it only
55 * registers one property, the detail of which is given in its arguments.
56 * anjuta_preferences_register_property_custom() is used to register a
57 * property that uses a widget which is not supported by #AnjutaPreferences.
58 */
59
60 #ifdef HAVE_CONFIG_H
61 # include <config.h>
62 #endif
63
64 #include <sys/stat.h>
65 #include <unistd.h>
66 #include <string.h>
67
68 #include <glade/glade-parser.h>
69 #include <gconf/gconf-client.h>
70
71 #include <libanjuta/anjuta-preferences.h>
72 #include <libanjuta/anjuta-utils.h>
73 #include <libanjuta/resources.h>
74 #include <libanjuta/anjuta-debug.h>
75 #include <libanjuta/interfaces/ianjuta-preferences.h>
76
77 struct _AnjutaProperty
78 {
79 GtkWidget *object;
80 gchar *key;
81 gchar *default_value;
82 guint flags;
83 gint notify_id;
84 GConfClient *gclient;
85
86 /* Set true if custom set/get to be used */
87 gboolean custom;
88
89 /* For inbuilt generic objects */
90 AnjutaPropertyObjectType object_type;
91 AnjutaPropertyDataType data_type;
92
93 /* For custom objects */
94 void (*set_property) (AnjutaProperty *prop, const gchar *value);
95 gchar * (*get_property) (AnjutaProperty *prop);
96
97 };
98
99 struct _AnjutaPreferencesPriv
100 {
101 GConfClient *gclient;
102 GHashTable *properties;
103 GtkWidget *prefs_dialog;
104 AnjutaPluginManager *plugin_manager;
105 gboolean is_showing;
106 };
107
108 /* Internal structure for anjuta_preferences_foreach */
109 struct _AnjutaPreferencesForeachData
110 {
111 AnjutaPreferences *pr;
112 AnjutaPreferencesFilterType filter;
113 AnjutaPreferencesCallback callback;
114 gpointer callback_data;
115 };
116
117 #define PREFERENCE_PROPERTY_PREFIX "preferences_"
118 #define GCONF_KEY_PREFIX "/apps/anjuta/preferences"
119
120 static const gchar *
121 build_key (const gchar *key)
122 {
123 static gchar buffer[1024];
124 snprintf (buffer, 1024, "%s/%s", GCONF_KEY_PREFIX, key);
125 return buffer;
126 }
127
128 /**
129 * anjuta_preferences_get:
130 * @pr: A #AnjutaPreferences object
131 * @key: Property key
132 *
133 * Gets the value of @key as string. Returned string should be g_freed() when not
134 * required.
135 *
136 * Return value: Key value as string or NULL if the key is not defined.
137 */
138 #ifdef __GNUC__
139 inline
140 #endif
141 gchar *
142 anjuta_preferences_get (AnjutaPreferences *pr, const gchar *key)
143 {
144 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), NULL);
145 g_return_val_if_fail (key != NULL, NULL);
146
147 return gconf_client_get_string (pr->priv->gclient, build_key (key), NULL);
148 }
149
150 /**
151 * anjuta_preferences_get_list:
152 * @pr: A #AnjutaPreferences object
153 * @key: Property key
154 * @list_type: Type of each list element
155 *
156 * Gets the list of @key.
157 *
158 * Return value: Key list or NULL if the key is not defined.
159 */
160 #ifdef __GNUC__
161 inline
162 #endif
163 GSList *
164 anjuta_preferences_get_list (AnjutaPreferences *pr, const gchar *key,
165 GConfValueType list_type)
166 {
167 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), NULL);
168 g_return_val_if_fail (key != NULL, NULL);
169
170 return gconf_client_get_list(pr->priv->gclient, build_key (key), list_type, NULL);
171 }
172
173 /**
174 * anjuta_preferences_get_pair:
175 * @pr: A #AnjutaPreferences object
176 * @key: Property key
177 * @car_type: Desired type of the pair's first field (car).
178 * @cdr_type: Desired type of the pair's second field (cdr).
179 * @car_retloc: Address of a return location for the car.
180 * @cdr_retloc: Address of a return location for the cdr.
181 *
182 * Gets the pair of @key.
183 *
184 * Return value: TRUE or FALSE.
185 */
186 #ifdef __GNUC__
187 inline
188 #endif
189 gboolean
190 anjuta_preferences_get_pair (AnjutaPreferences *pr, const gchar *key,
191 GConfValueType car_type, GConfValueType cdr_type,
192 gpointer car_retloc, gpointer cdr_retloc)
193 {
194 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), FALSE);
195 g_return_val_if_fail (key != NULL, FALSE);
196
197 return gconf_client_get_pair(pr->priv->gclient, build_key (key),
198 car_type, cdr_type,
199 car_retloc, cdr_retloc, NULL);
200 }
201
202 /**
203 * anjuta_preferences_get_int:
204 * @pr: A #AnjutaPreferences object
205 * @key: Property key
206 *
207 * Gets the value of @key as integer.
208 *
209 * Return value: Key value as integer or 0 if the key is not defined.
210 */
211 #ifdef __GNUC__
212 inline
213 #endif
214 gint
215 anjuta_preferences_get_int (AnjutaPreferences *pr, const gchar *key)
216 {
217 gint ret_val;
218 GConfValue *value;
219
220 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), 0);
221 g_return_val_if_fail (key != NULL, 0);
222
223 ret_val = 0;
224 value = gconf_client_get (pr->priv->gclient, build_key (key), NULL);
225 if (value)
226 {
227 switch (value->type)
228 {
229 case GCONF_VALUE_INT:
230 ret_val = gconf_value_get_int (value);
231 break;
232 case GCONF_VALUE_BOOL:
233 ret_val = gconf_value_get_bool (value);
234 break;
235 default:
236 g_warning ("Invalid gconf type for key: %s", key);
237 }
238 gconf_value_free (value);
239 }
240 /* else
241 g_warning ("The preference key %s is not defined", key); */
242 return ret_val;
243 }
244
245 /**
246 * anjuta_preferences_get_int_with_default:
247 * @pr: A #AnjutaPreferences object
248 * @key: Property key
249 * @default_value: Default value to return if the key is not defined.
250 *
251 * Gets the value of @key as integer.
252 *
253 * Return value: Key value as integer or @default_value if the
254 * key is not defined.
255 */
256 #ifdef __GNUC__
257 inline
258 #endif
259 gint
260 anjuta_preferences_get_int_with_default (AnjutaPreferences *pr,
261 const gchar *key, gint default_value)
262 {
263 gint ret_val;
264 GConfValue *value;
265
266 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), 0);
267 g_return_val_if_fail (key != NULL, 0);
268
269 ret_val = default_value;
270 value = gconf_client_get (pr->priv->gclient, build_key (key), NULL);
271 if (value)
272 {
273 switch (value->type)
274 {
275 case GCONF_VALUE_INT:
276 ret_val = gconf_value_get_int (value);
277 break;
278 case GCONF_VALUE_BOOL:
279 ret_val = gconf_value_get_bool (value);
280 break;
281 default:
282 g_warning ("Invalid gconf type for key: %s", key);
283 }
284 gconf_value_free (value);
285 }
286 return ret_val;
287 }
288
289 /**
290 * anjuta_preferences_default_get:
291 * @pr: A #AnjutaPreferences object
292 * @key: Property key
293 *
294 * Gets the default value of @key as string. The default value of the key
295 * is the value defined in System defaults (generally installed during
296 * program installation). Returned value must be g_freed() when not required.
297 *
298 * Return value: Default key value as string or NULL if not defined.
299 */
300 #ifdef __GNUC__
301 inline
302 #endif
303 gchar *
304 anjuta_preferences_default_get (AnjutaPreferences * pr, const gchar * key)
305 {
306 GConfValue *val;
307 gchar *str;
308 GError *err = NULL;
309
310 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), NULL);
311 g_return_val_if_fail (key != NULL, NULL);
312
313 val = gconf_client_get_default_from_schema (pr->priv->gclient, build_key (key), &err);
314 if (err) {
315 g_error_free (err);
316 return NULL;
317 }
318 str = g_strdup (gconf_value_get_string (val));
319 gconf_value_free (val);
320 return str;
321 }
322
323 /**
324 * anjuta_preferences_default_get_int:
325 * @pr: A #AnjutaPreferences object
326 * @key: Property key
327 *
328 * Gets the default value of @key as integer. The default value of the key
329 * is the value defined in System defaults (generally installed during
330 * program installation).
331 *
332 * Return value: Default key value as integer or 0 if the key is not defined.
333 */
334 #ifdef __GNUC__
335 inline
336 #endif
337 gint
338 anjuta_preferences_default_get_int (AnjutaPreferences *pr, const gchar *key)
339 {
340 GConfValue *val;
341 gint ret;
342 GError *err = NULL;
343
344 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), 0);
345 g_return_val_if_fail (key != NULL, 0);
346 val = gconf_client_get_default_from_schema (pr->priv->gclient, build_key (key), &err);
347 if (err) {
348 g_error_free (err);
349 return 0;
350 }
351 ret = gconf_value_get_int (val);
352 gconf_value_free (val);
353 return ret;
354 }
355
356 /**
357 * anjuta_preferences_set:
358 * @pr: A #AnjutaPreferences object.
359 * @key: Property key.
360 * @value: Value of the key.
361 *
362 * Sets the value of @key in current session.
363 */
364 #ifdef __GNUC__
365 inline
366 #endif
367 void
368 anjuta_preferences_set (AnjutaPreferences *pr, const gchar *key,
369 const gchar *value)
370 {
371 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
372 g_return_if_fail (key != NULL);
373
374 if (value && (strlen (value) > 0))
375 {
376 gconf_client_set_string (pr->priv->gclient, build_key (key), value, NULL);
377 }
378 else
379 {
380 gconf_client_set_string (pr->priv->gclient, build_key (key), "", NULL);
381 }
382 }
383
384 /**
385 * anjuta_preferences_set_list:
386 * @pr: A #AnjutaPreferences object.
387 * @key: Property key.
388 * @list_type: Type of each element.
389 * @list: New value of the key.
390 *
391 * Sets a list in current session.
392 */
393 #ifdef __GNUC__
394 inline
395 #endif
396 void
397 anjuta_preferences_set_list (AnjutaPreferences *pr, const gchar *key,
398 GConfValueType list_type, GSList *list)
399 {
400 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
401 g_return_if_fail (key != NULL);
402
403 gconf_client_set_list(pr->priv->gclient, build_key (key),
404 list_type, list, NULL);
405 }
406
407 /**
408 * anjuta_preferences_set_pair:
409 * @pr: A #AnjutaPreferences object.
410 * @key: Property key.
411 * @car_type: Type of the pair's first field (car).
412 * @cdr_type: Type of the pair's second field (cdr).
413 * @address_of_car: Address of the car.
414 * @address_of_cdr: Address of the cdr.
415 *
416 */
417 #ifdef __GNUC__
418 inline
419 #endif
420 gboolean
421 anjuta_preferences_set_pair (AnjutaPreferences *pr, const gchar *key,
422 GConfValueType car_type, GConfValueType cdr_type,
423 gconstpointer address_of_car,
424 gconstpointer address_of_cdr)
425 {
426 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), FALSE);
427 g_return_val_if_fail (key != NULL, FALSE);
428
429 return gconf_client_set_pair (pr->priv->gclient, build_key (key),
430 car_type, cdr_type,
431 address_of_car, address_of_cdr,
432 NULL);
433 }
434
435 /**
436 * anjuta_preferences_set_int:
437 * @pr: A #AnjutaPreferences object.
438 * @key: Property key.
439 * @value: Integer value of the key.
440 *
441 * Sets the value of @key in current session.
442 */
443 #ifdef __GNUC__
444 inline
445 #endif
446 void
447 anjuta_preferences_set_int (AnjutaPreferences *pr, const gchar *key,
448 gint value)
449 {
450 GConfValue *gvalue;
451
452 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
453 g_return_if_fail (key != NULL);
454
455 gvalue = gconf_client_get (pr->priv->gclient, build_key (key), NULL);
456 if (gvalue)
457 {
458 switch (gvalue->type)
459 {
460 case GCONF_VALUE_BOOL:
461 gconf_client_set_bool (pr->priv->gclient, build_key (key),
462 value, NULL);
463 break;
464 case GCONF_VALUE_INT:
465 gconf_client_set_int (pr->priv->gclient, build_key (key),
466 value, NULL);
467 break;
468 default:
469 g_warning ("Invalid gconf type for key: %s", key);
470 }
471 gconf_value_free (gvalue);
472 }
473 else
474 {
475 /* g_warning ("The preference key %s is not defined", key); */
476 gconf_client_set_int (pr->priv->gclient, build_key (key),
477 value, NULL);
478 }
479 }
480
481 static void
482 property_destroy (AnjutaProperty *property)
483 {
484 g_return_if_fail (property);
485 if (property->key) g_free (property->key);
486 if (property->default_value) g_free (property->default_value);
487 g_object_unref (property->object);
488 gconf_client_notify_remove (property->gclient, property->notify_id);
489 g_free (property);
490 }
491
492 /**
493 * anjuta_property_get_widget:
494 * @prop: an #AnjutaProperty reference
495 *
496 * Gets the widget associated with the property.
497 *
498 * Returns: a #GtkWidget object associated with the property.
499 */
500 GtkWidget*
501 anjuta_property_get_widget (AnjutaProperty *prop)
502 {
503 return prop->object;
504 }
505
506 static AnjutaPropertyObjectType
507 get_object_type_from_string (const gchar* object_type)
508 {
509 if (strcmp (object_type, "entry") == 0)
510 return ANJUTA_PROPERTY_OBJECT_TYPE_ENTRY;
511 else if (strcmp (object_type, "combo") == 0)
512 return ANJUTA_PROPERTY_OBJECT_TYPE_COMBO;
513 else if (strcmp (object_type, "spin") == 0)
514 return ANJUTA_PROPERTY_OBJECT_TYPE_SPIN;
515 else if (strcmp (object_type, "toggle") == 0)
516 return ANJUTA_PROPERTY_OBJECT_TYPE_TOGGLE;
517 else if (strcmp (object_type, "text") == 0)
518 return ANJUTA_PROPERTY_OBJECT_TYPE_TEXT;
519 else if (strcmp (object_type, "color") == 0)
520 return ANJUTA_PROPERTY_OBJECT_TYPE_COLOR;
521 else if (strcmp (object_type, "font") == 0)
522 return ANJUTA_PROPERTY_OBJECT_TYPE_FONT;
523 else if (strcmp (object_type, "file") == 0)
524 return ANJUTA_PROPERTY_OBJECT_TYPE_FILE;
525 else
526 return (AnjutaPropertyObjectType)(-1);
527 }
528
529 static AnjutaPropertyDataType
530 get_data_type_from_string (const gchar* data_type)
531 {
532 if (strcmp (data_type, "bool") == 0)
533 return ANJUTA_PROPERTY_DATA_TYPE_BOOL;
534 else if (strcmp (data_type, "int") == 0)
535 return ANJUTA_PROPERTY_DATA_TYPE_INT;
536 else if (strcmp (data_type, "text") == 0)
537 return ANJUTA_PROPERTY_DATA_TYPE_TEXT;
538 else if (strcmp (data_type, "color") == 0)
539 return ANJUTA_PROPERTY_DATA_TYPE_COLOR;
540 else if (strcmp (data_type, "font") == 0)
541 return ANJUTA_PROPERTY_DATA_TYPE_FONT;
542 else
543 return (AnjutaPropertyDataType)(-1);
544 }
545
546 static gchar*
547 get_property_value_as_string (AnjutaProperty *prop)
548 {
549 gint int_value;
550 gchar** values;
551 gchar *text_value = NULL;
552
553 if (prop->custom)
554 {
555 if (prop->get_property != NULL)
556 return prop->get_property (prop);
557 else
558 {
559 g_warning ("%s: Undefined get_property() for custom object",
560 prop->key);
561 return NULL;
562 }
563 }
564 switch (prop->object_type)
565 {
566 case ANJUTA_PROPERTY_OBJECT_TYPE_TOGGLE:
567 int_value =
568 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (prop->object));
569 text_value = g_strdup_printf ("%d", int_value);
570 break;
571
572 case ANJUTA_PROPERTY_OBJECT_TYPE_SPIN:
573 int_value =
574 gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (prop->object));
575 text_value = g_strdup_printf ("%d", int_value);
576 break;
577
578 case ANJUTA_PROPERTY_OBJECT_TYPE_ENTRY:
579 text_value =
580 gtk_editable_get_chars (GTK_EDITABLE (prop->object), 0, -1);
581 break;
582 case ANJUTA_PROPERTY_OBJECT_TYPE_COMBO:
583 {
584 gint idx;
585 values = g_object_get_data(G_OBJECT(prop->object), "untranslated");
586 idx = gtk_combo_box_get_active(GTK_COMBO_BOX(prop->object));
587 if (values[idx] != NULL)
588 text_value = g_strdup(values[idx]);
589 break;
590 }
591 case ANJUTA_PROPERTY_OBJECT_TYPE_TEXT:
592 {
593 GtkTextBuffer *buffer;
594 GtkTextIter start_iter;
595 GtkTextIter end_iter;
596 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (prop->object));
597 gtk_text_buffer_get_start_iter (buffer, &start_iter);
598 gtk_text_buffer_get_end_iter (buffer, &end_iter);
599 text_value =
600 gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, TRUE);
601 break;
602 }
603 case ANJUTA_PROPERTY_OBJECT_TYPE_COLOR:
604 {
605 GdkColor color;
606 gtk_color_button_get_color(GTK_COLOR_BUTTON (prop->object),
607 &color);
608 text_value = anjuta_util_string_from_color (color.red, color.green, color.blue);
609 }
610 break;
611 case ANJUTA_PROPERTY_OBJECT_TYPE_FONT:
612 {
613 const gchar *font;
614 font = gtk_font_button_get_font_name (GTK_FONT_BUTTON
615 (prop->object));
616 text_value = g_strdup (font);
617 }
618 break;
619 case ANJUTA_PROPERTY_OBJECT_TYPE_FILE:
620 {
621 const gchar *filename;
622 filename = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (prop->object));
623 text_value = g_strdup (filename);
624 }
625 break;
626 }
627 if (text_value && (strlen (text_value) == 0))
628 {
629 g_free (text_value);
630 text_value = NULL;
631 }
632 return text_value;
633 }
634
635 static gint
636 get_property_value_as_int (AnjutaProperty *prop)
637 {
638 gint int_value;
639 gchar *text_value;
640 text_value = get_property_value_as_string (prop);
641 int_value = atoi (text_value);
642 g_free (text_value);
643 return int_value;
644 }
645
646 static void
647 set_property_value_as_string (AnjutaProperty *prop, const gchar *value)
648 {
649 gint int_value;
650 char** values;
651 gint i;
652
653 if (prop->custom)
654 {
655 if (prop->set_property != NULL)
656 {
657 prop->set_property (prop, value);
658 return;
659 }
660 else
661 {
662 g_warning ("%s: Undefined set_property() for custom object",
663 prop->key);
664 return;
665 }
666 }
667 switch (prop->object_type)
668 {
669 case ANJUTA_PROPERTY_OBJECT_TYPE_TOGGLE:
670 if (value)
671 int_value = atoi (value);
672 else
673 int_value = 0;
674
675 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop->object),
676 int_value);
677 break;
678
679 case ANJUTA_PROPERTY_OBJECT_TYPE_SPIN:
680 if (value)
681 int_value = atoi (value);
682 else
683 int_value = 0;
684
685 gtk_spin_button_set_value (GTK_SPIN_BUTTON (prop->object), int_value);
686 break;
687
688 case ANJUTA_PROPERTY_OBJECT_TYPE_ENTRY:
689 if (value)
690 gtk_entry_set_text (GTK_ENTRY (prop->object), value);
691 else
692 gtk_entry_set_text (GTK_ENTRY (prop->object), "");
693 break;
694 case ANJUTA_PROPERTY_OBJECT_TYPE_COMBO:
695 values = g_object_get_data(G_OBJECT(prop->object), "untranslated");
696 if (value != NULL)
697 {
698 for (i=0; values[i] != NULL; i++)
699 {
700 if (strcmp(value, values[i]) == 0)
701 {
702 gtk_combo_box_set_active(GTK_COMBO_BOX(prop->object), i);
703 break;
704 }
705 }
706 }
707 break;
708 case ANJUTA_PROPERTY_OBJECT_TYPE_TEXT:
709 {
710 GtkTextBuffer *buffer;
711 buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (prop->object));
712 if (value)
713 gtk_text_buffer_set_text (buffer, value, -1);
714 else
715 gtk_text_buffer_set_text (buffer, "", -1);
716 }
717 break;
718
719 case ANJUTA_PROPERTY_OBJECT_TYPE_COLOR:
720 {
721 GdkColor color;
722
723 if (value)
724 anjuta_util_color_from_string (value, &color.red, &color.green, &color.blue);
725
726 gtk_color_button_set_color(GTK_COLOR_BUTTON(prop->object), &color);
727 }
728 break;
729
730 case ANJUTA_PROPERTY_OBJECT_TYPE_FONT:
731 if (value)
732 {
733 /* If the font name is Xfont name, convert it into
734 Pango font description text -- Just take the family name :) */
735 if (value[0] == '-')
736 {
737 /* Font is xfont name */
738 gchar *font_name, *tmp;
739 const gchar *end, *start;
740 start = value;
741 start = g_strstr_len (&start[1], strlen (&start[1]), "-");
742 end = g_strstr_len (&start[1], strlen (&start[1]), "-");
743 font_name = g_strndup (&start[1], end-start-1);
744 tmp = font_name;
745
746 /* Set font size to (arbitrary) 12 points */
747 font_name = g_strconcat (tmp, " 12", NULL);
748 g_free (tmp);
749
750 /* DEBUG_PRINT ("Font set as: %s", font_name); */
751
752 gtk_font_button_set_font_name (GTK_FONT_BUTTON
753 (prop->object), font_name);
754 g_free (font_name);
755 }
756 else
757 {
758 gtk_font_button_set_font_name (GTK_FONT_BUTTON
759 (prop->object), value);
760 }
761 }
762 /* FIXME: Set a standard font as default.
763 else
764 {
765 gnome_font_picker_set_font_name (GNOME_FONT_PICKER (prop->object),
766 "A standard font");
767 }*/
768 break;
769
770 case ANJUTA_PROPERTY_OBJECT_TYPE_FILE:
771 {
772 if (value)
773 {
774 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (prop->object),
775 value);
776 }
777 }
778 break;
779 }
780 }
781
782 static void
783 set_property_value_as_int (AnjutaProperty *prop, gint value)
784 {
785 gchar *text_value;
786 text_value = g_strdup_printf ("%d", value);
787 set_property_value_as_string (prop, text_value);
788 g_free (text_value);
789 }
790
791 static gboolean
792 update_property_on_event_str (GtkWidget *widget, GdkEvent *event,
793 gpointer user_data)
794 {
795 AnjutaPreferences *pr;
796 AnjutaProperty *p;
797 gchar *val;
798
799 pr = ANJUTA_PREFERENCES (g_object_get_data (G_OBJECT (widget),
800 "AnjutaPreferences"));
801 p = (AnjutaProperty *) user_data;
802 val = get_property_value_as_string (p);
803 anjuta_preferences_set (pr, p->key, val);
804 g_free (val);
805 return FALSE;
806 }
807
808 static void
809 update_property_on_change_str (GtkWidget *widget, gpointer user_data)
810 {
811 AnjutaPreferences *pr;
812 AnjutaProperty *p;
813 gchar *val;
814
815 pr = ANJUTA_PREFERENCES (g_object_get_data (G_OBJECT (widget),
816 "AnjutaPreferences"));
817 p = (AnjutaProperty *) user_data;
818 val = get_property_value_as_string (p);
819 anjuta_preferences_set (pr, p->key, val);
820 g_free (val);
821 }
822
823 static gboolean
824 block_update_property_on_change_str (GtkWidget *widget, GdkEvent *event,
825 gpointer user_data)
826 {
827 AnjutaProperty *p = (AnjutaProperty *) user_data;
828
829 gtk_signal_handler_block_by_func (GTK_OBJECT(p->object), G_CALLBACK (update_property_on_change_str), p);
830 return FALSE;
831 }
832
833 static gboolean
834 unblock_update_property_on_change_str (GtkWidget *widget, GdkEvent *event,
835 gpointer user_data)
836 {
837 AnjutaProperty *p = (AnjutaProperty *) user_data;
838
839 gtk_signal_handler_unblock_by_func (GTK_OBJECT(p->object), G_CALLBACK (update_property_on_change_str), p);
840 return FALSE;
841 }
842
843 static void
844 update_property_on_change_int (GtkWidget *widget, gpointer user_data)
845 {
846 AnjutaPreferences *pr;
847 AnjutaProperty *p;
848 gint val;
849
850 pr = ANJUTA_PREFERENCES (g_object_get_data (G_OBJECT (widget),
851 "AnjutaPreferences"));
852 p = (AnjutaProperty *) user_data;
853 val = get_property_value_as_int (p);
854 anjuta_preferences_set_int (pr, p->key, val);
855 }
856
857 static void
858 update_property_on_change_color (GtkWidget *widget, gpointer user_data)
859 {
860 AnjutaPreferences *pr;
861 AnjutaProperty *p;
862 gchar *val;
863
864 pr = ANJUTA_PREFERENCES (g_object_get_data (G_OBJECT (widget),
865 "AnjutaPreferences"));
866 p = (AnjutaProperty *) user_data;
867 val = get_property_value_as_string (p);
868 anjuta_preferences_set (pr, p->key, val);
869 g_free (val);
870 }
871
872 static void
873 update_property_on_change_font (GtkWidget *widget,
874 gpointer user_data)
875 {
876 AnjutaPreferences *pr;
877 AnjutaProperty *p;
878 gchar *val;
879
880 pr = ANJUTA_PREFERENCES (g_object_get_data (G_OBJECT (widget),
881 "AnjutaPreferences"));
882 p = (AnjutaProperty *) user_data;
883 val = get_property_value_as_string (p);
884 anjuta_preferences_set (pr, p->key, val);
885 g_free (val);
886 }
887
888 static void
889 unregister_preferences_key (GtkWidget *widget,
890 gpointer user_data)
891 {
892 AnjutaProperty *p;
893 AnjutaPreferences *pr;
894 gchar *key;
895
896 p = (AnjutaProperty *) user_data;
897 pr = g_object_get_data (G_OBJECT (widget),
898 "AnjutaPreferences");
899 key = g_strdup (p->key);
900
901 g_hash_table_remove (pr->priv->properties, key);
902 g_free (key);
903 }
904
905 static void
906 get_property (GConfClient *gclient, guint cnxt_id,
907 GConfEntry *entry, gpointer user_data)
908 {
909 const gchar *key;
910 GConfValue *value;
911
912 AnjutaProperty *p = (AnjutaProperty *) user_data;
913 key = gconf_entry_get_key (entry);
914 value = gconf_entry_get_value (entry);
915 /* DEBUG_PRINT ("Preference changed %s", key); */
916
917 if (p->data_type == ANJUTA_PROPERTY_DATA_TYPE_BOOL)
918 {
919 gboolean gconf_value;
920
921 gconf_value = gconf_value_get_bool (value);
922 set_property_value_as_int (p, gconf_value);
923 }
924 else if (p->data_type == ANJUTA_PROPERTY_DATA_TYPE_INT)
925 {
926 int gconf_value;
927
928 gconf_value = gconf_value_get_int (value);
929 set_property_value_as_int (p, gconf_value);
930 }
931 else
932 {
933 const gchar *gconf_value;
934 gconf_value = gconf_value_get_string (value);
935 set_property_value_as_string (p, gconf_value);
936 }
937 }
938
939 static void
940 register_callbacks (AnjutaPreferences *pr, AnjutaProperty *p)
941 {
942 GConfClient *gclient;
943 gchar *key_error_msg;
944
945 gclient = pr->priv->gclient;
946 g_object_set_data (G_OBJECT (p->object), "AnjutaPreferences", pr);
947 switch (p->object_type) {
948 case ANJUTA_PROPERTY_OBJECT_TYPE_ENTRY:
949 g_signal_connect (G_OBJECT(p->object), "changed",
950 G_CALLBACK (update_property_on_change_str), p);
951 g_signal_connect (G_OBJECT(p->object), "focus_out_event",
952 G_CALLBACK (update_property_on_event_str), p);
953 g_signal_connect (G_OBJECT(p->object), "focus_out_event",
954 G_CALLBACK (unblock_update_property_on_change_str), p);
955 g_signal_connect (G_OBJECT(p->object), "focus_in_event",
956 G_CALLBACK (block_update_property_on_change_str), p);
957 break;
958 case ANJUTA_PROPERTY_OBJECT_TYPE_SPIN:
959 g_signal_connect (G_OBJECT(p->object), "value-changed",
960 G_CALLBACK (update_property_on_change_int), p);
961 break;
962 case ANJUTA_PROPERTY_OBJECT_TYPE_FONT:
963 g_signal_connect (G_OBJECT(p->object), "font-set",
964 G_CALLBACK (update_property_on_change_font), p);
965 break;
966 case ANJUTA_PROPERTY_OBJECT_TYPE_TEXT:
967 g_signal_connect (G_OBJECT(p->object), "focus_out_event",
968 G_CALLBACK (update_property_on_event_str), p);
969 break;
970 case ANJUTA_PROPERTY_OBJECT_TYPE_COMBO:
971 g_signal_connect (G_OBJECT(p->object), "changed",
972 G_CALLBACK (update_property_on_change_str), p);
973 break;
974 case ANJUTA_PROPERTY_OBJECT_TYPE_TOGGLE:
975 g_signal_connect (G_OBJECT(p->object), "toggled",
976 G_CALLBACK (update_property_on_change_int), p);
977 break;
978 case ANJUTA_PROPERTY_OBJECT_TYPE_COLOR:
979 g_signal_connect (G_OBJECT(p->object), "color-set",
980 G_CALLBACK (update_property_on_change_color), p);
981 break;
982 case ANJUTA_PROPERTY_OBJECT_TYPE_FILE:
983 g_signal_connect (G_OBJECT(p->object), "current-folder-changed",
984 G_CALLBACK (update_property_on_change_str), p);
985 break;
986 default:
987 break;
988 }
989 if (!gconf_valid_key (build_key (p->key), &key_error_msg))
990 {
991 g_warning ("Invalid key \"%s\": Error: \"%s\"", build_key (p->key),
992 key_error_msg);
993 g_free (key_error_msg);
994 }
995 p->notify_id = gconf_client_notify_add (gclient, build_key (p->key),
996 get_property, p, NULL, NULL);
997
998 /* Connect to widget destroy signal so we can automatically unregister
999 * keys so there aren't any potential conflicts or references to
1000 * nonexistent widgets on subsequent uses of the prefs dialog. */
1001 g_signal_connect (G_OBJECT (p->object), "destroy",
1002 G_CALLBACK (unregister_preferences_key),
1003 p);
1004 }
1005
1006 static gboolean
1007 preferences_foreach_callback (gchar *key, struct _AnjutaProperty *p,
1008 struct _AnjutaPreferencesForeachData *data)
1009 {
1010 if (p->object_type != ANJUTA_PROPERTY_OBJECT_TYPE_COMBO)
1011 {
1012 if (data->filter == ANJUTA_PREFERENCES_FILTER_NONE)
1013 return data->callback (data->pr, key, data->callback_data);
1014 else if (p->flags & data->filter)
1015 return data->callback (data->pr, key, data->callback_data);
1016 }
1017
1018 return TRUE;
1019 }
1020
1021 static void
1022 connect_prop_to_object (AnjutaPreferences *pr, AnjutaProperty *p)
1023 {
1024 int gconf_value;
1025 gchar *value;
1026
1027 if (p->data_type == ANJUTA_PROPERTY_DATA_TYPE_BOOL ||
1028 p->data_type == ANJUTA_PROPERTY_DATA_TYPE_INT)
1029 {
1030 gconf_value = anjuta_preferences_get_int (pr, p->key);
1031 value = g_strdup_printf ("%d", gconf_value);
1032 set_property_value_as_string (p, value);
1033 }
1034 else
1035 {
1036 value = anjuta_preferences_get (pr, p->key);
1037 set_property_value_as_string (p, value);
1038 g_free (value);
1039 }
1040 }
1041
1042
1043 /**
1044 * anjuta_preferences_register_property_raw:
1045 * @pr: a #AnjutaPreferences object
1046 * @object: Widget to register
1047 * @key: Property key
1048 * @default_value: Default value of the key
1049 * @flags: Flags
1050 * @object_type: Object type of widget
1051 * @data_type: Data type of the property
1052 *
1053 * This also registers only one widget, but instead of supplying the property
1054 * parameters as a single parsable string (as done in previous method), it
1055 * takes them separately.
1056 *
1057 * Return value: TRUE if sucessful.
1058 */
1059 gboolean
1060 anjuta_preferences_register_property_raw (AnjutaPreferences *pr,
1061 GtkWidget *object,
1062 const gchar *key,
1063 const gchar *default_value,
1064 guint flags,
1065 AnjutaPropertyObjectType object_type,
1066 AnjutaPropertyDataType data_type)
1067 {
1068 AnjutaProperty *p;
1069 GConfValue *value;
1070
1071 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), FALSE);
1072 g_return_val_if_fail (GTK_IS_WIDGET (object), FALSE);
1073 g_return_val_if_fail (key != NULL, FALSE);
1074 g_return_val_if_fail (strlen(key) > 0, FALSE);
1075
1076 p = g_new0 (AnjutaProperty, 1);
1077 g_object_ref (object);
1078 p->object = object;
1079 p->object_type = object_type;
1080 p->data_type = data_type;
1081 p->key = g_strdup (key);
1082 p->gclient = pr->priv->gclient;
1083
1084 value = gconf_client_get (pr->priv->gclient,
1085 build_key (p->key), NULL);
1086 if (value)
1087 {
1088 /* Verify key type. Unset key if type mismatch. */
1089 if (!((value->type == GCONF_VALUE_BOOL &&
1090 data_type == ANJUTA_PROPERTY_DATA_TYPE_BOOL) ||
1091 (value->type == GCONF_VALUE_INT &&
1092 data_type == ANJUTA_PROPERTY_DATA_TYPE_INT) ||
1093 (value->type == GCONF_VALUE_STRING &&
1094 data_type != ANJUTA_PROPERTY_DATA_TYPE_BOOL &&
1095 data_type != ANJUTA_PROPERTY_DATA_TYPE_INT)))
1096 {
1097 gconf_client_unset (pr->priv->gclient, build_key (key), NULL);
1098 }
1099 gconf_value_free (value);
1100 }
1101 if (default_value)
1102 {
1103 p->default_value = g_strdup (default_value);
1104 if (strlen (default_value) > 0)
1105 {
1106 /* For combo, initialize the untranslated strings */
1107 if (object_type == ANJUTA_PROPERTY_OBJECT_TYPE_COMBO)
1108 {
1109 gchar *old_value;
1110 gchar **vstr;
1111
1112 vstr = g_strsplit (default_value, ",", 100);
1113 g_object_set_data(G_OBJECT(p->object), "untranslated",
1114 vstr);
1115 old_value = anjuta_preferences_get (pr, p->key);
1116 if (old_value == NULL && vstr[0])
1117 {
1118 /* DEBUG_PRINT ("Setting default pref value: %s = %s",
1119 p->key, default_value); */
1120 anjuta_preferences_set (pr, p->key, vstr[0]);
1121 }
1122 if (old_value)
1123 g_free (old_value);
1124 }
1125 else if (p->data_type != ANJUTA_PROPERTY_DATA_TYPE_BOOL &&
1126 p->data_type != ANJUTA_PROPERTY_DATA_TYPE_INT)
1127 {
1128 gchar *old_value;
1129 old_value = anjuta_preferences_get (pr, p->key);
1130 if (old_value == NULL)
1131 {
1132 /* DEBUG_PRINT ("Setting default pref value: %s = %s",
1133 p->key, default_value);*/
1134 anjuta_preferences_set (pr, p->key, default_value);
1135 }
1136 if (old_value)
1137 g_free (old_value);
1138 }
1139 else
1140 {
1141 value = gconf_client_get (pr->priv->gclient,
1142 build_key (p->key), NULL);
1143 if (value == NULL)
1144 {
1145 /* DEBUG_PRINT ("Setting default pref value: %s = %s",
1146 p->key, default_value);*/
1147 if (p->data_type == ANJUTA_PROPERTY_DATA_TYPE_INT)
1148 gconf_client_set_int (pr->priv->gclient,
1149 build_key (p->key),
1150 atoi (default_value), NULL);
1151 else
1152 gconf_client_set_bool (pr->priv->gclient,
1153 build_key (p->key),
1154 atoi (default_value), NULL);
1155 }
1156 if (value)
1157 gconf_value_free (value);
1158 }
1159 }
1160 }
1161 p->flags = flags;
1162 p->custom = FALSE;
1163 p->set_property = NULL;
1164 p->get_property = NULL;
1165
1166 g_hash_table_insert (pr->priv->properties, g_strdup (key), p);
1167 connect_prop_to_object (pr, p);
1168 register_callbacks (pr, p);
1169 return TRUE;
1170 }
1171
1172 /**
1173 * anjuta_preferences_register_property_custom:
1174 * @pr: a #AnjutaPreferences object.
1175 * @object: Object to register.
1176 * @key: Property key.
1177 * @default_value: Default value of the key.
1178 * @data_type: property data type.
1179 * @flags: Flags
1180 * @set_property: Set property to widget callback.
1181 * @get_property: Get property from widget callback.
1182 *
1183 * This is meant for complex widgets which can not be set/get with the
1184 * standard object set/get methods. Custom set/get methods are passed for
1185 * the property to set/get the value to/from the widget.
1186 *
1187 * Return value: TRUE if sucessful.
1188 */
1189 gboolean
1190 anjuta_preferences_register_property_custom (AnjutaPreferences *pr,
1191 GtkWidget *object,
1192 const gchar *key,
1193 const gchar *default_value,
1194 AnjutaPropertyDataType data_type,
1195 guint flags,
1196 void (*set_property) (AnjutaProperty *prop, const gchar *value),
1197 gchar * (*get_property) (AnjutaProperty *))
1198 {
1199 AnjutaProperty *p;
1200 GConfValue *value;
1201
1202 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), FALSE);
1203 g_return_val_if_fail (GTK_IS_WIDGET (object), FALSE);
1204 g_return_val_if_fail (key != NULL, FALSE);
1205 g_return_val_if_fail (strlen(key) > 0, FALSE);
1206
1207 p = g_new0 (AnjutaProperty, 1);
1208 g_object_ref (object);
1209 p->object = object;
1210 p->object_type = (AnjutaPropertyObjectType) 0;
1211 p->data_type = data_type;
1212 p->key = g_strdup (key);
1213 p->gclient = pr->priv->gclient;
1214
1215 value = gconf_client_get (pr->priv->gclient,
1216 build_key (p->key), NULL);
1217 if (value)
1218 {
1219 /* Verify key type. Unset key if type mismatch. */
1220 if (!((value->type == GCONF_VALUE_BOOL &&
1221 data_type == ANJUTA_PROPERTY_DATA_TYPE_BOOL) ||
1222 (value->type == GCONF_VALUE_INT &&
1223 data_type == ANJUTA_PROPERTY_DATA_TYPE_INT) ||
1224 (value->type == GCONF_VALUE_STRING &&
1225 data_type != ANJUTA_PROPERTY_DATA_TYPE_BOOL &&
1226 data_type != ANJUTA_PROPERTY_DATA_TYPE_INT)))
1227 {
1228 gconf_client_unset (pr->priv->gclient, build_key (key), NULL);
1229 }
1230 gconf_value_free (value);
1231 }
1232 if (default_value)
1233 {
1234 p->default_value = g_strdup (default_value);
1235 if (p->data_type != ANJUTA_PROPERTY_DATA_TYPE_BOOL &&
1236 p->data_type != ANJUTA_PROPERTY_DATA_TYPE_INT)
1237 {
1238 gchar *old_value;
1239 old_value = anjuta_preferences_get (pr, p->key);
1240 if (old_value == NULL)
1241 {
1242 /* DEBUG_PRINT ("Setting default pref value: %s = %s",
1243 p->key, default_value); */
1244 anjuta_preferences_set (pr, p->key, default_value);
1245 }
1246 if (old_value)
1247 g_free (old_value);
1248 }
1249 else
1250 {
1251 value = gconf_client_get (pr->priv->gclient,
1252 build_key (p->key), NULL);
1253 if (value == NULL)
1254 {
1255 /* DEBUG_PRINT ("Setting default pref value: %s = %s",
1256 p->key, default_value);*/
1257 if (p->data_type == ANJUTA_PROPERTY_DATA_TYPE_INT)
1258 gconf_client_set_int (pr->priv->gclient,
1259 build_key (p->key),
1260 atoi (default_value), NULL);
1261 else
1262 gconf_client_set_bool (pr->priv->gclient,
1263 build_key (p->key),
1264 atoi (default_value), NULL);
1265 }
1266 if (value)
1267 gconf_value_free (value);
1268 }
1269 }
1270 p->custom = TRUE;
1271 p->flags = flags;
1272 p->set_property = set_property;
1273 p->get_property = get_property;
1274
1275 g_hash_table_insert (pr->priv->properties, g_strdup (key), p);
1276 return TRUE;
1277 }
1278
1279 /**
1280 * anjuta_preferences_register_property_from_string:
1281 * @pr: a #AnjutaPreferences object
1282 * @object: Widget to register
1283 * @property_desc: Property description (see anjuta_preferences_add_pag())
1284 *
1285 * This registers only one widget. The widget could be shown elsewhere.
1286 * the property_description should be of the form described before.
1287 *
1288 * Return value: TRUE if sucessful.
1289 */
1290 gboolean
1291 anjuta_preferences_register_property_from_string (AnjutaPreferences *pr,
1292 GtkWidget *object,
1293 const gchar *property_desc)
1294 {
1295 gchar **fields;
1296 gint n_fields;
1297
1298 AnjutaPropertyObjectType object_type;
1299 AnjutaPropertyDataType data_type;
1300 gchar *key;
1301 gchar *default_value;
1302 gint flags;
1303
1304 g_return_val_if_fail (ANJUTA_IS_PREFERENCES(pr), FALSE);
1305 g_return_val_if_fail ((GTK_IS_WIDGET (object)), FALSE);
1306 g_return_val_if_fail (property_desc != NULL, FALSE);
1307
1308 fields = g_strsplit (property_desc, ":", 5);
1309 g_return_val_if_fail (fields, FALSE);
1310 for (n_fields = 0; fields[n_fields]; n_fields++);
1311 if (n_fields != 5)
1312 {
1313 g_strfreev (fields);
1314 return FALSE;
1315 }
1316 object_type = get_object_type_from_string (fields[0]);
1317 data_type = get_data_type_from_string (fields[1]);
1318 default_value = fields[2];
1319 flags = atoi (fields[3]);
1320 key = fields[4];
1321 if (object_type < 0)
1322 {
1323 g_warning ("Invalid property object type in property description");
1324 g_strfreev (fields);
1325 return FALSE;
1326 }
1327 if (data_type < 0)
1328 {
1329 g_warning ("Invalid property data type in property description");
1330 g_strfreev (fields);
1331 return FALSE;
1332 }
1333 anjuta_preferences_register_property_raw (pr, object, key, default_value,
1334 flags, object_type,
1335 data_type);
1336 g_strfreev (fields);
1337 return TRUE;
1338 }
1339
1340 /**
1341 * anjuta_preferences_register_all_properties_from_glade_xml:
1342 * @pr: a #AnjutaPreferences Object
1343 * @gxml: GladeXML object containing the properties widgets.
1344 * @parent: Parent widget in the gxml object
1345 *
1346 * This will register all the properties names of the format described above
1347 * without considering the UI. Useful if you have the widgets shown elsewhere
1348 * but you want them to be part of preferences system.
1349 */
1350 void
1351 anjuta_preferences_register_all_properties_from_glade_xml (AnjutaPreferences *pr,
1352 GladeXML *gxml,
1353 GtkWidget *parent)
1354 {
1355 GList *widgets;
1356 GList *node;
1357
1358 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
1359 g_return_if_fail (gxml != NULL);
1360
1361 widgets = glade_xml_get_widget_prefix (gxml, "preferences_");
1362 node = widgets;
1363 while (node)
1364 {
1365 const gchar *name;
1366 GtkWidget *widget, *p;
1367 gboolean cont_flag = FALSE;
1368
1369 widget = node->data;
1370
1371 p = gtk_widget_get_parent (widget);
1372 /* Added only if it's a desendend child of the parent */
1373 while (p != parent)
1374 {
1375 if (p == NULL)
1376 {
1377 cont_flag = TRUE;
1378 break;
1379 }
1380 p = gtk_widget_get_parent (p);
1381 }
1382 if (cont_flag == TRUE)
1383 {
1384 node = g_list_next (node);
1385 continue;
1386 }
1387
1388 name = glade_get_widget_name (widget);
1389 if (strncmp (name, PREFERENCE_PROPERTY_PREFIX,
1390 strlen (PREFERENCE_PROPERTY_PREFIX)) == 0)
1391 {
1392 const gchar *property = &name[strlen (PREFERENCE_PROPERTY_PREFIX)];
1393 anjuta_preferences_register_property_from_string (pr, widget,
1394 property);
1395 }
1396 node = g_list_next (node);
1397 }
1398 }
1399
1400 /**
1401 * anjuta_preferences_reset_defaults:
1402 * @pr: a #AnjutaPreferences object.
1403 *
1404 * Resets the default values into the keys
1405 */
1406 void
1407 anjuta_preferences_reset_defaults (AnjutaPreferences * pr)
1408 {
1409 GtkWidget *dlg;
1410
1411 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
1412
1413 dlg = gtk_message_dialog_new (GTK_WINDOW (pr),
1414 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
1415 GTK_BUTTONS_NONE,
1416 _("Are you sure you want to reset the preferences to\n"
1417 "their default settings?"));
1418 gtk_dialog_add_button (GTK_DIALOG (dlg), GTK_STOCK_CANCEL,
1419 GTK_RESPONSE_CANCEL);
1420 anjuta_util_dialog_add_button (GTK_DIALOG (dlg), _("_Reset"),
1421 GTK_STOCK_REVERT_TO_SAVED,
1422 GTK_RESPONSE_YES);
1423 if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_YES)
1424 {
1425 /* FIXME: Reset preferences to built-in default values. */
1426 }
1427 gtk_widget_destroy (dlg);
1428 }
1429
1430 /**
1431 * anjuta_preferences_foreach:
1432 * @pr: A #AnjutaPreferences object.
1433 * @filter: Keys to filter out from the loop.
1434 * @callback: User callback function.
1435 * @data: User data passed to @callback
1436 *
1437 * Calls @callback function for each of the registered property keys. Keys
1438 * with matching @filter flags are left out of the loop. If @filter is
1439 * ANJUTA_PREFERENCES_FILTER_NONE, all properties are selected for the loop.
1440 */
1441 void
1442 anjuta_preferences_foreach (AnjutaPreferences *pr,
1443 AnjutaPreferencesFilterType filter,
1444 AnjutaPreferencesCallback callback,
1445 gpointer data)
1446 {
1447 struct _AnjutaPreferencesForeachData foreach_data;
1448
1449 foreach_data.pr = pr;
1450 foreach_data.filter = filter;
1451 foreach_data.callback = callback;
1452 foreach_data.callback_data = data;
1453
1454 g_hash_table_find (pr->priv->properties,
1455 (GHRFunc) preferences_foreach_callback,
1456 &foreach_data);
1457
1458 }
1459
1460 /**
1461 * anjuta_preferences_add_page:
1462 * @pr: a #AnjutaPreferences object
1463 * @gxml: #GladeXML object containing the preferences page
1464 * @glade_widget_name: Page widget name (as give with glade interface editor).
1465 * The widget will be searched with the given name and detached
1466 * (that is, removed from the container, if present) from it's parent.
1467 * @icon_filename: File name (of the form filename.png) of the icon representing
1468 * the preference page.
1469 *
1470 * Add a page to the preferences sytem.
1471 * gxml is the GladeXML object of the glade dialog containing the page widget.
1472 * The glade dialog will contain the layout of the preferences widgets.
1473 * The widgets which are preference widgets (e.g. toggle button) should have
1474 * widget names of the form:
1475 *
1476 * <programlisting>
1477 * preferences_OBJECTTYPE:DATATYPE:DEFAULT:FLAGS:PROPERTYKEY
1478 * where,
1479 * OBJECTTYPE is 'toggle', 'spin', 'entry', 'text', 'color', 'font' or 'file' .
1480 * DATATYPE is 'bool', 'int', 'float', 'text', 'color' or 'font'.
1481 * DEFAULT is the default value (in the appropriate format). The format
1482 * for color is '#XXXXXX' representing RGB value and for
1483 * font, it is the pango font description.
1484 * FLAGS is any flag associated with the property. Currently it
1485 * has only two values -- 0 and 1. For normal preference
1486 * property which is saved/retrieved globally, the flag = 0.
1487 * For preference property which is also saved/retrieved
1488 * along with the project, the flag = 1.
1489 * PROPERTYKEY is the property key. e.g - 'tab.size'.
1490 * </programlisting>
1491 *
1492 * All widgets having the above names in the gxml tree will be registered
1493 * and will become part of auto saving/loading. For example, refer to
1494 * anjuta preferences dialogs and study the widget names.
1495 */
1496 void
1497 anjuta_preferences_add_page (AnjutaPreferences* pr, GladeXML *gxml,
1498 const gchar* glade_widget_name,
1499 const gchar* title,
1500 const gchar *icon_filename)
1501 {
1502 GtkWidget *parent;
1503 GtkWidget *page;
1504 GdkPixbuf *pixbuf;
1505 gchar *image_path;
1506
1507 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
1508 g_return_if_fail (glade_widget_name != NULL);
1509 g_return_if_fail (icon_filename != NULL);
1510
1511 page = glade_xml_get_widget (gxml, glade_widget_name);
1512 g_object_ref (page);
1513 g_return_if_fail (GTK_IS_WIDGET (page));
1514 parent = gtk_widget_get_parent (page);
1515 if (parent && GTK_IS_CONTAINER (parent))
1516 {
1517 if (GTK_IS_NOTEBOOK (parent))
1518 {
1519 gint page_num;
1520
1521 page_num = gtk_notebook_page_num (GTK_NOTEBOOK (parent), page);
1522 gtk_notebook_remove_page (GTK_NOTEBOOK (parent), page_num);
1523 }
1524 else
1525 {
1526 gtk_container_remove (GTK_CONTAINER (parent), page);
1527 }
1528 }
1529 image_path = anjuta_res_get_pixmap_file (icon_filename);
1530 pixbuf = gdk_pixbuf_new_from_file (image_path, NULL);
1531 anjuta_preferences_dialog_add_page (ANJUTA_PREFERENCES_DIALOG (pr->priv->prefs_dialog),
1532 glade_widget_name, title, pixbuf, page);
1533 anjuta_preferences_register_all_properties_from_glade_xml (pr, gxml, page);
1534 g_object_unref (page);
1535 g_free (image_path);
1536 g_object_unref (pixbuf);
1537 }
1538
1539 void
1540 anjuta_preferences_remove_page (AnjutaPreferences *pr,
1541 const gchar *page_name)
1542 {
1543 if (pr->priv->prefs_dialog)
1544 {
1545 anjuta_preferences_dialog_remove_page (ANJUTA_PREFERENCES_DIALOG (pr->priv->prefs_dialog),
1546 page_name);
1547 }
1548 }
1549
1550 static void
1551 on_preferences_dialog_destroyed (GtkWidget *preferencess_dialog,
1552 AnjutaPreferences *pr)
1553 {
1554 GList *plugins;
1555 GList *current_plugin;
1556
1557 plugins = anjuta_plugin_manager_get_active_plugin_objects (pr->priv->plugin_manager);
1558 current_plugin = plugins;
1559
1560 while (current_plugin)
1561 {
1562 if (IANJUTA_IS_PREFERENCES (current_plugin->data))
1563 {
1564 ianjuta_preferences_unmerge (IANJUTA_PREFERENCES (current_plugin->data),
1565 pr, NULL);
1566 }
1567
1568 current_plugin = g_list_next (current_plugin);
1569
1570 }
1571
1572 g_object_unref (pr->priv->prefs_dialog);
1573
1574 g_list_free (plugins);
1575 pr->priv->prefs_dialog = NULL;
1576 }
1577
1578 GtkWidget *
1579 anjuta_preferences_get_dialog (AnjutaPreferences *pr)
1580 {
1581 GList *plugins;
1582 GList *current_plugin;
1583
1584 if (pr->priv->prefs_dialog)
1585 return pr->priv->prefs_dialog;
1586 else
1587 {
1588 pr->priv->prefs_dialog = anjuta_preferences_dialog_new ();
1589
1590 g_signal_connect (G_OBJECT (pr->priv->prefs_dialog), "destroy",
1591 G_CALLBACK (on_preferences_dialog_destroyed),
1592 pr);
1593
1594 plugins = anjuta_plugin_manager_get_active_plugin_objects (pr->priv->plugin_manager);
1595 current_plugin = plugins;
1596
1597 while (current_plugin)
1598 {
1599 if (IANJUTA_IS_PREFERENCES (current_plugin->data))
1600 {
1601 ianjuta_preferences_merge (IANJUTA_PREFERENCES (current_plugin->data),
1602 pr, NULL);
1603 }
1604
1605 current_plugin = g_list_next (current_plugin);
1606 }
1607
1608 g_list_free (plugins);
1609
1610 return g_object_ref_sink (pr->priv->prefs_dialog);
1611 }
1612 }
1613
1614 static void anjuta_preferences_class_init (AnjutaPreferencesClass *class);
1615 static void anjuta_preferences_instance_init (AnjutaPreferences *pr);
1616
1617 GType
1618 anjuta_preferences_get_type ()
1619 {
1620 static GType obj_type = 0;
1621
1622 if (!obj_type)
1623 {
1624 static const GTypeInfo obj_info =
1625 {
1626 sizeof (AnjutaPreferencesClass),
1627 (GBaseInitFunc) NULL,
1628 (GBaseFinalizeFunc) NULL,
1629 (GClassInitFunc) anjuta_preferences_class_init,
1630 (GClassFinalizeFunc) NULL,
1631 NULL, /* class_data */
1632 sizeof (AnjutaPreferencesClass),
1633 0, /* n_preallocs */
1634 (GInstanceInitFunc) anjuta_preferences_instance_init,
1635 NULL /* value_table */
1636 };
1637 obj_type = g_type_register_static (G_TYPE_OBJECT,
1638 "AnjutaPreferences", &obj_info, 0);
1639 }
1640 return obj_type;
1641 }
1642
1643 static void
1644 anjuta_preferences_dispose (GObject *obj)
1645 {
1646 AnjutaPreferences *pr = ANJUTA_PREFERENCES (obj);
1647
1648 if (pr->priv->properties)
1649 {
1650 /* This will release the refs on property objects */
1651 g_hash_table_destroy (pr->priv->properties);
1652 pr->priv->properties = NULL;
1653 }
1654 }
1655
1656 static void
1657 anjuta_preferences_instance_init (AnjutaPreferences *pr)
1658 {
1659 pr->priv = g_new0 (AnjutaPreferencesPriv, 1);
1660
1661 pr->priv->properties = g_hash_table_new_full (g_str_hash, g_str_equal,
1662 g_free,
1663 (GDestroyNotify) property_destroy);
1664
1665 pr->priv->gclient = gconf_client_get_default();
1666 gconf_client_add_dir (pr->priv->gclient, GCONF_KEY_PREFIX,
1667 GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
1668
1669 }
1670
1671 static void
1672 anjuta_preferences_finalize (GObject *obj)
1673 {
1674 AnjutaPreferences *pr = ANJUTA_PREFERENCES (obj);
1675
1676 if (pr->priv->prefs_dialog)
1677 gtk_widget_destroy (pr->priv->prefs_dialog);
1678
1679 g_object_unref (pr->priv->plugin_manager);
1680 g_free (pr->priv);
1681 }
1682
1683 static void
1684 anjuta_preferences_class_init (AnjutaPreferencesClass *class)
1685 {
1686 GObjectClass *object_class = G_OBJECT_CLASS (class);
1687
1688 object_class->dispose = anjuta_preferences_dispose;
1689 object_class->finalize = anjuta_preferences_finalize;
1690 }
1691
1692 /**
1693 * anjuta_preferences_new:
1694 *
1695 * Creates a new #AnjutaPreferences object
1696 *
1697 * Return value: A #AnjutaPreferences object.
1698 */
1699 AnjutaPreferences *
1700 anjuta_preferences_new (AnjutaPluginManager *plugin_manager)
1701 {
1702 AnjutaPreferences *pr;
1703
1704 pr = g_object_new (ANJUTA_TYPE_PREFERENCES, NULL);
1705 pr->priv->plugin_manager = g_object_ref (plugin_manager);
1706
1707 return pr;
1708
1709 }
1710
1711 /**
1712 * anjuta_preferences_notify_add:
1713 * @pr: A #AnjutaPreferences object.
1714 * @key: Key to monitor.
1715 * @func: User callback function.
1716 * @data: User data passed to @func
1717 * @destroy_notify: Destroy notify function - called when notify is removed.
1718 *
1719 * This is similar to gconf_client_notify_add(), except that the key is not
1720 * given as full path. Only anjuta preference key is given. The key prefix
1721 * is added internally.
1722 *
1723 * Return value: Notify ID.
1724 */
1725 guint
1726 anjuta_preferences_notify_add (AnjutaPreferences *pr,
1727 const gchar *key,
1728 GConfClientNotifyFunc func,
1729 gpointer data,
1730 GFreeFunc destroy_notify)
1731 {
1732 return gconf_client_notify_add (pr->priv->gclient,
1733 build_key (key),
1734 func, data, destroy_notify, NULL);
1735 }
1736
1737 /**
1738 * anjuta_preferences_notify_remove:
1739 * @pr: A #AnjutaPreferences object.
1740 * @notify_id: Notify ID returned by anjuta_preferences_notify_add().
1741 *
1742 * Removes the notify callback added with anjuta_preferences_notify_add().
1743 */
1744 void
1745 anjuta_preferences_notify_remove (AnjutaPreferences *pr, guint notify_id)
1746 {
1747 gconf_client_notify_remove (pr->priv->gclient, notify_id);
1748 }
1749
1750 /**
1751 * anjuta_preferences_get_prefix:
1752 * @pr: A #AnjutaPreferences object.
1753 *
1754 * Returns the gconf key prefix used by anjuta to store its preferences.
1755 *
1756 * Return value: preferences keys prefix.
1757 */
1758 const gchar*
1759 anjuta_preferences_get_prefix (AnjutaPreferences *pr)
1760 {
1761 return PREFERENCE_PROPERTY_PREFIX;
1762 }
1763
1764 /**
1765 * anjuta_preferences_dir_exists:
1766 * @pr: A #AnjutaPreferences object.
1767 * @dir: Directory to checkfor.
1768 *
1769 * Returns TRUE if dir exists.
1770 */
1771 #ifdef __GNUC__
1772 inline
1773 #endif
1774 gboolean
1775 anjuta_preferences_dir_exists (AnjutaPreferences *pr, const gchar *dir)
1776 {
1777 g_return_val_if_fail (ANJUTA_IS_PREFERENCES (pr), FALSE);
1778 g_return_val_if_fail (dir != NULL, FALSE);
1779
1780 return gconf_client_dir_exists(pr->priv->gclient, build_key (dir), NULL);
1781 }
1782
1783 /**
1784 * anjuta_preferences_add_dir:
1785 * @pr: A #AnjutaPreferences object.
1786 * @dir: Directory to add to the list.
1787 * @preload: Degree of preload.
1788 *
1789 * Add a directory to the list of directories the GConfClient.
1790 */
1791 #ifdef __GNUC__
1792 inline
1793 #endif
1794 void
1795 anjuta_preferences_add_dir (AnjutaPreferences *pr, const gchar *dir,
1796 GConfClientPreloadType preload)
1797 {
1798 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
1799 g_return_if_fail (dir != NULL);
1800
1801 gconf_client_add_dir(pr->priv->gclient, build_key (dir),
1802 preload, NULL);
1803 }
1804
1805 /**
1806 * anjuta_preferences_remove_dir:
1807 * @pr: A #AnjutaPreferences object.
1808 * @dir: Directory to remove from the list.
1809 *
1810 * Remove a directory from the list of directories.
1811 */
1812 #ifdef __GNUC__
1813 inline
1814 #endif
1815 void
1816 anjuta_preferences_remove_dir (AnjutaPreferences *pr, const gchar *dir)
1817 {
1818 g_return_if_fail (ANJUTA_IS_PREFERENCES (pr));
1819 g_return_if_fail (dir != NULL);
1820
1821 gconf_client_remove_dir(pr->priv->gclient, build_key (dir), NULL);
1822 }
Anjuta IDE Git Plugin Development Tree