[Window] Fix automatic pulldown code
[tilda-gobject.git] / tilda-config.c
1 #include "tilda-config.h"
2
3 #include "tilda.h"
4 #include "tilda-types.h"
5 #include "debug.h"
6 #include "translation.h"
7
8 #include <glib-object.h> /* for GType */
9 #include <stdlib.h> /* for exit() */
10
11 GKeyFile *config_defaults = NULL;
12 GKeyFile *config_userprefs = NULL;
13
14 /*
15  * TODO:
16  * 1) Configuration forward-migration, automatically, on startup.
17  */
18
19 /* The main idea behind this configuration system is that each type of GObject
20  * that needs to use the system implements its own lookup scheme. I tried to
21  * do this as generically as possible, by using just the GObject property names,
22  * and then looking up their type and using that to use the correct parsing
23  * function.
24  *
25  * It is basically function overloading (for example, from C++) but done in C.
26  * Rather complicated, if you ask me. Also a complete pain. But the result
27  * sure is nice.
28  */
29
30 static gchar *
31 tilda_config_lookup_version (GKeyFile *keyfile, GError **error)
32 {
33         debug_enter  ();
34
35         return g_key_file_get_string (keyfile, "Meta", "version", error);
36 }
37
38 static gboolean
39 tilda_config_parse_integer (GKeyFile    *keyfile,
40                                                         const gchar *group_name,
41                                                         const gchar *key,
42                                                         GValue      *value,
43                                                         GError     **user_error)
44 {
45         debug_enter  ();
46         debug_assert (G_IS_VALUE(value));
47
48         GError *error = NULL;
49         gint ret;
50
51         /* Try to get the value */
52         ret = g_key_file_get_integer (keyfile, group_name, key, &error);
53
54         /* Check for error */
55         if (error)
56         {
57                 g_propagate_error (user_error, error);
58                 return FALSE;
59         }
60
61         /* We successfully parsed the int, so set it in the GValue */
62         g_value_set_int (value, ret);
63
64         return TRUE;
65 }
66
67 static gboolean
68 tilda_config_parse_boolean (GKeyFile    *keyfile,
69                                                         const gchar *group_name,
70                                                         const gchar *key,
71                                                         GValue      *value,
72                                                         GError     **user_error)
73 {
74         debug_enter  ();
75         debug_assert (G_IS_VALUE(value));
76
77         GError *error = NULL;
78         gboolean ret;
79
80         /* Try to get the value */
81         ret = g_key_file_get_boolean (keyfile, group_name, key, &error);
82
83         /* Check for error */
84         if (error)
85         {
86                 g_propagate_error (user_error, error);
87                 return FALSE;
88         }
89
90         /* Success */
91         g_value_set_boolean (value, ret);
92
93         return TRUE;
94 }
95
96 static gboolean
97 tilda_config_parse_string (GKeyFile    *keyfile,
98                                                    const gchar *group_name,
99                                                    const gchar *key,
100                                                    GValue      *value,
101                                                    GError **user_error)
102 {
103         debug_enter  ();
104         debug_assert (G_IS_VALUE(value));
105
106         GError *error = NULL;
107         gchar *ret;
108
109         /* Try to get the value */
110         ret = g_key_file_get_string (keyfile, group_name, key, &error);
111
112         /* Check for error */
113         if (error)
114         {
115                 g_propagate_error (user_error, error);
116                 return FALSE;
117         }
118
119         /* Success */
120         g_value_set_string (value, ret);
121
122         return TRUE;
123 }
124
125 #define key_is(STR) (g_ascii_strcasecmp(key,(STR)) == 0)
126
127 static gboolean
128 tilda_config_parse_enum (GKeyFile    *keyfile,
129                                                  const gchar *group_name,
130                                                  const gchar *key,
131                                                  GValue      *value,
132                                                  GError     **user_error)
133 {
134         gchar *ret;
135         GError *error = NULL;
136         GEnumClass *enum_class;
137         GEnumValue *enum_value;
138
139         if (key_is("backspace-binding") || key_is("delete-binding"))
140                 enum_class = g_type_class_peek (vte_terminal_erase_binding_get_type());
141         else if (key_is("dynamic-title"))
142                 enum_class = g_type_class_peek (tilda_dynamic_title_get_type());
143         else if (key_is("exit-action"))
144                 enum_class = g_type_class_peek (tilda_child_exit_action_get_type());
145         else if (key_is("scrollbar-position"))
146                 enum_class = g_type_class_peek (tilda_scrollbar_position_get_type());
147         else if (key_is("animation-orientation") || key_is("tab-position"))
148                 enum_class = g_type_class_peek (gtk_position_type_get_type());
149         else
150         {
151                 g_critical ("FIXME: developer error -- unknown enum key used: %s\n", key);
152                 exit (1);
153                 return FALSE;
154         }
155
156         /* Get the value from the config as a string */
157         ret = g_key_file_get_string (keyfile, group_name, key, &error);
158
159         if (error)
160         {
161                 g_propagate_error (user_error, error);
162                 return FALSE;
163         }
164
165         enum_value = g_enum_get_value_by_nick (enum_class, ret);
166
167         if (!enum_value)
168         {
169                 /* This is exactly the same error that is returned by g_key_file_get_integer()
170                  * when it cannot correctly parse the value. */
171                 g_set_error (user_error,
172                                          G_KEY_FILE_ERROR,
173                                          G_KEY_FILE_ERROR_INVALID_VALUE,
174                                          _("Key file contains key '%s' in group '%s' which has value that cannot be interpreted."), key, group_name);
175                 return FALSE;
176         }
177
178         /* All was successful, let's set it */
179         g_value_set_enum (value, enum_value->value);
180         return TRUE;
181 }
182
183 gboolean
184 tilda_controller_set_property_from_config (TildaController *self, const gchar *property)
185 {
186         debug_enter  ();
187         debug_assert (TILDA_IS_CONTROLLER(self));
188
189         GError *error = NULL;
190         gboolean ret;
191
192         GParamSpec *pspec;
193         GValue *value = g_new0 (GValue, 1);
194         gboolean (*parse_func) (GKeyFile *keyfile, const gchar *group_name, const gchar *key, GValue *value, GError **error);
195
196         /* Get the pspec for this property */
197         pspec = g_object_class_find_property (G_OBJECT_GET_CLASS(self), property);
198
199         /* Make sure that this property exists */
200         if (pspec == NULL)
201         {
202                 g_critical ("FIXME: developer error -- unable to find property: %s\n", property);
203                 exit (1);
204         }
205
206         /* Initialize the GValue that is going to hold the returned value */
207         g_value_init (value, pspec->value_type);
208
209         /* Set the correct function to do the parsing */
210         if      (g_type_is_a (pspec->value_type, G_TYPE_INT))
211                 parse_func = tilda_config_parse_integer;
212         else if (g_type_is_a (pspec->value_type, G_TYPE_BOOLEAN))
213                 parse_func = tilda_config_parse_boolean;
214         else if (g_type_is_a (pspec->value_type, G_TYPE_STRING))
215                 parse_func = tilda_config_parse_string;
216         else if (g_type_is_a (pspec->value_type, G_TYPE_ENUM))
217                 parse_func = tilda_config_parse_enum;
218         else
219         {
220                 g_critical ("FIXME: developer error -- unknown property type: %s\n", g_type_name(pspec->value_type));
221                 exit(1);
222         }
223
224         /* Do the [Controller] lookup */
225         ret = parse_func (config_userprefs, "Controller", property, value, &error);
226
227         if (error)
228         {
229                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
230                         g_warning (error->message);
231
232                 g_clear_error (&error);
233         }
234         else
235                 goto success;
236
237         /* Do the [Global] lookup */
238         ret = parse_func (config_userprefs, "Global", property, value, &error);
239
240         if (error)
241         {
242                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
243                         g_warning (error->message);
244
245                 g_clear_error (&error);
246         }
247         else
248                 goto success;
249
250         /* Do the [controller-defaults] lookup */
251         ret = parse_func (config_defaults, "controller-defaults", property, value, &error);
252
253         if (error)
254         {
255                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
256                         g_warning (error->message);
257
258                 g_clear_error (&error);
259
260                 /* This is somewhat of a nasty hack, but I really do want to just set the property to
261                  * NULL if there is no default, but ONLY for strings. */
262                 if (parse_func == tilda_config_parse_string)
263                 {
264                         g_value_set_string (value, NULL);
265                         goto success;
266                 }
267         }
268         else
269                 goto success;
270
271 //failure:
272         g_critical (_("Unable to find a value for controller property: %s\n"), property);
273         g_free (value);
274         return FALSE;
275
276 success:
277         g_object_set_property (G_OBJECT(self), property, value);
278         g_value_unset (value);
279         g_free (value);
280         return TRUE;
281 }
282
283 gboolean
284 tilda_window_set_property_from_config (TildaWindow *self, const gchar *property)
285 {
286         debug_enter  ();
287         debug_assert (TILDA_IS_WINDOW(self));
288
289         gchar *group_name;
290         GError *error = NULL;
291         gboolean ret;
292
293         GParamSpec *pspec;
294         GValue *value = g_new0(GValue, 1);
295         gboolean (*parse_func) (GKeyFile *keyfile, const gchar *group_name, const gchar *key, GValue *value, GError **error);
296
297         /* Get the pspec for this property */
298         pspec = g_object_class_find_property (G_OBJECT_GET_CLASS(self), property);
299
300         /* Make sure that this property exists */
301         if (pspec == NULL)
302         {
303                 g_critical ("FIXME: developer error -- unable to find property: %s\n", property);
304                 exit (1);
305         }
306
307         /* Initialize the GValue that is going to hold the returned value */
308         g_value_init (value, pspec->value_type);
309
310         /* Set the correct function to do the parsing */
311         if      (g_type_is_a (pspec->value_type, G_TYPE_INT))
312                 parse_func = tilda_config_parse_integer;
313         else if (g_type_is_a (pspec->value_type, G_TYPE_BOOLEAN))
314                 parse_func = tilda_config_parse_boolean;
315         else if (g_type_is_a (pspec->value_type, G_TYPE_STRING))
316                 parse_func = tilda_config_parse_string;
317         else if (g_type_is_a (pspec->value_type, G_TYPE_ENUM))
318                 parse_func = tilda_config_parse_enum;
319         else
320         {
321                 g_critical ("FIXME: developer error -- unknown property type: %s\n", g_type_name(pspec->value_type));
322                 exit(1);
323         }
324
325         /* Do the [Window] lookup */
326         group_name = g_strdup_printf ("Window%d", self->number);
327         ret = parse_func (config_userprefs, group_name, property, value, &error);
328         g_free (group_name);
329
330         if (error)
331         {
332                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
333                         g_warning (error->message);
334
335                 g_clear_error (&error);
336         }
337         else
338                 goto success;
339
340         /* Do the [Global] lookup */
341         ret = parse_func (config_userprefs, "Global", property, value, &error);
342
343         if (error)
344         {
345                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
346                         g_warning (error->message);
347
348                 g_clear_error (&error);
349         }
350         else
351                 goto success;
352
353         /* Do the [window-defaults] lookup */
354         ret = parse_func (config_defaults, "window-defaults", property, value, &error);
355
356         if (error)
357         {
358                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
359                         g_warning (error->message);
360
361                 g_clear_error (&error);
362
363                 /* This is somewhat of a nasty hack, but I really do want to just set the property to
364                  * NULL if there is no default, but ONLY for strings. */
365                 if (parse_func == tilda_config_parse_string)
366                 {
367                         g_value_set_string (value, NULL);
368                         goto success;
369                 }
370         }
371         else
372                 goto success;
373
374 //failure:
375         g_critical (_("Unable to find a value for window property: %s\n"), property);
376         g_free (value);
377         return FALSE;
378
379 success:
380         g_object_set_property (G_OBJECT(self), property, value);
381         g_value_unset (value);
382         g_free (value);
383         return TRUE;
384 }
385
386 gboolean
387 tilda_terminal_set_property_from_config (TildaTerminal *self, const gchar *property)
388 {
389         debug_enter  ();
390         debug_assert (TILDA_IS_TERMINAL(self));
391
392         TildaWindow *parent_window = TILDA_WINDOW(self->parent_window);
393         gchar *group_name;
394         GError *error = NULL;
395         gboolean ret;
396
397         GParamSpec *pspec;
398         GValue *value = g_new0 (GValue, 1);
399         gboolean (*parse_func) (GKeyFile *keyfile, const gchar *group_name, const gchar *key, GValue *value, GError **error);
400
401         /* Get the pspec for this property */
402         pspec = g_object_class_find_property (G_OBJECT_GET_CLASS(self), property);
403
404         /* Make sure that this property exists */
405         if (pspec == NULL)
406         {
407                 g_critical ("FIXME: developer error -- unable to find property: %s\n", property);
408                 exit (1);
409         }
410
411         /* Initialize the GValue that is going to hold the returned value */
412         g_value_init (value, pspec->value_type);
413
414         /* Set the correct function to do the parsing */
415         if      (g_type_is_a (pspec->value_type, G_TYPE_INT))
416                 parse_func = tilda_config_parse_integer;
417         else if (g_type_is_a (pspec->value_type, G_TYPE_BOOLEAN))
418                 parse_func = tilda_config_parse_boolean;
419         else if (g_type_is_a (pspec->value_type, G_TYPE_STRING))
420                 parse_func = tilda_config_parse_string;
421         else if (g_type_is_a (pspec->value_type, G_TYPE_ENUM))
422                 parse_func = tilda_config_parse_enum;
423         else
424         {
425                 g_critical ("FIXME: developer error -- unknown property type: %s\n", g_type_name(pspec->value_type));
426                 exit(1);
427         }
428
429         /* Do the [Window/Terminal] lookup */
430         group_name = g_strdup_printf ("Window%d/Terminal%d", parent_window->number, self->number);
431         ret = parse_func (config_userprefs, group_name, property, value, &error);
432         g_free (group_name);
433
434         if (error)
435         {
436                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
437                         g_warning (error->message);
438
439                 g_clear_error (&error);
440         }
441         else
442                 goto success;
443
444         /* Do the [Window] lookup */
445         group_name = g_strdup_printf ("Window%d", parent_window->number);
446         ret = parse_func (config_userprefs, group_name, property, value, &error);
447         g_free (group_name);
448
449         if (error)
450         {
451                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
452                         g_warning (error->message);
453
454                 g_clear_error (&error);
455         }
456         else
457                 goto success;
458
459         /* Do the [Global] lookup */
460         ret = parse_func (config_userprefs, "Global", property, value, &error);
461
462         if (error)
463         {
464                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
465                         g_warning (error->message);
466
467                 g_clear_error (&error);
468         }
469         else
470                 goto success;
471
472         /* Do the [terminal-defaults] lookup */
473         ret = parse_func (config_defaults, "terminal-defaults", property, value, &error);
474
475         if (error)
476         {
477                 if (error->code == G_KEY_FILE_ERROR_INVALID_VALUE)
478                         g_warning (error->message);
479
480                 g_clear_error (&error);
481
482                 /* This is somewhat of a nasty hack, but I really do want to just set the property to
483                  * NULL if there is no default, but ONLY for strings. */
484                 if (parse_func == tilda_config_parse_string)
485                 {
486                         g_value_set_string (value, NULL);
487                         goto success;
488                 }
489         }
490         else
491                 goto success;
492
493 //failure:
494         g_critical (_("Unable to find a value for terminal property: %s\n"), property);
495         g_free (value);
496         return FALSE;
497
498 success:
499         g_object_set_property (G_OBJECT(self), property, value);
500         g_value_unset (value);
501         g_free (value);
502         return TRUE;
503 }
504
505 gboolean
506 tilda_config_init (const gchar *userprefs_filename)
507 {
508         gchar *defaults_filename;
509         GError *error = NULL;
510
511         /* Call g_type_class_ref() on all enum types that are being used */
512         g_type_class_ref (vte_terminal_erase_binding_get_type());
513         g_type_class_ref (tilda_dynamic_title_get_type());
514         g_type_class_ref (tilda_child_exit_action_get_type());
515         g_type_class_ref (tilda_scrollbar_position_get_type());
516         g_type_class_ref (gtk_position_type_get_type());
517
518         /* Create the defaults file's path */
519         defaults_filename = g_build_filename ("share-tilda.conf", NULL); // FIXME: use /usr/share/tilda
520
521         /* Create the keyfiles */
522         config_defaults = g_key_file_new ();
523         config_userprefs = g_key_file_new ();
524
525         /* Check if the defaults exist, and load them */
526         if (!g_file_test (defaults_filename, G_FILE_TEST_EXISTS))
527         {
528                 g_critical (_("No configuration defaults file found. Tilda may not work.\n"));
529         }
530         else
531         {
532                 if (!g_key_file_load_from_file (config_defaults, defaults_filename, G_KEY_FILE_NONE, &error))
533                 {
534                         g_critical (_("Error reading configuration defaults: %s\n"), error->message);
535                         g_clear_error (&error);
536                 }
537         }
538
539         /* Check if the user's config exists, and load it */
540         if (!g_file_test (userprefs_filename, G_FILE_TEST_EXISTS))
541         {
542                 g_warning (_("No user configuration file found, using defaults\n"));
543         }
544         else
545         {
546                 if (!g_key_file_load_from_file (config_userprefs, userprefs_filename, G_KEY_FILE_NONE, &error))
547                 {
548                         g_warning (_("Error reading user configuration: %s\n"), error->message);
549                         g_clear_error (&error);
550                 }
551         }
552
553         /* This is just here for the future. Currently, it is acceptable to run without
554          * a configuration, though Tilda may not work very well. */
555         return TRUE;
556 }
557
558 /**
559  * Since we DO NOT allow writing to the configuration file from a Tilda
560  * process (only from the wizard), this does nothing more than free the
561  * defaults hashtable, and free the opened keyfile.
562  */
563 gboolean
564 tilda_config_free ()
565 {
566         /* Since we never write the config file from within Tilda,
567          * we can just close the files. */
568         g_key_file_free (config_defaults);
569         g_key_file_free (config_userprefs);
570
571         config_defaults = NULL;
572         config_userprefs = NULL;
573
574         return TRUE;
575 }
576
577 /* vim: set ts=4 sts=4 sw=4 noet tw=112: */