Line data Source code
1 : /********************************************************************\
2 : * gnc-gsettings.c -- utility functions for storing/retrieving *
3 : * data in the GSettings database for GnuCash *
4 : * Copyright (C) 2013 Geert Janssens <geert@kobaltwit.be> *
5 : * *
6 : * This program is free software; you can redistribute it and/or *
7 : * modify it under the terms of the GNU General Public License as *
8 : * published by the Free Software Foundation; either version 2 of *
9 : * the License, or (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, contact: *
18 : * *
19 : * Free Software Foundation Voice: +1-617-542-5942 *
20 : * 51 Franklin Street, Fifth Floor Fax: +1-617-542-2652 *
21 : * Boston, MA 02110-1301, USA gnu@gnu.org *
22 : * *
23 : \********************************************************************/
24 :
25 : #include <config.h>
26 :
27 :
28 : #include <gio/gio.h>
29 : #include <glib.h>
30 :
31 : #include <stdio.h>
32 : #include <string.h>
33 : #include "gnc-gsettings.h"
34 : #include "gnc-path.h"
35 : #include "qof.h"
36 : #include "gnc-prefs-p.h"
37 :
38 : #include <boost/property_tree/ptree.hpp>
39 : #include <boost/property_tree/xml_parser.hpp>
40 : #include <fstream>
41 : #include <iostream>
42 : #include <unordered_map>
43 :
44 : namespace bpt = boost::property_tree;
45 :
46 : #define GSET_SCHEMA_PREFIX "org.gnucash.GnuCash"
47 : #define GSET_SCHEMA_OLD_PREFIX "org.gnucash"
48 :
49 : struct GSettingsDeleter
50 : {
51 0 : void operator()(GSettings* gsp)
52 : {
53 0 : g_object_unref(gsp);
54 0 : }
55 : };
56 :
57 : static GSettingsDeleter g_settings_deleter;
58 :
59 : using GSettingsPtr = std::unique_ptr<GSettings, GSettingsDeleter>;
60 :
61 : static std::unordered_map<std::string,GSettingsPtr> schema_hash;
62 :
63 : /* This static indicates the debugging module that this .o belongs to. */
64 : static QofLogModule log_module = "gnc.app-utils.gsettings";
65 :
66 : /************************************************************/
67 : /* Internal helper functions */
68 : /************************************************************/
69 0 : static bool gnc_gsettings_is_valid_key(GSettings *settings, const gchar *key)
70 : {
71 : // Check if the key is valid key within settings
72 0 : if (!G_IS_SETTINGS(settings))
73 0 : return false;
74 :
75 : GSettingsSchema *schema;
76 0 : g_object_get (settings, "settings-schema", &schema, nullptr);
77 0 : if (!schema)
78 0 : return false;
79 :
80 0 : auto keys = g_settings_schema_list_keys (schema);
81 0 : auto found = (keys && g_strv_contains(keys, key));
82 0 : g_strfreev (keys);
83 0 : g_settings_schema_unref (schema);
84 :
85 0 : return found;
86 : }
87 :
88 : static std::string
89 0 : normalize_schema_name (const gchar *name)
90 : {
91 0 : if (!name)
92 0 : return GSET_SCHEMA_PREFIX;
93 :
94 0 : if (g_str_has_prefix (name, GSET_SCHEMA_PREFIX) ||
95 0 : (g_str_has_prefix (name, GSET_SCHEMA_OLD_PREFIX)))
96 0 : return name;
97 :
98 0 : return std::string{GSET_SCHEMA_PREFIX} + '.' + name;
99 : }
100 :
101 0 : static GSettings * gnc_gsettings_get_settings_obj (const gchar *schema_str)
102 : {
103 0 : ENTER("");
104 :
105 0 : auto full_name_str = normalize_schema_name (schema_str);
106 0 : auto full_name = full_name_str.c_str();
107 0 : auto schema_source {g_settings_schema_source_get_default()};
108 0 : g_return_val_if_fail(schema_source, nullptr);
109 :
110 0 : auto schema {g_settings_schema_source_lookup(schema_source, full_name, true)};
111 0 : g_return_val_if_fail(schema, nullptr);
112 :
113 0 : auto gset = g_settings_new_full (schema, nullptr, nullptr);
114 0 : DEBUG ("Created gsettings object %p for schema %s", gset, full_name);
115 :
116 0 : if (!G_IS_SETTINGS(gset))
117 0 : PWARN ("Ignoring attempt to access unknown gsettings schema %s", full_name);
118 :
119 0 : LEAVE("");
120 0 : g_settings_schema_unref (schema);
121 0 : return gset;
122 0 : }
123 :
124 : static GSettings*
125 0 : schema_to_gsettings (const char *schema, bool can_retrieve)
126 : {
127 0 : auto full_name = normalize_schema_name (schema);
128 0 : auto iter = schema_hash.find (full_name);
129 0 : if (iter != schema_hash.end())
130 0 : return iter->second.get();
131 :
132 0 : if (!can_retrieve)
133 0 : return nullptr;
134 :
135 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
136 0 : if (!G_IS_SETTINGS (gs_obj))
137 : {
138 0 : PWARN ("Ignoring attempt to access unknown gsettings schema %s", full_name.c_str());
139 0 : return nullptr;
140 : }
141 :
142 0 : schema_hash[full_name] = GSettingsPtr (gs_obj, g_settings_deleter);
143 0 : return gs_obj;
144 0 : }
145 :
146 : /************************************************************/
147 : /* GSettings Utilities */
148 : /************************************************************/
149 :
150 : const gchar *
151 0 : gnc_gsettings_get_prefix (void)
152 : {
153 0 : return GSET_SCHEMA_PREFIX;
154 : }
155 :
156 : /************************************************************/
157 : /* Change notification */
158 : /************************************************************/
159 :
160 : gulong
161 0 : gnc_gsettings_register_cb (const gchar *schema, const gchar *key,
162 : gpointer func,
163 : gpointer user_data)
164 : {
165 0 : ENTER("");
166 0 : g_return_val_if_fail (func, 0);
167 :
168 0 : auto gs_obj = schema_to_gsettings (schema, true);
169 0 : g_return_val_if_fail (G_IS_SETTINGS (gs_obj), 0);
170 :
171 0 : auto signal = static_cast<char *> (nullptr);
172 0 : if (!(key && *key))
173 0 : signal = g_strdup ("changed");
174 0 : else if (gnc_gsettings_is_valid_key(gs_obj, key))
175 0 : signal = g_strconcat ("changed::", key, nullptr);
176 :
177 0 : auto handlerid = g_signal_connect (gs_obj, signal, G_CALLBACK (func), user_data);
178 0 : if (handlerid)
179 : {
180 0 : g_object_ref (gs_obj);
181 :
182 0 : PINFO("schema: %s, key: %s, gs_obj: %p, handler_id: %ld",
183 : schema, key, gs_obj, handlerid);
184 : }
185 0 : g_free (signal);
186 :
187 0 : LEAVE("");
188 0 : return handlerid;
189 : }
190 :
191 :
192 : static void
193 0 : gnc_gsettings_remove_cb_by_id_internal (GSettings *gs_obj, guint handlerid)
194 : {
195 0 : ENTER ();
196 0 : g_return_if_fail (G_IS_SETTINGS (gs_obj));
197 :
198 0 : g_signal_handler_disconnect (gs_obj, handlerid);
199 0 : g_object_unref (gs_obj);
200 :
201 0 : LEAVE ("Schema: %p, handlerid: %d - removed for handler",
202 : gs_obj, handlerid);
203 : }
204 :
205 :
206 : void
207 0 : gnc_gsettings_remove_cb_by_func (const gchar *schema, const gchar *key,
208 : gpointer func, gpointer user_data)
209 : {
210 0 : ENTER ();
211 0 : g_return_if_fail (func);
212 :
213 0 : auto gs_obj = schema_to_gsettings (schema, false);
214 :
215 0 : if (!G_IS_SETTINGS (gs_obj))
216 : {
217 0 : LEAVE ("No valid GSettings object retrieved from hash table");
218 0 : return;
219 : }
220 :
221 0 : auto match_type = static_cast<GSignalMatchType> (G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA);
222 0 : auto changed_signal = g_signal_lookup ("changed", G_TYPE_SETTINGS); /* signal_id */
223 0 : auto quark = g_quark_from_string (key); /* signal_detail */
224 :
225 0 : auto matched = 0;
226 0 : guint handler_id = 0;
227 : do
228 : {
229 0 : handler_id = g_signal_handler_find (gs_obj, match_type,
230 : changed_signal, quark, nullptr,
231 : func, user_data);
232 0 : if (handler_id)
233 : {
234 0 : matched ++;
235 0 : gnc_gsettings_remove_cb_by_id_internal (gs_obj, handler_id);
236 :
237 : // Previous function will invalidate object if there is only one handler
238 0 : if (!G_IS_SETTINGS (gs_obj))
239 0 : handler_id = 0;
240 : }
241 0 : } while (handler_id);
242 :
243 0 : LEAVE ("Schema: %s, key: %s - removed %d handlers for 'changed' signal",
244 : schema, key, matched);
245 : }
246 :
247 :
248 : void
249 0 : gnc_gsettings_remove_cb_by_id (const gchar *schema, guint handlerid)
250 : {
251 0 : ENTER ();
252 :
253 0 : auto gs_obj = schema_to_gsettings (schema, false);
254 :
255 0 : if (!G_IS_SETTINGS (gs_obj))
256 : {
257 0 : LEAVE ("No valid GSettings object retrieved from hash table");
258 0 : return;
259 : }
260 :
261 0 : gnc_gsettings_remove_cb_by_id_internal (gs_obj, handlerid);
262 :
263 0 : LEAVE ("Schema: %p, handlerid: %d - removed for handler",
264 : gs_obj, handlerid);
265 : }
266 :
267 :
268 : guint
269 0 : gnc_gsettings_register_any_cb (const gchar *schema,
270 : gpointer func,
271 : gpointer user_data)
272 : {
273 0 : return gnc_gsettings_register_cb (schema, nullptr, func, user_data);
274 : }
275 :
276 :
277 : void
278 0 : gnc_gsettings_remove_any_cb_by_func (const gchar *schema,
279 : gpointer func,
280 : gpointer user_data)
281 : {
282 0 : gnc_gsettings_remove_cb_by_func (schema, nullptr, func, user_data);
283 0 : }
284 :
285 :
286 0 : static gboolean gnc_gsettings_enum_bool_mapping_get (GValue *value,
287 : GVariant *variant,
288 : gpointer user_data)
289 : {
290 0 : g_value_set_boolean (value,
291 0 : !g_strcmp0 ((const gchar *)user_data,
292 : g_variant_get_string (variant, nullptr)));
293 :
294 0 : return true;
295 : }
296 :
297 0 : static GVariant* gnc_gsettings_enum_bool_mapping_set (const GValue *value,
298 : const GVariantType *expected_type,
299 : gpointer user_data)
300 : {
301 0 : if (g_value_get_boolean (value))
302 : {
303 0 : return g_variant_new_string ((const gchar *)user_data);
304 : }
305 : else
306 : {
307 : /* GtkRadioButtons will set the value to false when another option is
308 : * selected, just ignore this. */
309 0 : return nullptr;
310 : }
311 : }
312 :
313 0 : void gnc_gsettings_bind (const gchar *schema,
314 : /*@ null @*/ const gchar *key,
315 : /*@ null @*/ const gchar *value,
316 : gpointer object,
317 : const gchar *property)
318 : {
319 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
320 0 : g_return_if_fail (G_IS_SETTINGS (gs_obj));
321 :
322 0 : if (gnc_gsettings_is_valid_key (gs_obj, key))
323 : {
324 0 : if (value)
325 : {
326 0 : g_settings_bind_with_mapping (gs_obj, key, object, property,
327 : G_SETTINGS_BIND_DEFAULT,
328 : gnc_gsettings_enum_bool_mapping_get,
329 : gnc_gsettings_enum_bool_mapping_set,
330 0 : g_strdup (value), g_free);
331 : }
332 : else
333 : {
334 0 : g_settings_bind (gs_obj, key, object, property, G_SETTINGS_BIND_DEFAULT);
335 : }
336 : }
337 : else
338 : {
339 0 : PERR ("Invalid key %s for schema %s", key, schema);
340 : }
341 : }
342 :
343 :
344 : static void
345 0 : gs_obj_block_handlers ([[maybe_unused]] gpointer key, gpointer gs_obj,
346 : [[maybe_unused]] gpointer pointer)
347 : {
348 0 : g_signal_handlers_block_matched (gs_obj, G_SIGNAL_MATCH_CLOSURE, 0, 0, nullptr, nullptr, nullptr);
349 0 : PINFO("Block all handlers for GSettings object %p", gs_obj);
350 0 : }
351 :
352 : static void
353 0 : gs_obj_unblock_handlers ([[maybe_unused]] gpointer key, gpointer gs_obj,
354 : [[maybe_unused]] gpointer pointer)
355 : {
356 0 : g_signal_handlers_unblock_matched (gs_obj, G_SIGNAL_MATCH_CLOSURE, 0, 0, nullptr, nullptr, nullptr);
357 0 : PINFO("Unblock all handlers for GSettings object %p", gs_obj);
358 0 : }
359 :
360 0 : void gnc_gsettings_block_all (void)
361 : {
362 0 : ENTER ();
363 0 : for (const auto& it : schema_hash)
364 0 : gs_obj_block_handlers (nullptr, it.second.get(), nullptr);
365 0 : LEAVE();
366 0 : }
367 :
368 :
369 0 : void gnc_gsettings_unblock_all (void)
370 : {
371 0 : ENTER ();
372 0 : for (const auto& it : schema_hash)
373 0 : gs_obj_unblock_handlers (nullptr, it.second.get(), nullptr);
374 0 : LEAVE();
375 0 : }
376 :
377 :
378 : /************************************************************/
379 : /* Getters */
380 : /************************************************************/
381 : template<typename T>
382 0 : T gnc_gsettings_get(const char *schema, const char *key,
383 : auto getter(GSettings*, const char *)->T, T default_val)
384 : {
385 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
386 0 : g_return_val_if_fail (G_IS_SETTINGS (gs_obj), default_val);
387 :
388 0 : T val = default_val;
389 0 : if (gnc_gsettings_is_valid_key (gs_obj, key))
390 0 : val = getter (gs_obj, key);
391 : else
392 0 : PERR ("Invalid key %s for schema %s", key, schema);
393 :
394 0 : g_object_unref (gs_obj);
395 0 : return val;
396 : }
397 :
398 : gboolean
399 0 : gnc_gsettings_get_bool (const gchar *schema, const gchar *key)
400 : {
401 0 : return gnc_gsettings_get (schema, key, g_settings_get_boolean,
402 0 : static_cast<gboolean>(false));
403 : }
404 :
405 : gint
406 0 : gnc_gsettings_get_int (const gchar *schema, const gchar *key)
407 : {
408 0 : return gnc_gsettings_get (schema, key, g_settings_get_int, 0);
409 : }
410 :
411 : gdouble
412 0 : gnc_gsettings_get_float (const gchar *schema, const gchar *key)
413 : {
414 0 : return gnc_gsettings_get (schema, key, g_settings_get_double, 0.0);
415 : }
416 :
417 : gchar *
418 0 : gnc_gsettings_get_string (const gchar *schema, const gchar *key)
419 : {
420 0 : return gnc_gsettings_get (schema, key, g_settings_get_string,
421 0 : static_cast<gchar *> (nullptr));
422 : }
423 :
424 : gint
425 0 : gnc_gsettings_get_enum (const gchar *schema, const gchar *key)
426 : {
427 0 : return gnc_gsettings_get (schema, key, g_settings_get_enum, 0);
428 : }
429 :
430 : GVariant *
431 0 : gnc_gsettings_get_value (const gchar *schema, const gchar *key)
432 : {
433 0 : return gnc_gsettings_get (schema, key, g_settings_get_value,
434 0 : static_cast<GVariant *> (nullptr));
435 : }
436 :
437 : /************************************************************/
438 : /* Setters */
439 : /************************************************************/
440 : template<typename T> gboolean
441 0 : gnc_gsettings_set (const gchar *schema,
442 : const gchar *key,
443 : T value,
444 : gboolean setter(GSettings*, const char *, T))
445 : {
446 0 : ENTER("schema: %s, key: %s", schema, key);
447 :
448 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
449 0 : g_return_val_if_fail (G_IS_SETTINGS (gs_obj), false);
450 :
451 0 : auto result = false;
452 0 : if (gnc_gsettings_is_valid_key (gs_obj, key))
453 : {
454 0 : result = setter (gs_obj, key, value);
455 0 : if (!result)
456 0 : PERR ("Unable to set value for key %s in schema %s", key, schema);
457 : }
458 : else
459 0 : PERR ("Invalid key %s for schema %s", key, schema);
460 :
461 0 : g_object_unref (gs_obj);
462 0 : LEAVE("result %i", result);
463 0 : return result;
464 : }
465 :
466 : gboolean
467 0 : gnc_gsettings_set_bool (const gchar *schema, const gchar *key, gboolean value)
468 : {
469 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_boolean);
470 : }
471 :
472 : gboolean
473 0 : gnc_gsettings_set_int (const gchar *schema, const gchar *key, gint value)
474 : {
475 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_int);
476 : }
477 :
478 : gboolean
479 0 : gnc_gsettings_set_float (const gchar *schema, const gchar *key, gdouble value)
480 : {
481 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_double);
482 : }
483 :
484 : gboolean
485 0 : gnc_gsettings_set_string (const gchar *schema, const gchar *key, const gchar *value)
486 : {
487 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_string);
488 : }
489 :
490 : gboolean
491 0 : gnc_gsettings_set_enum (const gchar *schema, const gchar *key, gint value)
492 : {
493 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_enum);
494 : }
495 :
496 : gboolean
497 0 : gnc_gsettings_set_value (const gchar *schema, const gchar *key, GVariant *value)
498 : {
499 0 : return gnc_gsettings_set (schema, key, value, g_settings_set_value);
500 : }
501 :
502 : void
503 0 : gnc_gsettings_reset (const gchar *schema,
504 : const gchar *key)
505 : {
506 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
507 0 : g_return_if_fail (G_IS_SETTINGS (gs_obj));
508 :
509 0 : if (gnc_gsettings_is_valid_key (gs_obj, key))
510 0 : g_settings_reset (gs_obj, key);
511 : else
512 0 : PERR ("Invalid key %s for schema %s", key, schema);
513 :
514 0 : g_object_unref (gs_obj);
515 : }
516 :
517 : void
518 0 : gnc_gsettings_reset_schema (const gchar *schema_str)
519 : {
520 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema_str);
521 :
522 0 : if (!gs_obj)
523 0 : return;
524 :
525 : GSettingsSchema *schema;
526 0 : g_object_get (gs_obj, "settings-schema", &schema, nullptr);
527 0 : if (!schema)
528 : {
529 0 : g_object_unref (gs_obj);
530 0 : return;
531 : }
532 :
533 0 : auto keys = g_settings_schema_list_keys (schema);
534 0 : if (keys)
535 : {
536 0 : auto fkeys = keys;
537 0 : for (auto key = *fkeys; key; key = *++fkeys)
538 0 : gnc_gsettings_reset (schema_str, key);
539 : }
540 :
541 0 : g_object_unref (gs_obj);
542 0 : g_settings_schema_unref (schema);
543 0 : g_strfreev (keys);
544 : }
545 :
546 : static void
547 0 : gnc_settings_dump_schema_paths (void)
548 : {
549 : gchar **non_relocatable;
550 :
551 0 : auto schema_source {g_settings_schema_source_get_default()};
552 0 : g_return_if_fail(schema_source);
553 :
554 0 : g_settings_schema_source_list_schemas (schema_source, true,
555 : &non_relocatable, nullptr);
556 :
557 0 : for (gint i = 0; non_relocatable[i] != nullptr; i++)
558 0 : PINFO("Schema entry %d is '%s'", i, non_relocatable[i]);
559 :
560 0 : g_strfreev (non_relocatable);
561 : }
562 :
563 1 : void gnc_gsettings_load_backend (void)
564 : {
565 1 : ENTER("");
566 :
567 : /* The gsettings backend only works in an installed environment.
568 : * When called from the source environment (for testing purposes)
569 : * simply return.
570 : */
571 1 : if (g_strcmp0 (g_getenv ("GNC_UNINSTALLED"), "1") == 0)
572 1 : return;
573 :
574 0 : g_free (prefsbackend);
575 0 : prefsbackend = g_new0 (PrefsBackend, 1);
576 :
577 0 : prefsbackend->register_cb = gnc_gsettings_register_cb;
578 0 : prefsbackend->remove_cb_by_func = gnc_gsettings_remove_cb_by_func;
579 0 : prefsbackend->remove_cb_by_id = gnc_gsettings_remove_cb_by_id;
580 0 : prefsbackend->register_group_cb = gnc_gsettings_register_any_cb;
581 0 : prefsbackend->remove_group_cb_by_func = gnc_gsettings_remove_any_cb_by_func;
582 0 : prefsbackend->bind = gnc_gsettings_bind;
583 0 : prefsbackend->get_bool = gnc_gsettings_get_bool;
584 0 : prefsbackend->get_int = gnc_gsettings_get_int;
585 0 : prefsbackend->get_float = gnc_gsettings_get_float;
586 0 : prefsbackend->get_string = gnc_gsettings_get_string;
587 0 : prefsbackend->get_enum = gnc_gsettings_get_enum;
588 0 : prefsbackend->get_value = gnc_gsettings_get_value;
589 0 : prefsbackend->set_bool = gnc_gsettings_set_bool;
590 0 : prefsbackend->set_int = gnc_gsettings_set_int;
591 0 : prefsbackend->set_float = gnc_gsettings_set_float;
592 0 : prefsbackend->set_string = gnc_gsettings_set_string;
593 0 : prefsbackend->set_enum = gnc_gsettings_set_enum;
594 0 : prefsbackend->set_value = gnc_gsettings_set_value;
595 0 : prefsbackend->reset = gnc_gsettings_reset;
596 0 : prefsbackend->reset_group = gnc_gsettings_reset_schema;
597 0 : prefsbackend->block_all = gnc_gsettings_block_all;
598 0 : prefsbackend->unblock_all = gnc_gsettings_unblock_all;
599 :
600 0 : if (qof_log_check (log_module, QOF_LOG_DEBUG))
601 0 : gnc_settings_dump_schema_paths ();
602 :
603 : /* Run any data model changes for the backend before it's used
604 : * by anyone */
605 0 : gnc_gsettings_version_upgrade();
606 :
607 0 : LEAVE("Prefsbackend bind = %p", prefsbackend->bind);
608 : }
609 :
610 : void
611 0 : gnc_gsettings_shutdown (void)
612 : {
613 0 : schema_hash.clear();
614 0 : g_free (prefsbackend);
615 0 : }
616 :
617 :
618 : static GVariant *
619 0 : gnc_gsettings_get_user_value (const gchar *schema,
620 : const gchar *key)
621 : {
622 0 : auto gs_obj = gnc_gsettings_get_settings_obj (schema);
623 0 : g_return_val_if_fail (G_IS_SETTINGS (gs_obj), nullptr);
624 :
625 0 : auto val = static_cast<GVariant *> (nullptr);
626 0 : if (gnc_gsettings_is_valid_key (gs_obj, key))
627 0 : val = g_settings_get_user_value (gs_obj, key);
628 : else
629 0 : PERR ("Invalid key %s for schema %s", key, schema);
630 :
631 0 : g_object_unref (gs_obj);
632 0 : return val;
633 : }
634 :
635 : using opt_str_vec = boost::optional<std::string>;
636 :
637 : static void
638 0 : deprecate_one_key (const opt_str_vec &oldpath, const opt_str_vec &oldkey)
639 : {
640 0 : if (!oldpath || !oldkey )
641 : {
642 0 : DEBUG ("Skipping <deprecate> node - missing attribute (old-path or old-key)");
643 0 : return;
644 : }
645 :
646 0 : PINFO ("'%s:%s' has been marked deprecated", oldpath->c_str(), oldkey->c_str());
647 : /* This does nothing really, but is a reminder for future maintainers
648 : * to mark this pref as obsolete in the next major release. */
649 : }
650 :
651 : static void
652 0 : migrate_one_key (const opt_str_vec &oldpath, const opt_str_vec &oldkey,
653 : const opt_str_vec &newpath, const opt_str_vec &newkey)
654 : {
655 0 : if (!oldpath || !oldkey || !newpath || !newkey)
656 : {
657 0 : DEBUG ("Skipping <migrate> node - missing attribute (old-path, old-key, new-path or new-key)");
658 0 : return;
659 : }
660 :
661 0 : PINFO ("Migrating '%s:%s' to '%s:%s'", oldpath->c_str(), oldkey->c_str(),
662 : newpath->c_str(), newkey->c_str());
663 :
664 0 : auto user_value = gnc_gsettings_get_user_value (oldpath->c_str(), oldkey->c_str());
665 0 : if (user_value)
666 0 : gnc_gsettings_set_value (newpath->c_str(), newkey->c_str(), user_value);
667 : }
668 :
669 : static void
670 0 : obsolete_one_key (const opt_str_vec &oldpath, const opt_str_vec &oldkey)
671 : {
672 0 : if (!oldpath || !oldkey )
673 : {
674 0 : DEBUG ("Skipping <obsolete> node - missing attribute (old-path or old-key)");
675 0 : return;
676 : }
677 :
678 0 : PINFO ("Resetting obsolete '%s:%s'", oldpath->c_str(), oldkey->c_str());
679 0 : gnc_gsettings_reset (oldpath->c_str(), oldkey->c_str());
680 : }
681 :
682 : static void
683 0 : parse_one_release_node (bpt::ptree &pt)
684 : {
685 : /* loop over top-level property tree */
686 0 : std::for_each (pt.begin(), pt.end(),
687 0 : [] (std::pair<bpt::ptree::key_type, bpt::ptree> node)
688 : {
689 0 : if (node.first == "<xmlattr>")
690 0 : return;
691 0 : else if (node.first == "deprecate")
692 0 : deprecate_one_key (node.second.get_optional<std::string> ("<xmlattr>.old-path"),
693 0 : node.second.get_optional<std::string> ("<xmlattr>.old-key"));
694 0 : else if (node.first == "migrate")
695 0 : migrate_one_key (node.second.get_optional<std::string> ("<xmlattr>.old-path"),
696 0 : node.second.get_optional<std::string> ("<xmlattr>.old-key"),
697 0 : node.second.get_optional<std::string> ("<xmlattr>.new-path"),
698 0 : node.second.get_optional<std::string> ("<xmlattr>.new-key"));
699 0 : else if (node.first == "obsolete")
700 0 : obsolete_one_key (node.second.get_optional<std::string> ("<xmlattr>.old-path"),
701 0 : node.second.get_optional<std::string> ("<xmlattr>.old-key"));
702 : else
703 : {
704 0 : DEBUG ("Skipping unknown node <%s>", node.first.c_str());
705 0 : return;
706 : }
707 : });
708 0 : }
709 :
710 : static void
711 0 : transform_settings (int old_maj_min, int cur_maj_min)
712 : {
713 0 : bpt::ptree pt;
714 :
715 0 : auto pkg_data_dir = gnc_path_get_pkgdatadir();
716 0 : auto transform_file = std::string (pkg_data_dir) + "/pref_transformations.xml";
717 0 : g_free (pkg_data_dir);
718 :
719 0 : std::ifstream transform_stream {transform_file};
720 0 : if (!transform_stream.is_open())
721 : {
722 0 : PWARN("Failed to load preferences transformation file '%s'", transform_file.c_str());
723 0 : return;
724 : }
725 :
726 : try
727 : {
728 0 : bpt::read_xml (transform_stream, pt);
729 : }
730 0 : catch (bpt::xml_parser_error &e) {
731 0 : PWARN ("Failed to parse GnuCash preferences transformation file.\n");
732 0 : PWARN ("Error message:\n");
733 0 : PWARN ("%s\n", e.what());
734 0 : return;
735 0 : }
736 0 : catch (...) {
737 0 : PWARN ("Unknown error while parsing GnuCash preferences transformation file.\n");
738 0 : return;
739 0 : }
740 :
741 : /* loop over top-level property tree */
742 0 : std::for_each (pt.begin(), pt.end(),
743 0 : [&old_maj_min, &cur_maj_min] (std::pair<bpt::ptree::key_type, bpt::ptree> node)
744 : {
745 0 : if (node.first != "release")
746 : {
747 0 : DEBUG ("Skipping non-<release> node <%s>", node.first.c_str());
748 0 : return;
749 : }
750 0 : auto version = node.second.get_optional<int> ("<xmlattr>.version");
751 0 : if (!version)
752 : {
753 0 : DEBUG ("Skipping <release> node - no version attribute found");
754 0 : return;
755 : }
756 0 : if (*version <= old_maj_min)
757 : {
758 0 : DEBUG ("Skipping <release> node - version %i is less than current compatibility level %i", *version, old_maj_min);
759 0 : return;
760 : }
761 0 : if (*version > cur_maj_min)
762 : {
763 0 : DEBUG ("Skipping <release> node - version %i is greater than current version level %i", *version, cur_maj_min);
764 0 : return;
765 : }
766 0 : DEBUG ("Retrieved version value '%i'", *version);
767 :
768 0 : parse_one_release_node (node.second);
769 : });
770 0 : }
771 :
772 0 : void gnc_gsettings_version_upgrade (void)
773 : {
774 : /* This routine will conditionally execute conversion rules from
775 : * prefs_transformations.xml to adapt the user's existing preferences to
776 : * the current preferences schema. The rules in this file are versioned and
777 : * only rules still relevant to the user's existing preferences and for
778 : * this version of GnuCash will be executed.
779 : *
780 : * Starting with GnuCash 4.7 the code expects all preferences to be stored
781 : * under prefix org.gnucash.GnuCash instead of org.gnucash, including our
782 : * GNC_PREF_VERSION setting.
783 : * As the logic to determine whether or not settings conversions are needed
784 : * depends on this preference, we have to test for its value in two
785 : * locations:
786 : * - if GNC_PREF_VERSION is not set under old nor new prefix
787 : * => GnuCash has never run before so no conversion run necessary
788 : * - if GNC_PREF_VERSION is set under old prefix and not new prefix
789 : * => user's preferences weren't moved yet from old to new prefix. Use old
790 : * prefix GNC_PREF_VERSION to determine which conversions may be needed
791 : * - if GNC_PREF_VERSION is set under both prefixes
792 : * => ignore old prefix and use new prefix GNC_PREF_VERSION to determine
793 : * which conversions may be needed.
794 : * Sometime in the future (GnuCash 6.0) the old prefix will be fully removed
795 : * and the test will be simplified to only check in the new prefix.
796 : */
797 0 : ENTER("Start of settings transform routine.");
798 :
799 0 : auto ogG_maj_min = gnc_gsettings_get_user_value (GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION);
800 0 : auto og_maj_min = gnc_gsettings_get_user_value (GSET_SCHEMA_OLD_PREFIX "." GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION);
801 :
802 0 : auto cur_maj_min = PROJECT_VERSION_MAJOR * 1000 + PROJECT_VERSION_MINOR;
803 :
804 0 : if (!ogG_maj_min && !og_maj_min) // new install
805 : {
806 0 : gnc_gsettings_set_int (GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION, cur_maj_min);
807 0 : LEAVE ("Setting Previous compatibility level to current version: %i", cur_maj_min);
808 0 : return;
809 : }
810 :
811 0 : auto old_maj_min = 0;
812 0 : if (!ogG_maj_min) // old preference location
813 0 : old_maj_min = gnc_gsettings_get_int (GSET_SCHEMA_OLD_PREFIX "." GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION);
814 : else // new preference location
815 : {
816 0 : g_variant_unref (ogG_maj_min);
817 0 : old_maj_min = gnc_gsettings_get_int (GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION);
818 : }
819 0 : if (og_maj_min)
820 0 : g_variant_unref (og_maj_min);
821 :
822 0 : PINFO ("Previous setting compatibility level: %i, Current version: %i", old_maj_min, cur_maj_min);
823 :
824 0 : transform_settings (old_maj_min, cur_maj_min);
825 :
826 : /* Only write current version if it's more recent than what was set */
827 0 : if (cur_maj_min > old_maj_min)
828 0 : gnc_gsettings_set_int (GNC_PREFS_GROUP_GENERAL, GNC_PREF_VERSION, cur_maj_min);
829 :
830 0 : LEAVE("");
831 : }
|
