src/gnumeric-conf.c

   1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * gnumeric-conf.c:
   4  *
   5  * Author:
   6  *      Andreas J. Guelzow <aguelzow@pyrshep.ca>
   7  *
   8  * (C) Copyright 2002-2005 Andreas J. Guelzow <aguelzow@pyrshep.ca>
   9  * (C) Copyright 2009-2011 Morten Welinder <terra@gnome.org>
  10  *
  11  * Introduced the concept of "node" and implemented the win32 backend
  12  * by Ivan, Wong Yat Cheung <email@ivanwong.info>, 2005
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  26  */
  27
  28 #include <gnumeric-config.h>
  29 #include <gnumeric.h>
  30 #include "application.h"
  31 #include "gnumeric-conf.h"
  32 #include "gutils.h"
  33 #include "mstyle.h"
  34 #include <goffice/goffice.h>
  35 #include <value.h>
  36 #include <number-match.h>
  37 #include <string.h>
  38 #include <sheet.h>
  39 #include <print-info.h>
  40 #include <glib/gi18n-lib.h>
  41
  42 #define NO_DEBUG_GCONF
  43 #ifndef NO_DEBUG_GCONF
  44 #define d(code) { code; }
  45 #else
  46 #define d(code)
  47 #endif
  48
  49 #define GNM_CONF_DIR "gnumeric"
  50
  51 static GOConfNode *root = NULL;
  52
  53 /*
  54  * Hashes to simplify ownership rules.  We use this so none of the getters
  55  * have to return memory that the callers need to free.
  56   */
  57 static GHashTable *string_pool;
  58 static GHashTable *string_list_pool;
  59 static GHashTable *node_pool, *node_watch;
  60
  61 static gboolean debug_getters;
  62 static gboolean debug_setters;
  63 #define MAYBE_DEBUG_GET(key) do {                               \
  64         if (debug_getters) g_printerr ("conf-get: %s\n", key);  \
  65 } while (0)
  66 #define MAYBE_DEBUG_SET(key) do {                               \
  67         if (debug_setters) g_printerr ("conf-set: %s\n", key);  \
  68 } while (0)
  69
  70
  71 static guint sync_handler;
  72
  73 static gboolean
  74 cb_sync (void)
  75 {
  76         go_conf_sync (root);
  77         sync_handler = 0;
  78         return FALSE;
  79 }
  80
  81 static void
  82 schedule_sync (void)
  83 {
  84         if (sync_handler)
  85                 return;
  86
  87         sync_handler = g_timeout_add (200, (GSourceFunc)cb_sync, NULL);
  88 }
  89
  90 /* -------------------------------------------------------------------------- */
  91
  92 static GSList *watchers;
  93
  94 struct cb_watch_generic {
  95         guint handler;
  96         const char *key;
  97         const char *short_desc;
  98         const char *long_desc;
  99 };
 100
 101 static void
 102 free_watcher (struct cb_watch_generic *watcher)
 103 {
 104         go_conf_remove_monitor (watcher->handler);
 105 }
 106
 107 /* ---------------------------------------- */
 108
 109 GOConfNode *
 110 gnm_conf_get_root (void)
 111 {
 112         return root;
 113 }
 114
 115 static GOConfNode *
 116 get_node (const char *key, gpointer watch)
 117 {
 118         GOConfNode *res = g_hash_table_lookup (node_pool, key);
 119         if (!res) {
 120                 res = go_conf_get_node (key[0] == '/' ? NULL : root, key);
 121                 g_hash_table_insert (node_pool, (gpointer)key, res);
 122                 if (watch)
 123                         g_hash_table_insert (node_watch, res, watch);
 124         }
 125         return res;
 126 }
 127
 128 static GOConfNode *
 129 get_watch_node (gpointer watch_)
 130 {
 131         struct cb_watch_generic *watch = watch_;
 132         return get_node (watch->key, watch);
 133 }
 134
 135 char const *
 136 gnm_conf_get_short_desc (GOConfNode *node)
 137 {
 138         struct cb_watch_generic *watch =
 139                 g_hash_table_lookup (node_watch, node);
 140         const char *desc = watch ? watch->short_desc : NULL;
 141         return desc ? _(desc) : NULL;
 142 }
 143
 144 char const *
 145 gnm_conf_get_long_desc (GOConfNode *node)
 146 {
 147         struct cb_watch_generic *watch =
 148                 g_hash_table_lookup (node_watch, node);
 149         const char *desc = watch ? watch->long_desc : NULL;
 150         return desc ? _(desc) : NULL;
 151 }
 152
 153 /* -------------------------------------------------------------------------- */
 154
 155 struct cb_watch_bool {
 156         guint handler;
 157         const char *key;
 158         const char *short_desc;
 159         const char *long_desc;
 160         gboolean defalt;
 161         gboolean var;
 162 };
 163
 164 static void
 165 cb_watch_bool (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 166 {
 167         struct cb_watch_bool *watch = user;
 168         watch->var = go_conf_load_bool (node, NULL, watch->defalt);
 169 }
 170
 171 static void
 172 watch_bool (struct cb_watch_bool *watch)
 173 {
 174         GOConfNode *node = get_node (watch->key, watch);
 175         watch->handler = go_conf_add_monitor
 176                 (node, NULL, cb_watch_bool, watch);
 177         watchers = g_slist_prepend (watchers, watch);
 178         cb_watch_bool (node, NULL, watch);
 179         MAYBE_DEBUG_GET (watch->key);
 180 }
 181
 182 static void
 183 set_bool (struct cb_watch_bool *watch, gboolean x)
 184 {
 185         x = (x != FALSE);
 186         if (x == watch->var)
 187                 return;
 188
 189         MAYBE_DEBUG_SET (watch->key);
 190         watch->var = x;
 191         go_conf_set_bool (root, watch->key, x);
 192         schedule_sync ();
 193 }
 194
 195 /* ---------------------------------------- */
 196
 197 struct cb_watch_int {
 198         guint handler;
 199         const char *key;
 200         const char *short_desc;
 201         const char *long_desc;
 202         int min, max, defalt;
 203         int var;
 204 };
 205
 206 static void
 207 cb_watch_int (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 208 {
 209         struct cb_watch_int *watch = user;
 210         watch->var = go_conf_load_int (node, NULL,
 211                                        watch->min, watch->max,
 212                                        watch->defalt);
 213 }
 214
 215 static void
 216 watch_int (struct cb_watch_int *watch)
 217 {
 218         GOConfNode *node = get_node (watch->key, watch);
 219         watch->handler = go_conf_add_monitor
 220                 (node, NULL, cb_watch_int, watch);
 221         watchers = g_slist_prepend (watchers, watch);
 222         cb_watch_int (node, NULL, watch);
 223         MAYBE_DEBUG_GET (watch->key);
 224 }
 225
 226 static void
 227 set_int (struct cb_watch_int *watch, int x)
 228 {
 229         x = CLAMP (x, watch->min, watch->max);
 230
 231         if (x == watch->var)
 232                 return;
 233
 234         MAYBE_DEBUG_SET (watch->key);
 235         watch->var = x;
 236         go_conf_set_int (root, watch->key, x);
 237         schedule_sync ();
 238 }
 239
 240 /* ---------------------------------------- */
 241
 242 struct cb_watch_double {
 243         guint handler;
 244         const char *key;
 245         const char *short_desc;
 246         const char *long_desc;
 247         double min, max, defalt;
 248         double var;
 249 };
 250
 251 static void
 252 cb_watch_double (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 253 {
 254         struct cb_watch_double *watch = user;
 255         watch->var = go_conf_load_double (node, NULL,
 256                                           watch->min, watch->max,
 257                                           watch->defalt);
 258 }
 259
 260 static void
 261 watch_double (struct cb_watch_double *watch)
 262 {
 263         GOConfNode *node = get_node (watch->key, watch);
 264         watch->handler = go_conf_add_monitor
 265                 (node, NULL, cb_watch_double, watch);
 266         watchers = g_slist_prepend (watchers, watch);
 267         cb_watch_double (node, NULL, watch);
 268         MAYBE_DEBUG_GET (watch->key);
 269 }
 270
 271 static void
 272 set_double (struct cb_watch_double *watch, double x)
 273 {
 274         x = CLAMP (x, watch->min, watch->max);
 275
 276         if (x == watch->var)
 277                 return;
 278
 279         MAYBE_DEBUG_SET (watch->key);
 280         watch->var = x;
 281         go_conf_set_double (root, watch->key, x);
 282         schedule_sync ();
 283 }
 284
 285 /* ---------------------------------------- */
 286
 287 struct cb_watch_string {
 288         guint handler;
 289         const char *key;
 290         const char *short_desc;
 291         const char *long_desc;
 292         const char *defalt;
 293         const char *var;
 294 };
 295
 296 static void
 297 cb_watch_string (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 298 {
 299         struct cb_watch_string *watch = user;
 300         char *res = go_conf_load_string (node, NULL);
 301         if (!res) res = g_strdup (watch->defalt);
 302         g_hash_table_replace (string_pool, (gpointer)watch->key, res);
 303         watch->var = res;
 304 }
 305
 306 static void
 307 watch_string (struct cb_watch_string *watch)
 308 {
 309         GOConfNode *node = get_node (watch->key, watch);
 310         watch->handler = go_conf_add_monitor
 311                 (node, NULL, cb_watch_string, watch);
 312         watchers = g_slist_prepend (watchers, watch);
 313         cb_watch_string (node, NULL, watch);
 314         MAYBE_DEBUG_GET (watch->key);
 315 }
 316
 317 static void
 318 set_string (struct cb_watch_string *watch, const char *x)
 319 {
 320         char *xc;
 321
 322         if (!x || !watch->var || strcmp (x, watch->var) == 0)
 323                 return;
 324
 325         MAYBE_DEBUG_SET (watch->key);
 326         xc = g_strdup (x);
 327         watch->var = xc;
 328         /* Update pool before setting so monitors see the right value.  */
 329         g_hash_table_replace (string_pool, (gpointer)watch->key, xc);
 330         go_conf_set_string (root, watch->key, xc);
 331         schedule_sync ();
 332 }
 333
 334 /* ---------------------------------------- */
 335
 336 struct cb_watch_string_list {
 337         guint handler;
 338         const char *key;
 339         const char *short_desc;
 340         const char *long_desc;
 341         GSList *var;
 342 };
 343
 344 static void
 345 cb_watch_string_list (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 346 {
 347         struct cb_watch_string_list *watch = user;
 348         GSList *res = go_conf_load_str_list (node, NULL);
 349         g_hash_table_replace (string_list_pool, (gpointer)watch->key, res);
 350         watch->var = res;
 351 }
 352
 353 static void
 354 watch_string_list (struct cb_watch_string_list *watch)
 355 {
 356         GOConfNode *node = get_node (watch->key, watch);
 357         watch->handler = go_conf_add_monitor
 358                 (node, NULL, cb_watch_string_list, watch);
 359         watchers = g_slist_prepend (watchers, watch);
 360         cb_watch_string_list (node, NULL, watch);
 361         MAYBE_DEBUG_GET (watch->key);
 362 }
 363
 364 static gboolean
 365 string_list_equal (GSList *x, GSList *y)
 366 {
 367         while (x && y) {
 368                 if (strcmp (x->data, y->data) != 0)
 369                         return FALSE;
 370                 x = x->next;
 371                 y = y->next;
 372         }
 373
 374         return x == y;
 375 }
 376
 377 static void
 378 set_string_list (struct cb_watch_string_list *watch, GSList *x)
 379 {
 380         if (string_list_equal (x, watch->var))
 381                 return;
 382
 383         x = go_string_slist_copy (x);
 384
 385         MAYBE_DEBUG_SET (watch->key);
 386         watch->var = x;
 387         /* Update pool before setting so monitors see the right value.  */
 388         g_hash_table_replace (string_list_pool, (gpointer)watch->key, x);
 389         go_conf_set_str_list (root, watch->key, x);
 390         schedule_sync ();
 391 }
 392
 393 /* ---------------------------------------- */
 394
 395 struct cb_watch_enum {
 396         guint handler;
 397         const char *key;
 398         const char *short_desc;
 399         const char *long_desc;
 400         int defalt;
 401         GType typ;
 402         int var;
 403 };
 404
 405 static void
 406 cb_watch_enum (GOConfNode *node, G_GNUC_UNUSED const char *key, gpointer user)
 407 {
 408         struct cb_watch_enum *watch = user;
 409         watch->var = go_conf_load_enum (node, NULL,
 410                                         watch->typ, watch->defalt);
 411 }
 412
 413 static void
 414 watch_enum (struct cb_watch_enum *watch, GType typ)
 415 {
 416         GOConfNode *node = get_node (watch->key, watch);
 417         watch->typ = typ;
 418         watch->handler = go_conf_add_monitor
 419                 (node, NULL, cb_watch_enum, watch);
 420         watchers = g_slist_prepend (watchers, watch);
 421         cb_watch_enum (node, NULL, watch);
 422         MAYBE_DEBUG_GET (watch->key);
 423 }
 424
 425 static void
 426 set_enum (struct cb_watch_enum *watch, int x)
 427 {
 428         if (x == watch->var)
 429                 return;
 430
 431         MAYBE_DEBUG_SET (watch->key);
 432         watch->var = x;
 433         go_conf_set_enum (root, watch->key, watch->typ, x);
 434         schedule_sync ();
 435 }
 436
 437 /* -------------------------------------------------------------------------- */
 438
 439 static void
 440 cb_free_string_list (GSList *l)
 441 {
 442         g_slist_free_full (l, g_free);
 443 }
 444
 445 void
 446 gnm_conf_init (void)
 447 {
 448         debug_getters = gnm_debug_flag ("conf-get");
 449         debug_setters = gnm_debug_flag ("conf-set");
 450
 451         if (debug_getters || debug_setters)
 452                 g_printerr ("gnm_conf_init\n");
 453
 454         string_pool = g_hash_table_new_full
 455                 (g_str_hash, g_str_equal,
 456                  NULL, g_free);
 457         string_list_pool = g_hash_table_new_full
 458                 (g_str_hash, g_str_equal,
 459                  NULL, (GDestroyNotify)cb_free_string_list);
 460         node_pool = g_hash_table_new_full
 461                 (g_str_hash, g_str_equal,
 462                  NULL, (GDestroyNotify)go_conf_free_node);
 463         node_watch = g_hash_table_new (g_direct_hash, g_direct_equal);
 464
 465         root = go_conf_get_node (NULL, GNM_CONF_DIR);
 466         g_hash_table_insert (node_pool, (gpointer)"/", root);
 467 }
 468
 469 void
 470 gnm_conf_shutdown (void)
 471 {
 472         if (debug_getters || debug_setters)
 473                 g_printerr ("gnm_conf_shutdown\n");
 474
 475         go_conf_sync (root);
 476         if (sync_handler) {
 477                 g_source_remove (sync_handler);
 478                 sync_handler = 0;
 479         }
 480
 481         g_slist_free_full (watchers, (GDestroyNotify)free_watcher);
 482         watchers = NULL;
 483
 484         g_hash_table_destroy (string_pool);
 485         string_pool = NULL;
 486
 487         g_hash_table_destroy (string_list_pool);
 488         string_list_pool = NULL;
 489
 490         g_hash_table_destroy (node_watch);
 491         node_watch = NULL;
 492
 493         g_hash_table_destroy (node_pool);
 494         node_pool = NULL;
 495
 496         root = NULL;
 497 }
 498
 499 /**
 500  * gnm_conf_get_page_setup:
 501  *
 502  * Returns: (transfer full): the default #GtkPageSetup.
 503  **/
 504 GtkPageSetup *
 505 gnm_conf_get_page_setup (void)
 506 {
 507         GtkPageSetup *page_setup = gtk_page_setup_new ();
 508
 509         page_setup_set_paper (page_setup,
 510                               gnm_conf_get_printsetup_paper ());
 511
 512         gtk_page_setup_set_orientation
 513                 (page_setup,
 514                  gnm_conf_get_printsetup_paper_orientation ());
 515
 516         gtk_page_setup_set_top_margin
 517                 (page_setup,
 518                  gnm_conf_get_printsetup_margin_gtk_top (),
 519                  GTK_UNIT_POINTS);
 520         gtk_page_setup_set_bottom_margin
 521                 (page_setup,
 522                  gnm_conf_get_printsetup_margin_gtk_bottom (),
 523                  GTK_UNIT_POINTS);
 524         gtk_page_setup_set_left_margin
 525                 (page_setup,
 526                  gnm_conf_get_printsetup_margin_gtk_left (),
 527                  GTK_UNIT_POINTS);
 528         gtk_page_setup_set_right_margin
 529                 (page_setup,
 530                  gnm_conf_get_printsetup_margin_gtk_right (),
 531                  GTK_UNIT_POINTS);
 532
 533         return page_setup;
 534 }
 535
 536 void
 537 gnm_conf_set_page_setup (GtkPageSetup *setup)
 538 {
 539         char *paper;
 540
 541         paper = page_setup_get_paper (setup);
 542         gnm_conf_set_printsetup_paper (paper);
 543         g_free (paper);
 544
 545         gnm_conf_set_printsetup_paper_orientation
 546                 (gtk_page_setup_get_orientation (setup));
 547
 548         gnm_conf_set_printsetup_margin_gtk_top
 549                 (gtk_page_setup_get_top_margin (setup, GTK_UNIT_POINTS));
 550         gnm_conf_set_printsetup_margin_gtk_bottom
 551                 (gtk_page_setup_get_bottom_margin (setup, GTK_UNIT_POINTS));
 552         gnm_conf_set_printsetup_margin_gtk_left
 553                 (gtk_page_setup_get_left_margin (setup, GTK_UNIT_POINTS));
 554         gnm_conf_set_printsetup_margin_gtk_right
 555                 (gtk_page_setup_get_right_margin (setup, GTK_UNIT_POINTS));
 556 }
 557
 558 GnmStyle *
 559 gnm_conf_get_printer_decoration_font (void)
 560 {
 561         GnmStyle *style = gnm_style_new ();
 562
 563         gnm_style_set_font_name (style,
 564                                  gnm_conf_get_printsetup_hf_font_name ());
 565         gnm_style_set_font_size (style,
 566                                  gnm_conf_get_printsetup_hf_font_size ());
 567         gnm_style_set_font_bold (style,
 568                                  gnm_conf_get_printsetup_hf_font_bold ());
 569         gnm_style_set_font_italic (style,
 570                                    gnm_conf_get_printsetup_hf_font_italic ());
 571
 572         return style;
 573 }
 574
 575 #define TOOLBAR_TANGO(Object,Format,Standard)   \
 576         if (strcmp (name, "ObjectToolbar") == 0)                \
 577                 Object                                          \
 578         else if (strcmp (name, "FormatToolbar") == 0)           \
 579                 Format                                          \
 580         else if (strcmp (name, "StandardToolbar") == 0)         \
 581                 Standard
 582
 583
 584 gboolean
 585 gnm_conf_get_toolbar_visible (const char *name)
 586 {
 587         TOOLBAR_TANGO
 588                 (return gnm_conf_get_core_gui_toolbars_object_visible ();,
 589                  return gnm_conf_get_core_gui_toolbars_format_visible ();,
 590                  return gnm_conf_get_core_gui_toolbars_standard_visible (););
 591
 592         g_warning ("Unknown toolbar: %s", name);
 593         return FALSE;
 594 }
 595
 596 void
 597 gnm_conf_set_toolbar_visible (const char *name, gboolean x)
 598 {
 599         TOOLBAR_TANGO
 600                 (gnm_conf_set_core_gui_toolbars_object_visible (x);,
 601                  gnm_conf_set_core_gui_toolbars_format_visible (x);,
 602                  gnm_conf_set_core_gui_toolbars_standard_visible (x););
 603 }
 604
 605 GtkPositionType
 606 gnm_conf_get_toolbar_position (const char *name)
 607 {
 608         TOOLBAR_TANGO
 609                 (return gnm_conf_get_core_gui_toolbars_object_position ();,
 610                  return gnm_conf_get_core_gui_toolbars_format_position ();,
 611                  return gnm_conf_get_core_gui_toolbars_standard_position (););
 612
 613         g_warning ("Unknown toolbar: %s", name);
 614         return GTK_POS_TOP;
 615 }
 616
 617 void
 618 gnm_conf_set_toolbar_position (const char *name, GtkPositionType x)
 619 {
 620         TOOLBAR_TANGO
 621                 (gnm_conf_set_core_gui_toolbars_object_position (x);,
 622                  gnm_conf_set_core_gui_toolbars_format_position (x);,
 623                  gnm_conf_set_core_gui_toolbars_standard_position (x););
 624 }
 625
 626 #undef TOOLBAR_TANGO
 627
 628 /**
 629  * gnm_conf_get_print_settings:
 630  *
 631  * Returns: (transfer full): the default #GtkPrintSettings.
 632  **/
 633 GtkPrintSettings *
 634 gnm_conf_get_print_settings (void)
 635 {
 636         GtkPrintSettings *settings =  gtk_print_settings_new ();
 637         GSList *list = gnm_conf_get_printsetup_gtk_setting ();
 638
 639         while (list && list->next) {
 640                 /* For historical reasons, value comes before key. */
 641                 const char *value = list->data;
 642                 const char *key = list->next->data;
 643
 644                 list = list->next->next;
 645                 gtk_print_settings_set (settings, key, value);
 646         }
 647
 648         return settings;
 649 }
 650
 651 static void
 652 gnm_gconf_set_print_settings_cb (const gchar *key, const gchar *value, gpointer user_data)
 653 {
 654         GSList **list = user_data;
 655
 656         /* For historical reasons, value comes before key. */
 657         *list = g_slist_prepend (*list, g_strdup (key));
 658         *list = g_slist_prepend (*list, g_strdup (value));
 659 }
 660
 661 void
 662 gnm_conf_set_print_settings (GtkPrintSettings *settings)
 663 {
 664         GSList *list = NULL;
 665
 666         gtk_print_settings_foreach (settings, gnm_gconf_set_print_settings_cb, &list);
 667         gnm_conf_set_printsetup_gtk_setting (list);
 668         g_slist_free_full (list, g_free);
 669 }
 670
 671 gboolean
 672 gnm_conf_get_detachable_toolbars (void)
 673 {
 674 #ifdef WIN32
 675         return FALSE;
 676 #else
 677         return go_conf_get_bool
 678                 (NULL,
 679                  "/desktop/interface/toolbar_detachable");
 680 #endif
 681 }
 682
 683 /* ------------------------------------------------------------------------- */
 684 /*
 685  * The following code was generated by running
 686  *
 687  *     make update-gnumeric-conf
 688  */
 689
 690 /* ----------- AUTOMATICALLY GENERATED CODE BELOW -- DO NOT EDIT ----------- */
 691
 692 static struct cb_watch_bool watch_autocorrect_first_letter = {
 693         0, "autocorrect/first-letter",
 694         "Autocorrect first letter",
 695         "This variable determines whether to autocorrect first letters",
 696         TRUE,
 697 };
 698
 699 gboolean
 700 gnm_conf_get_autocorrect_first_letter (void)
 701 {
 702         if (!watch_autocorrect_first_letter.handler)
 703                 watch_bool (&watch_autocorrect_first_letter);
 704         return watch_autocorrect_first_letter.var;
 705 }
 706
 707 void
 708 gnm_conf_set_autocorrect_first_letter (gboolean x)
 709 {
 710         if (!watch_autocorrect_first_letter.handler)
 711                 watch_bool (&watch_autocorrect_first_letter);
 712         set_bool (&watch_autocorrect_first_letter, x);
 713 }
 714
 715 GOConfNode *
 716 gnm_conf_get_autocorrect_first_letter_node (void)
 717 {
 718         return get_watch_node (&watch_autocorrect_first_letter);
 719 }
 720
 721 static struct cb_watch_string_list watch_autocorrect_first_letter_list = {
 722         0, "autocorrect/first-letter-list",
 723         "List of First Letter Exception",
 724         "The autocorrect engine does not capitalize the first letter of words following strings in this list.",
 725 };
 726
 727 /**
 728  * gnm_conf_get_autocorrect_first_letter_list:
 729  *
 730  * Returns: (element-type char) (transfer none):
 731  **/
 732 GSList *
 733 gnm_conf_get_autocorrect_first_letter_list (void)
 734 {
 735         if (!watch_autocorrect_first_letter_list.handler)
 736                 watch_string_list (&watch_autocorrect_first_letter_list);
 737         return watch_autocorrect_first_letter_list.var;
 738 }
 739
 740 /**
 741  * gnm_conf_set_autocorrect_first_letter_list:
 742  * @x: (element-type char): list of strings
 743  *
 744  **/
 745 void
 746 gnm_conf_set_autocorrect_first_letter_list (GSList *x)
 747 {
 748         if (!watch_autocorrect_first_letter_list.handler)
 749                 watch_string_list (&watch_autocorrect_first_letter_list);
 750         set_string_list (&watch_autocorrect_first_letter_list, x);
 751 }
 752
 753 GOConfNode *
 754 gnm_conf_get_autocorrect_first_letter_list_node (void)
 755 {
 756         return get_watch_node (&watch_autocorrect_first_letter_list);
 757 }
 758
 759 static struct cb_watch_bool watch_autocorrect_init_caps = {
 760         0, "autocorrect/init-caps",
 761         "Autocorrect initial caps",
 762         "This variable determines whether to autocorrect initial caps",
 763         TRUE,
 764 };
 765
 766 gboolean
 767 gnm_conf_get_autocorrect_init_caps (void)
 768 {
 769         if (!watch_autocorrect_init_caps.handler)
 770                 watch_bool (&watch_autocorrect_init_caps);
 771         return watch_autocorrect_init_caps.var;
 772 }
 773
 774 void
 775 gnm_conf_set_autocorrect_init_caps (gboolean x)
 776 {
 777         if (!watch_autocorrect_init_caps.handler)
 778                 watch_bool (&watch_autocorrect_init_caps);
 779         set_bool (&watch_autocorrect_init_caps, x);
 780 }
 781
 782 GOConfNode *
 783 gnm_conf_get_autocorrect_init_caps_node (void)
 784 {
 785         return get_watch_node (&watch_autocorrect_init_caps);
 786 }
 787
 788 static struct cb_watch_string_list watch_autocorrect_init_caps_list = {
 789         0, "autocorrect/init-caps-list",
 790         "List of initial caps exceptions",
 791         "The autocorrect engine does not correct the initial caps for words in this list.",
 792 };
 793
 794 /**
 795  * gnm_conf_get_autocorrect_init_caps_list:
 796  *
 797  * Returns: (element-type char) (transfer none):
 798  **/
 799 GSList *
 800 gnm_conf_get_autocorrect_init_caps_list (void)
 801 {
 802         if (!watch_autocorrect_init_caps_list.handler)
 803                 watch_string_list (&watch_autocorrect_init_caps_list);
 804         return watch_autocorrect_init_caps_list.var;
 805 }
 806
 807 /**
 808  * gnm_conf_set_autocorrect_init_caps_list:
 809  * @x: (element-type char): list of strings
 810  *
 811  **/
 812 void
 813 gnm_conf_set_autocorrect_init_caps_list (GSList *x)
 814 {
 815         if (!watch_autocorrect_init_caps_list.handler)
 816                 watch_string_list (&watch_autocorrect_init_caps_list);
 817         set_string_list (&watch_autocorrect_init_caps_list, x);
 818 }
 819
 820 GOConfNode *
 821 gnm_conf_get_autocorrect_init_caps_list_node (void)
 822 {
 823         return get_watch_node (&watch_autocorrect_init_caps_list);
 824 }
 825
 826 static struct cb_watch_bool watch_autocorrect_names_of_days = {
 827         0, "autocorrect/names-of-days",
 828         "Autocorrect names of days",
 829         "This variable determines whether to autocorrect names of days",
 830         TRUE,
 831 };
 832
 833 gboolean
 834 gnm_conf_get_autocorrect_names_of_days (void)
 835 {
 836         if (!watch_autocorrect_names_of_days.handler)
 837                 watch_bool (&watch_autocorrect_names_of_days);
 838         return watch_autocorrect_names_of_days.var;
 839 }
 840
 841 void
 842 gnm_conf_set_autocorrect_names_of_days (gboolean x)
 843 {
 844         if (!watch_autocorrect_names_of_days.handler)
 845                 watch_bool (&watch_autocorrect_names_of_days);
 846         set_bool (&watch_autocorrect_names_of_days, x);
 847 }
 848
 849 GOConfNode *
 850 gnm_conf_get_autocorrect_names_of_days_node (void)
 851 {
 852         return get_watch_node (&watch_autocorrect_names_of_days);
 853 }
 854
 855 static struct cb_watch_bool watch_autocorrect_replace = {
 856         0, "autocorrect/replace",
 857         "Autocorrect replace",
 858         "Autocorrect replace",
 859         TRUE,
 860 };
 861
 862 gboolean
 863 gnm_conf_get_autocorrect_replace (void)
 864 {
 865         if (!watch_autocorrect_replace.handler)
 866                 watch_bool (&watch_autocorrect_replace);
 867         return watch_autocorrect_replace.var;
 868 }
 869
 870 void
 871 gnm_conf_set_autocorrect_replace (gboolean x)
 872 {
 873         if (!watch_autocorrect_replace.handler)
 874                 watch_bool (&watch_autocorrect_replace);
 875         set_bool (&watch_autocorrect_replace, x);
 876 }
 877
 878 GOConfNode *
 879 gnm_conf_get_autocorrect_replace_node (void)
 880 {
 881         return get_watch_node (&watch_autocorrect_replace);
 882 }
 883
 884 static struct cb_watch_string_list watch_autoformat_extra_dirs = {
 885         0, "autoformat/extra-dirs",
 886         "List of Extra Autoformat Directories.",
 887         "This list contains all extra directories containing autoformat templates.",
 888 };
 889
 890 /**
 891  * gnm_conf_get_autoformat_extra_dirs:
 892  *
 893  * Returns: (element-type char) (transfer none):
 894  **/
 895 GSList *
 896 gnm_conf_get_autoformat_extra_dirs (void)
 897 {
 898         if (!watch_autoformat_extra_dirs.handler)
 899                 watch_string_list (&watch_autoformat_extra_dirs);
 900         return watch_autoformat_extra_dirs.var;
 901 }
 902
 903 /**
 904  * gnm_conf_set_autoformat_extra_dirs:
 905  * @x: (element-type char): list of strings
 906  *
 907  **/
 908 void
 909 gnm_conf_set_autoformat_extra_dirs (GSList *x)
 910 {
 911         if (!watch_autoformat_extra_dirs.handler)
 912                 watch_string_list (&watch_autoformat_extra_dirs);
 913         set_string_list (&watch_autoformat_extra_dirs, x);
 914 }
 915
 916 GOConfNode *
 917 gnm_conf_get_autoformat_extra_dirs_node (void)
 918 {
 919         return get_watch_node (&watch_autoformat_extra_dirs);
 920 }
 921
 922 static struct cb_watch_string watch_autoformat_sys_dir = {
 923         0, "autoformat/sys-dir",
 924         "System Directory for Autoformats",
 925         "This directory contains the pre-installed autoformat templates.",
 926         "autoformat-templates",
 927 };
 928
 929 const char *
 930 gnm_conf_get_autoformat_sys_dir (void)
 931 {
 932         if (!watch_autoformat_sys_dir.handler)
 933                 watch_string (&watch_autoformat_sys_dir);
 934         return watch_autoformat_sys_dir.var;
 935 }
 936
 937 void
 938 gnm_conf_set_autoformat_sys_dir (const char *x)
 939 {
 940         g_return_if_fail (x != NULL);
 941         if (!watch_autoformat_sys_dir.handler)
 942                 watch_string (&watch_autoformat_sys_dir);
 943         set_string (&watch_autoformat_sys_dir, x);
 944 }
 945
 946 GOConfNode *
 947 gnm_conf_get_autoformat_sys_dir_node (void)
 948 {
 949         return get_watch_node (&watch_autoformat_sys_dir);
 950 }
 951
 952 static struct cb_watch_string watch_autoformat_usr_dir = {
 953         0, "autoformat/usr-dir",
 954         "User Directory for Autoformats",
 955         "The main directory for user specific autoformat templates.",
 956         "autoformat-templates",
 957 };
 958
 959 const char *
 960 gnm_conf_get_autoformat_usr_dir (void)
 961 {
 962         if (!watch_autoformat_usr_dir.handler)
 963                 watch_string (&watch_autoformat_usr_dir);
 964         return watch_autoformat_usr_dir.var;
 965 }
 966
 967 void
 968 gnm_conf_set_autoformat_usr_dir (const char *x)
 969 {
 970         g_return_if_fail (x != NULL);
 971         if (!watch_autoformat_usr_dir.handler)
 972                 watch_string (&watch_autoformat_usr_dir);
 973         set_string (&watch_autoformat_usr_dir, x);
 974 }
 975
 976 GOConfNode *
 977 gnm_conf_get_autoformat_usr_dir_node (void)
 978 {
 979         return get_watch_node (&watch_autoformat_usr_dir);
 980 }
 981
 982 static struct cb_watch_bool watch_core_defaultfont_bold = {
 983         0, "core/defaultfont/bold",
 984         "The default font is bold.",
 985         "This value determines whether the default font for a new workbook is bold.",
 986         FALSE,
 987 };
 988
 989 gboolean
 990 gnm_conf_get_core_defaultfont_bold (void)
 991 {
 992         if (!watch_core_defaultfont_bold.handler)
 993                 watch_bool (&watch_core_defaultfont_bold);
 994         return watch_core_defaultfont_bold.var;
 995 }
 996
 997 void
 998 gnm_conf_set_core_defaultfont_bold (gboolean x)
 999 {
1000         if (!watch_core_defaultfont_bold.handler)
1001                 watch_bool (&watch_core_defaultfont_bold);
1002         set_bool (&watch_core_defaultfont_bold, x);
1003 }
1004
1005 GOConfNode *
1006 gnm_conf_get_core_defaultfont_bold_node (void)
1007 {
1008         return get_watch_node (&watch_core_defaultfont_bold);
1009 }
1010
1011 static struct cb_watch_bool watch_core_defaultfont_italic = {
1012         0, "core/defaultfont/italic",
1013         "The default font is italic.",
1014         "This value determines whether the default font for a new workbook is italic.",
1015         FALSE,
1016 };
1017
1018 gboolean
1019 gnm_conf_get_core_defaultfont_italic (void)
1020 {
1021         if (!watch_core_defaultfont_italic.handler)
1022                 watch_bool (&watch_core_defaultfont_italic);
1023         return watch_core_defaultfont_italic.var;
1024 }
1025
1026 void
1027 gnm_conf_set_core_defaultfont_italic (gboolean x)
1028 {
1029         if (!watch_core_defaultfont_italic.handler)
1030                 watch_bool (&watch_core_defaultfont_italic);
1031         set_bool (&watch_core_defaultfont_italic, x);
1032 }
1033
1034 GOConfNode *
1035 gnm_conf_get_core_defaultfont_italic_node (void)
1036 {
1037         return get_watch_node (&watch_core_defaultfont_italic);
1038 }
1039
1040 static struct cb_watch_string watch_core_defaultfont_name = {
1041         0, "core/defaultfont/name",
1042         "Default font name",
1043         "The default font name for new workbooks.",
1044         "Sans",
1045 };
1046
1047 const char *
1048 gnm_conf_get_core_defaultfont_name (void)
1049 {
1050         if (!watch_core_defaultfont_name.handler)
1051                 watch_string (&watch_core_defaultfont_name);
1052         return watch_core_defaultfont_name.var;
1053 }
1054
1055 void
1056 gnm_conf_set_core_defaultfont_name (const char *x)
1057 {
1058         g_return_if_fail (x != NULL);
1059         if (!watch_core_defaultfont_name.handler)
1060                 watch_string (&watch_core_defaultfont_name);
1061         set_string (&watch_core_defaultfont_name, x);
1062 }
1063
1064 GOConfNode *
1065 gnm_conf_get_core_defaultfont_name_node (void)
1066 {
1067         return get_watch_node (&watch_core_defaultfont_name);
1068 }
1069
1070 static struct cb_watch_double watch_core_defaultfont_size = {
1071         0, "core/defaultfont/size",
1072         "Default Font Size",
1073         "The default font size for new workbooks.",
1074         1, 100, 10,
1075 };
1076
1077 double
1078 gnm_conf_get_core_defaultfont_size (void)
1079 {
1080         if (!watch_core_defaultfont_size.handler)
1081                 watch_double (&watch_core_defaultfont_size);
1082         return watch_core_defaultfont_size.var;
1083 }
1084
1085 void
1086 gnm_conf_set_core_defaultfont_size (double x)
1087 {
1088         if (!watch_core_defaultfont_size.handler)
1089                 watch_double (&watch_core_defaultfont_size);
1090         set_double (&watch_core_defaultfont_size, x);
1091 }
1092
1093 GOConfNode *
1094 gnm_conf_get_core_defaultfont_size_node (void)
1095 {
1096         return get_watch_node (&watch_core_defaultfont_size);
1097 }
1098
1099 static struct cb_watch_bool watch_core_file_save_def_overwrite = {
1100         0, "core/file/save/def-overwrite",
1101         "Default To Overwriting Files",
1102         "Before an existing file is being overwritten, Gnumeric will present a warning dialog. Setting this option will make the overwrite button in that dialog the default button.",
1103         FALSE,
1104 };
1105
1106 gboolean
1107 gnm_conf_get_core_file_save_def_overwrite (void)
1108 {
1109         if (!watch_core_file_save_def_overwrite.handler)
1110                 watch_bool (&watch_core_file_save_def_overwrite);
1111         return watch_core_file_save_def_overwrite.var;
1112 }
1113
1114 void
1115 gnm_conf_set_core_file_save_def_overwrite (gboolean x)
1116 {
1117         if (!watch_core_file_save_def_overwrite.handler)
1118                 watch_bool (&watch_core_file_save_def_overwrite);
1119         set_bool (&watch_core_file_save_def_overwrite, x);
1120 }
1121
1122 GOConfNode *
1123 gnm_conf_get_core_file_save_def_overwrite_node (void)
1124 {
1125         return get_watch_node (&watch_core_file_save_def_overwrite);
1126 }
1127
1128 static struct cb_watch_string_list watch_core_file_save_extension_check_disabled = {
1129         0, "core/file/save/extension-check-disabled",
1130         "List of file savers with disabled extension check.",
1131         "This list contains the ids of the file savers for which the extension check is disabled.",
1132 };
1133
1134 /**
1135  * gnm_conf_get_core_file_save_extension_check_disabled:
1136  *
1137  * Returns: (element-type char) (transfer none):
1138  **/
1139 GSList *
1140 gnm_conf_get_core_file_save_extension_check_disabled (void)
1141 {
1142         if (!watch_core_file_save_extension_check_disabled.handler)
1143                 watch_string_list (&watch_core_file_save_extension_check_disabled);
1144         return watch_core_file_save_extension_check_disabled.var;
1145 }
1146
1147 /**
1148  * gnm_conf_set_core_file_save_extension_check_disabled:
1149  * @x: (element-type char): list of strings
1150  *
1151  **/
1152 void
1153 gnm_conf_set_core_file_save_extension_check_disabled (GSList *x)
1154 {
1155         if (!watch_core_file_save_extension_check_disabled.handler)
1156                 watch_string_list (&watch_core_file_save_extension_check_disabled);
1157         set_string_list (&watch_core_file_save_extension_check_disabled, x);
1158 }
1159
1160 GOConfNode *
1161 gnm_conf_get_core_file_save_extension_check_disabled_node (void)
1162 {
1163         return get_watch_node (&watch_core_file_save_extension_check_disabled);
1164 }
1165
1166 static struct cb_watch_bool watch_core_file_save_single_sheet = {
1167         0, "core/file/save/single-sheet",
1168         "Warn When Exporting Into Single Sheet Format",
1169         "Some file formats can contain only a single sheet. This variable determines whether the user will be warned if only a single sheet of a multi-sheet workbook is being saved.",
1170         TRUE,
1171 };
1172
1173 gboolean
1174 gnm_conf_get_core_file_save_single_sheet (void)
1175 {
1176         if (!watch_core_file_save_single_sheet.handler)
1177                 watch_bool (&watch_core_file_save_single_sheet);
1178         return watch_core_file_save_single_sheet.var;
1179 }
1180
1181 void
1182 gnm_conf_set_core_file_save_single_sheet (gboolean x)
1183 {
1184         if (!watch_core_file_save_single_sheet.handler)
1185                 watch_bool (&watch_core_file_save_single_sheet);
1186         set_bool (&watch_core_file_save_single_sheet, x);
1187 }
1188
1189 GOConfNode *
1190 gnm_conf_get_core_file_save_single_sheet_node (void)
1191 {
1192         return get_watch_node (&watch_core_file_save_single_sheet);
1193 }
1194
1195 static struct cb_watch_bool watch_core_gui_cells_extension_markers = {
1196         0, "core/gui/cells/extension-markers",
1197         "Extension Markers",
1198         "This variable determines whether cells with truncated content are marked.",
1199         FALSE,
1200 };
1201
1202 gboolean
1203 gnm_conf_get_core_gui_cells_extension_markers (void)
1204 {
1205         if (!watch_core_gui_cells_extension_markers.handler)
1206                 watch_bool (&watch_core_gui_cells_extension_markers);
1207         return watch_core_gui_cells_extension_markers.var;
1208 }
1209
1210 void
1211 gnm_conf_set_core_gui_cells_extension_markers (gboolean x)
1212 {
1213         if (!watch_core_gui_cells_extension_markers.handler)
1214                 watch_bool (&watch_core_gui_cells_extension_markers);
1215         set_bool (&watch_core_gui_cells_extension_markers, x);
1216 }
1217
1218 GOConfNode *
1219 gnm_conf_get_core_gui_cells_extension_markers_node (void)
1220 {
1221         return get_watch_node (&watch_core_gui_cells_extension_markers);
1222 }
1223
1224 static struct cb_watch_bool watch_core_gui_cells_function_markers = {
1225         0, "core/gui/cells/function-markers",
1226         "Function Markers",
1227         "This variable determines whether cells containing spreadsheet function are marked.",
1228         FALSE,
1229 };
1230
1231 gboolean
1232 gnm_conf_get_core_gui_cells_function_markers (void)
1233 {
1234         if (!watch_core_gui_cells_function_markers.handler)
1235                 watch_bool (&watch_core_gui_cells_function_markers);
1236         return watch_core_gui_cells_function_markers.var;
1237 }
1238
1239 void
1240 gnm_conf_set_core_gui_cells_function_markers (gboolean x)
1241 {
1242         if (!watch_core_gui_cells_function_markers.handler)
1243                 watch_bool (&watch_core_gui_cells_function_markers);
1244         set_bool (&watch_core_gui_cells_function_markers, x);
1245 }
1246
1247 GOConfNode *
1248 gnm_conf_get_core_gui_cells_function_markers_node (void)
1249 {
1250         return get_watch_node (&watch_core_gui_cells_function_markers);
1251 }
1252
1253 static struct cb_watch_bool watch_core_gui_editing_autocomplete = {
1254         0, "core/gui/editing/autocomplete",
1255         "Autocomplete",
1256         "This variable determines whether autocompletion is set on.",
1257         TRUE,
1258 };
1259
1260 gboolean
1261 gnm_conf_get_core_gui_editing_autocomplete (void)
1262 {
1263         if (!watch_core_gui_editing_autocomplete.handler)
1264                 watch_bool (&watch_core_gui_editing_autocomplete);
1265         return watch_core_gui_editing_autocomplete.var;
1266 }
1267
1268 void
1269 gnm_conf_set_core_gui_editing_autocomplete (gboolean x)
1270 {
1271         if (!watch_core_gui_editing_autocomplete.handler)
1272                 watch_bool (&watch_core_gui_editing_autocomplete);
1273         set_bool (&watch_core_gui_editing_autocomplete, x);
1274 }
1275
1276 GOConfNode *
1277 gnm_conf_get_core_gui_editing_autocomplete_node (void)
1278 {
1279         return get_watch_node (&watch_core_gui_editing_autocomplete);
1280 }
1281
1282 static struct cb_watch_int watch_core_gui_editing_autocomplete_min_chars = {
1283         0, "core/gui/editing/autocomplete-min-chars",
1284         "Minimum Number of Characters for Autocompletion",
1285         "This variable determines the minimum number of characters required for autocompletion.",
1286         1, 10, 3,
1287 };
1288
1289 int
1290 gnm_conf_get_core_gui_editing_autocomplete_min_chars (void)
1291 {
1292         if (!watch_core_gui_editing_autocomplete_min_chars.handler)
1293                 watch_int (&watch_core_gui_editing_autocomplete_min_chars);
1294         return watch_core_gui_editing_autocomplete_min_chars.var;
1295 }
1296
1297 void
1298 gnm_conf_set_core_gui_editing_autocomplete_min_chars (int x)
1299 {
1300         if (!watch_core_gui_editing_autocomplete_min_chars.handler)
1301                 watch_int (&watch_core_gui_editing_autocomplete_min_chars);
1302         set_int (&watch_core_gui_editing_autocomplete_min_chars, x);
1303 }
1304
1305 GOConfNode *
1306 gnm_conf_get_core_gui_editing_autocomplete_min_chars_node (void)
1307 {
1308         return get_watch_node (&watch_core_gui_editing_autocomplete_min_chars);
1309 }
1310
1311 static struct cb_watch_enum watch_core_gui_editing_enter_moves_dir = {
1312         0, "core/gui/editing/enter-moves-dir",
1313         "Enter Direction",
1314         "Which direction pressing Enter will move the edit position.",
1315         GO_DIRECTION_DOWN,
1316 };
1317
1318 GODirection
1319 gnm_conf_get_core_gui_editing_enter_moves_dir (void)
1320 {
1321         if (!watch_core_gui_editing_enter_moves_dir.handler)
1322                 watch_enum (&watch_core_gui_editing_enter_moves_dir, GO_TYPE_DIRECTION);
1323         return watch_core_gui_editing_enter_moves_dir.var;
1324 }
1325
1326 void
1327 gnm_conf_set_core_gui_editing_enter_moves_dir (GODirection x)
1328 {
1329         if (!watch_core_gui_editing_enter_moves_dir.handler)
1330                 watch_enum (&watch_core_gui_editing_enter_moves_dir, GO_TYPE_DIRECTION);
1331         set_enum (&watch_core_gui_editing_enter_moves_dir, x);
1332 }
1333
1334 GOConfNode *
1335 gnm_conf_get_core_gui_editing_enter_moves_dir_node (void)
1336 {
1337         return get_watch_node (&watch_core_gui_editing_enter_moves_dir);
1338 }
1339
1340 static struct cb_watch_bool watch_core_gui_editing_function_argument_tooltips = {
1341         0, "core/gui/editing/function-argument-tooltips",
1342         "Show Function Argument Tooltips",
1343         "This variable determines whether to show function argument tooltips.",
1344         TRUE,
1345 };
1346
1347 gboolean
1348 gnm_conf_get_core_gui_editing_function_argument_tooltips (void)
1349 {
1350         if (!watch_core_gui_editing_function_argument_tooltips.handler)
1351                 watch_bool (&watch_core_gui_editing_function_argument_tooltips);
1352         return watch_core_gui_editing_function_argument_tooltips.var;
1353 }
1354
1355 void
1356 gnm_conf_set_core_gui_editing_function_argument_tooltips (gboolean x)
1357 {
1358         if (!watch_core_gui_editing_function_argument_tooltips.handler)
1359                 watch_bool (&watch_core_gui_editing_function_argument_tooltips);
1360         set_bool (&watch_core_gui_editing_function_argument_tooltips, x);
1361 }
1362
1363 GOConfNode *
1364 gnm_conf_get_core_gui_editing_function_argument_tooltips_node (void)
1365 {
1366         return get_watch_node (&watch_core_gui_editing_function_argument_tooltips);
1367 }
1368
1369 static struct cb_watch_bool watch_core_gui_editing_function_name_tooltips = {
1370         0, "core/gui/editing/function-name-tooltips",
1371         "Show Function Name Tooltips",
1372         "This variable determines whether to show function name tooltips.",
1373         TRUE,
1374 };
1375
1376 gboolean
1377 gnm_conf_get_core_gui_editing_function_name_tooltips (void)
1378 {
1379         if (!watch_core_gui_editing_function_name_tooltips.handler)
1380                 watch_bool (&watch_core_gui_editing_function_name_tooltips);
1381         return watch_core_gui_editing_function_name_tooltips.var;
1382 }
1383
1384 void
1385 gnm_conf_set_core_gui_editing_function_name_tooltips (gboolean x)
1386 {
1387         if (!watch_core_gui_editing_function_name_tooltips.handler)
1388                 watch_bool (&watch_core_gui_editing_function_name_tooltips);
1389         set_bool (&watch_core_gui_editing_function_name_tooltips, x);
1390 }
1391
1392 GOConfNode *
1393 gnm_conf_get_core_gui_editing_function_name_tooltips_node (void)
1394 {
1395         return get_watch_node (&watch_core_gui_editing_function_name_tooltips);
1396 }
1397
1398 static struct cb_watch_int watch_core_gui_editing_recalclag = {
1399         0, "core/gui/editing/recalclag",
1400         "Auto Expression Recalculation Lag",
1401         "If `lag' is 0, Gnumeric recalculates all auto expressions immediately after every change.  Non-zero values of `lag' allow Gnumeric to accumulate more changes before each recalculation. If `lag' is positive, then whenever a change appears, Gnumeric waits `lag' milliseconds and then recalculates; if more changes appear during that period, they are also processed at that time. If `lag' is negative, then recalculation happens only after a quiet period of |lag| milliseconds.",
1402         -5000, 5000, 200,
1403 };
1404
1405 int
1406 gnm_conf_get_core_gui_editing_recalclag (void)
1407 {
1408         if (!watch_core_gui_editing_recalclag.handler)
1409                 watch_int (&watch_core_gui_editing_recalclag);
1410         return watch_core_gui_editing_recalclag.var;
1411 }
1412
1413 void
1414 gnm_conf_set_core_gui_editing_recalclag (int x)
1415 {
1416         if (!watch_core_gui_editing_recalclag.handler)
1417                 watch_int (&watch_core_gui_editing_recalclag);
1418         set_int (&watch_core_gui_editing_recalclag, x);
1419 }
1420
1421 GOConfNode *
1422 gnm_conf_get_core_gui_editing_recalclag_node (void)
1423 {
1424         return get_watch_node (&watch_core_gui_editing_recalclag);
1425 }
1426
1427 static struct cb_watch_bool watch_core_gui_editing_transitionkeys = {
1428         0, "core/gui/editing/transitionkeys",
1429         "Transition Keys",
1430         "This variable determines whether transition keys are set on. Transition keys are a throw back to 1-2-3 style event handling. They turn Ctrl-arrow into page movement rather than jumping to the start/end of series.",
1431         FALSE,
1432 };
1433
1434 gboolean
1435 gnm_conf_get_core_gui_editing_transitionkeys (void)
1436 {
1437         if (!watch_core_gui_editing_transitionkeys.handler)
1438                 watch_bool (&watch_core_gui_editing_transitionkeys);
1439         return watch_core_gui_editing_transitionkeys.var;
1440 }
1441
1442 void
1443 gnm_conf_set_core_gui_editing_transitionkeys (gboolean x)
1444 {
1445         if (!watch_core_gui_editing_transitionkeys.handler)
1446                 watch_bool (&watch_core_gui_editing_transitionkeys);
1447         set_bool (&watch_core_gui_editing_transitionkeys, x);
1448 }
1449
1450 GOConfNode *
1451 gnm_conf_get_core_gui_editing_transitionkeys_node (void)
1452 {
1453         return get_watch_node (&watch_core_gui_editing_transitionkeys);
1454 }
1455
1456 static struct cb_watch_double watch_core_gui_screen_horizontaldpi = {
1457         0, "core/gui/screen/horizontaldpi",
1458         "Horizontal DPI",
1459         "Screen resolution in the horizontal direction.",
1460         10, 1000, 96,
1461 };
1462
1463 double
1464 gnm_conf_get_core_gui_screen_horizontaldpi (void)
1465 {
1466         if (!watch_core_gui_screen_horizontaldpi.handler)
1467                 watch_double (&watch_core_gui_screen_horizontaldpi);
1468         return watch_core_gui_screen_horizontaldpi.var;
1469 }
1470
1471 void
1472 gnm_conf_set_core_gui_screen_horizontaldpi (double x)
1473 {
1474         if (!watch_core_gui_screen_horizontaldpi.handler)
1475                 watch_double (&watch_core_gui_screen_horizontaldpi);
1476         set_double (&watch_core_gui_screen_horizontaldpi, x);
1477 }
1478
1479 GOConfNode *
1480 gnm_conf_get_core_gui_screen_horizontaldpi_node (void)
1481 {
1482         return get_watch_node (&watch_core_gui_screen_horizontaldpi);
1483 }
1484
1485 static struct cb_watch_double watch_core_gui_screen_verticaldpi = {
1486         0, "core/gui/screen/verticaldpi",
1487         "Vertical DPI",
1488         "Screen resolution in the vertical direction.",
1489         10, 1000, 96,
1490 };
1491
1492 double
1493 gnm_conf_get_core_gui_screen_verticaldpi (void)
1494 {
1495         if (!watch_core_gui_screen_verticaldpi.handler)
1496                 watch_double (&watch_core_gui_screen_verticaldpi);
1497         return watch_core_gui_screen_verticaldpi.var;
1498 }
1499
1500 void
1501 gnm_conf_set_core_gui_screen_verticaldpi (double x)
1502 {
1503         if (!watch_core_gui_screen_verticaldpi.handler)
1504                 watch_double (&watch_core_gui_screen_verticaldpi);
1505         set_double (&watch_core_gui_screen_verticaldpi, x);
1506 }
1507
1508 GOConfNode *
1509 gnm_conf_get_core_gui_screen_verticaldpi_node (void)
1510 {
1511         return get_watch_node (&watch_core_gui_screen_verticaldpi);
1512 }
1513
1514 static struct cb_watch_int watch_core_gui_toolbars_format_position = {
1515         0, "core/gui/toolbars/format-position",
1516         "Format toolbar position",
1517         "This variable determines where the format toolbar should be shown.  0 is left, 1 is right, 2 is top.",
1518         0, 3, 2,
1519 };
1520
1521 GtkPositionType
1522 gnm_conf_get_core_gui_toolbars_format_position (void)
1523 {
1524         if (!watch_core_gui_toolbars_format_position.handler)
1525                 watch_int (&watch_core_gui_toolbars_format_position);
1526         return watch_core_gui_toolbars_format_position.var;
1527 }
1528
1529 void
1530 gnm_conf_set_core_gui_toolbars_format_position (GtkPositionType x)
1531 {
1532         if (!watch_core_gui_toolbars_format_position.handler)
1533                 watch_int (&watch_core_gui_toolbars_format_position);
1534         set_int (&watch_core_gui_toolbars_format_position, x);
1535 }
1536
1537 GOConfNode *
1538 gnm_conf_get_core_gui_toolbars_format_position_node (void)
1539 {
1540         return get_watch_node (&watch_core_gui_toolbars_format_position);
1541 }
1542
1543 static struct cb_watch_bool watch_core_gui_toolbars_format_visible = {
1544         0, "core/gui/toolbars/format-visible",
1545         "Format toolbar visible",
1546         "This variable determines whether the format toolbar should be visible initially.",
1547         TRUE,
1548 };
1549
1550 gboolean
1551 gnm_conf_get_core_gui_toolbars_format_visible (void)
1552 {
1553         if (!watch_core_gui_toolbars_format_visible.handler)
1554                 watch_bool (&watch_core_gui_toolbars_format_visible);
1555         return watch_core_gui_toolbars_format_visible.var;
1556 }
1557
1558 void
1559 gnm_conf_set_core_gui_toolbars_format_visible (gboolean x)
1560 {
1561         if (!watch_core_gui_toolbars_format_visible.handler)
1562                 watch_bool (&watch_core_gui_toolbars_format_visible);
1563         set_bool (&watch_core_gui_toolbars_format_visible, x);
1564 }
1565
1566 GOConfNode *
1567 gnm_conf_get_core_gui_toolbars_format_visible_node (void)
1568 {
1569         return get_watch_node (&watch_core_gui_toolbars_format_visible);
1570 }
1571
1572 static struct cb_watch_int watch_core_gui_toolbars_object_position = {
1573         0, "core/gui/toolbars/object-position",
1574         "Object toolbar position",
1575         "This variable determines where the object toolbar should be shown.  0 is left, 1 is right, 2 is top.",
1576         0, 3, 2,
1577 };
1578
1579 GtkPositionType
1580 gnm_conf_get_core_gui_toolbars_object_position (void)
1581 {
1582         if (!watch_core_gui_toolbars_object_position.handler)
1583                 watch_int (&watch_core_gui_toolbars_object_position);
1584         return watch_core_gui_toolbars_object_position.var;
1585 }
1586
1587 void
1588 gnm_conf_set_core_gui_toolbars_object_position (GtkPositionType x)
1589 {
1590         if (!watch_core_gui_toolbars_object_position.handler)
1591                 watch_int (&watch_core_gui_toolbars_object_position);
1592         set_int (&watch_core_gui_toolbars_object_position, x);
1593 }
1594
1595 GOConfNode *
1596 gnm_conf_get_core_gui_toolbars_object_position_node (void)
1597 {
1598         return get_watch_node (&watch_core_gui_toolbars_object_position);
1599 }
1600
1601 static struct cb_watch_bool watch_core_gui_toolbars_object_visible = {
1602         0, "core/gui/toolbars/object-visible",
1603         "Object toolbar visible",
1604         "This variable determines whether the object toolbar should be visible initially.",
1605         TRUE,
1606 };
1607
1608 gboolean
1609 gnm_conf_get_core_gui_toolbars_object_visible (void)
1610 {
1611         if (!watch_core_gui_toolbars_object_visible.handler)
1612                 watch_bool (&watch_core_gui_toolbars_object_visible);
1613         return watch_core_gui_toolbars_object_visible.var;
1614 }
1615
1616 void
1617 gnm_conf_set_core_gui_toolbars_object_visible (gboolean x)
1618 {
1619         if (!watch_core_gui_toolbars_object_visible.handler)
1620                 watch_bool (&watch_core_gui_toolbars_object_visible);
1621         set_bool (&watch_core_gui_toolbars_object_visible, x);
1622 }
1623
1624 GOConfNode *
1625 gnm_conf_get_core_gui_toolbars_object_visible_node (void)
1626 {
1627         return get_watch_node (&watch_core_gui_toolbars_object_visible);
1628 }
1629
1630 static struct cb_watch_int watch_core_gui_toolbars_standard_position = {
1631         0, "core/gui/toolbars/standard-position",
1632         "Standard toolbar position",
1633         "This variable determines where the standard toolbar should be shown.  0 is left, 1 is right, 2 is top.",
1634         0, 3, 2,
1635 };
1636
1637 GtkPositionType
1638 gnm_conf_get_core_gui_toolbars_standard_position (void)
1639 {
1640         if (!watch_core_gui_toolbars_standard_position.handler)
1641                 watch_int (&watch_core_gui_toolbars_standard_position);
1642         return watch_core_gui_toolbars_standard_position.var;
1643 }
1644
1645 void
1646 gnm_conf_set_core_gui_toolbars_standard_position (GtkPositionType x)
1647 {
1648         if (!watch_core_gui_toolbars_standard_position.handler)
1649                 watch_int (&watch_core_gui_toolbars_standard_position);
1650         set_int (&watch_core_gui_toolbars_standard_position, x);
1651 }
1652
1653 GOConfNode *
1654 gnm_conf_get_core_gui_toolbars_standard_position_node (void)
1655 {
1656         return get_watch_node (&watch_core_gui_toolbars_standard_position);
1657 }
1658
1659 static struct cb_watch_bool watch_core_gui_toolbars_standard_visible = {
1660         0, "core/gui/toolbars/standard-visible",
1661         "Standard toolbar visible",
1662         "This variable determines whether the standard toolbar should be visible initially.",
1663         TRUE,
1664 };
1665
1666 gboolean
1667 gnm_conf_get_core_gui_toolbars_standard_visible (void)
1668 {
1669         if (!watch_core_gui_toolbars_standard_visible.handler)
1670                 watch_bool (&watch_core_gui_toolbars_standard_visible);
1671         return watch_core_gui_toolbars_standard_visible.var;
1672 }
1673
1674 void
1675 gnm_conf_set_core_gui_toolbars_standard_visible (gboolean x)
1676 {
1677         if (!watch_core_gui_toolbars_standard_visible.handler)
1678                 watch_bool (&watch_core_gui_toolbars_standard_visible);
1679         set_bool (&watch_core_gui_toolbars_standard_visible, x);
1680 }
1681
1682 GOConfNode *
1683 gnm_conf_get_core_gui_toolbars_standard_visible_node (void)
1684 {
1685         return get_watch_node (&watch_core_gui_toolbars_standard_visible);
1686 }
1687
1688 static struct cb_watch_double watch_core_gui_window_x = {
1689         0, "core/gui/window/x",
1690         "Default Horizontal Window Size",
1691         "This number (between 0.25 and 1.00) gives the horizontal fraction of the screen size covered by the default window.",
1692         0.1, 1, 0.75,
1693 };
1694
1695 double
1696 gnm_conf_get_core_gui_window_x (void)
1697 {
1698         if (!watch_core_gui_window_x.handler)
1699                 watch_double (&watch_core_gui_window_x);
1700         return watch_core_gui_window_x.var;
1701 }
1702
1703 void
1704 gnm_conf_set_core_gui_window_x (double x)
1705 {
1706         if (!watch_core_gui_window_x.handler)
1707                 watch_double (&watch_core_gui_window_x);
1708         set_double (&watch_core_gui_window_x, x);
1709 }
1710
1711 GOConfNode *
1712 gnm_conf_get_core_gui_window_x_node (void)
1713 {
1714         return get_watch_node (&watch_core_gui_window_x);
1715 }
1716
1717 static struct cb_watch_double watch_core_gui_window_y = {
1718         0, "core/gui/window/y",
1719         "Default Vertical Window Size",
1720         "This number (between 0.25 and 1.00) gives the vertical fraction of the screen size covered by the default window.",
1721         0.1, 1, 0.75,
1722 };
1723
1724 double
1725 gnm_conf_get_core_gui_window_y (void)
1726 {
1727         if (!watch_core_gui_window_y.handler)
1728                 watch_double (&watch_core_gui_window_y);
1729         return watch_core_gui_window_y.var;
1730 }
1731
1732 void
1733 gnm_conf_set_core_gui_window_y (double x)
1734 {
1735         if (!watch_core_gui_window_y.handler)
1736                 watch_double (&watch_core_gui_window_y);
1737         set_double (&watch_core_gui_window_y, x);
1738 }
1739
1740 GOConfNode *
1741 gnm_conf_get_core_gui_window_y_node (void)
1742 {
1743         return get_watch_node (&watch_core_gui_window_y);
1744 }
1745
1746 static struct cb_watch_double watch_core_gui_window_zoom = {
1747         0, "core/gui/window/zoom",
1748         "Default Zoom Factor",
1749         "The initial zoom factor for new workbooks.",
1750         0.1, 5, 1,
1751 };
1752
1753 double
1754 gnm_conf_get_core_gui_window_zoom (void)
1755 {
1756         if (!watch_core_gui_window_zoom.handler)
1757                 watch_double (&watch_core_gui_window_zoom);
1758         return watch_core_gui_window_zoom.var;
1759 }
1760
1761 void
1762 gnm_conf_set_core_gui_window_zoom (double x)
1763 {
1764         if (!watch_core_gui_window_zoom.handler)
1765                 watch_double (&watch_core_gui_window_zoom);
1766         set_double (&watch_core_gui_window_zoom, x);
1767 }
1768
1769 GOConfNode *
1770 gnm_conf_get_core_gui_window_zoom_node (void)
1771 {
1772         return get_watch_node (&watch_core_gui_window_zoom);
1773 }
1774
1775 static struct cb_watch_bool watch_core_sort_default_ascending = {
1776         0, "core/sort/default/ascending",
1777         "Sort Ascending",
1778         "This option determines the initial state of the sort-order button in the sort dialog.",
1779         TRUE,
1780 };
1781
1782 gboolean
1783 gnm_conf_get_core_sort_default_ascending (void)
1784 {
1785         if (!watch_core_sort_default_ascending.handler)
1786                 watch_bool (&watch_core_sort_default_ascending);
1787         return watch_core_sort_default_ascending.var;
1788 }
1789
1790 void
1791 gnm_conf_set_core_sort_default_ascending (gboolean x)
1792 {
1793         if (!watch_core_sort_default_ascending.handler)
1794                 watch_bool (&watch_core_sort_default_ascending);
1795         set_bool (&watch_core_sort_default_ascending, x);
1796 }
1797
1798 GOConfNode *
1799 gnm_conf_get_core_sort_default_ascending_node (void)
1800 {
1801         return get_watch_node (&watch_core_sort_default_ascending);
1802 }
1803
1804 static struct cb_watch_bool watch_core_sort_default_by_case = {
1805         0, "core/sort/default/by-case",
1806         "Sort is Case-Sensitive",
1807         "Setting this option will cause the sort buttons on the toolbar to perform a case-sensitive sort and determine the initial state of the case-sensitive checkbox in the sort dialog.",
1808         FALSE,
1809 };
1810
1811 gboolean
1812 gnm_conf_get_core_sort_default_by_case (void)
1813 {
1814         if (!watch_core_sort_default_by_case.handler)
1815                 watch_bool (&watch_core_sort_default_by_case);
1816         return watch_core_sort_default_by_case.var;
1817 }
1818
1819 void
1820 gnm_conf_set_core_sort_default_by_case (gboolean x)
1821 {
1822         if (!watch_core_sort_default_by_case.handler)
1823                 watch_bool (&watch_core_sort_default_by_case);
1824         set_bool (&watch_core_sort_default_by_case, x);
1825 }
1826
1827 GOConfNode *
1828 gnm_conf_get_core_sort_default_by_case_node (void)
1829 {
1830         return get_watch_node (&watch_core_sort_default_by_case);
1831 }
1832
1833 static struct cb_watch_bool watch_core_sort_default_retain_formats = {
1834         0, "core/sort/default/retain-formats",
1835         "Sorting Preserves Formats",
1836         "Setting this option will cause the sort buttons on the toolbar to preserve the cell formats while sorting and determines the initial state of the preserve-formats checkbox in the sort dialog.",
1837         TRUE,
1838 };
1839
1840 gboolean
1841 gnm_conf_get_core_sort_default_retain_formats (void)
1842 {
1843         if (!watch_core_sort_default_retain_formats.handler)
1844                 watch_bool (&watch_core_sort_default_retain_formats);
1845         return watch_core_sort_default_retain_formats.var;
1846 }
1847
1848 void
1849 gnm_conf_set_core_sort_default_retain_formats (gboolean x)
1850 {
1851         if (!watch_core_sort_default_retain_formats.handler)
1852                 watch_bool (&watch_core_sort_default_retain_formats);
1853         set_bool (&watch_core_sort_default_retain_formats, x);
1854 }
1855
1856 GOConfNode *
1857 gnm_conf_get_core_sort_default_retain_formats_node (void)
1858 {
1859         return get_watch_node (&watch_core_sort_default_retain_formats);
1860 }
1861
1862 static struct cb_watch_int watch_core_sort_dialog_max_initial_clauses = {
1863         0, "core/sort/dialog/max-initial-clauses",
1864         "Number of Automatic Clauses",
1865         "When selecting a sort region in the sort dialog, sort clauses are automatically added. This number determines the maximum number of clauses to be added automatically.",
1866         0, 256, 10,
1867 };
1868
1869 int
1870 gnm_conf_get_core_sort_dialog_max_initial_clauses (void)
1871 {
1872         if (!watch_core_sort_dialog_max_initial_clauses.handler)
1873                 watch_int (&watch_core_sort_dialog_max_initial_clauses);
1874         return watch_core_sort_dialog_max_initial_clauses.var;
1875 }
1876
1877 void
1878 gnm_conf_set_core_sort_dialog_max_initial_clauses (int x)
1879 {
1880         if (!watch_core_sort_dialog_max_initial_clauses.handler)
1881                 watch_int (&watch_core_sort_dialog_max_initial_clauses);
1882         set_int (&watch_core_sort_dialog_max_initial_clauses, x);
1883 }
1884
1885 GOConfNode *
1886 gnm_conf_get_core_sort_dialog_max_initial_clauses_node (void)
1887 {
1888         return get_watch_node (&watch_core_sort_dialog_max_initial_clauses);
1889 }
1890
1891 static struct cb_watch_int watch_core_workbook_autosave_time = {
1892         0, "core/workbook/autosave-time",
1893         "Autosave frequency",
1894         "The number of seconds between autosaves.",
1895         0, 365 * 24 * 60 * 60, 0,
1896 };
1897
1898 int
1899 gnm_conf_get_core_workbook_autosave_time (void)
1900 {
1901         if (!watch_core_workbook_autosave_time.handler)
1902                 watch_int (&watch_core_workbook_autosave_time);
1903         return watch_core_workbook_autosave_time.var;
1904 }
1905
1906 void
1907 gnm_conf_set_core_workbook_autosave_time (int x)
1908 {
1909         if (!watch_core_workbook_autosave_time.handler)
1910                 watch_int (&watch_core_workbook_autosave_time);
1911         set_int (&watch_core_workbook_autosave_time, x);
1912 }
1913
1914 GOConfNode *
1915 gnm_conf_get_core_workbook_autosave_time_node (void)
1916 {
1917         return get_watch_node (&watch_core_workbook_autosave_time);
1918 }
1919
1920 static struct cb_watch_int watch_core_workbook_n_cols = {
1921         0, "core/workbook/n-cols",
1922         "Default Number of columns in a sheet",
1923         "The number of columns in each sheet. This setting will be used only in a new Gnumeric session.",
1924         GNM_MIN_COLS, GNM_MAX_COLS, 256,
1925 };
1926
1927 int
1928 gnm_conf_get_core_workbook_n_cols (void)
1929 {
1930         if (!watch_core_workbook_n_cols.handler)
1931                 watch_int (&watch_core_workbook_n_cols);
1932         return watch_core_workbook_n_cols.var;
1933 }
1934
1935 void
1936 gnm_conf_set_core_workbook_n_cols (int x)
1937 {
1938         if (!watch_core_workbook_n_cols.handler)
1939                 watch_int (&watch_core_workbook_n_cols);
1940         set_int (&watch_core_workbook_n_cols, x);
1941 }
1942
1943 GOConfNode *
1944 gnm_conf_get_core_workbook_n_cols_node (void)
1945 {
1946         return get_watch_node (&watch_core_workbook_n_cols);
1947 }
1948
1949 static struct cb_watch_int watch_core_workbook_n_rows = {
1950         0, "core/workbook/n-rows",
1951         "Default Number of rows in a sheet",
1952         "The number of rows in each sheet. This setting will be used only in a new Gnumeric session.",
1953         GNM_MIN_ROWS, GNM_MAX_ROWS, 65536,
1954 };
1955
1956 int
1957 gnm_conf_get_core_workbook_n_rows (void)
1958 {
1959         if (!watch_core_workbook_n_rows.handler)
1960                 watch_int (&watch_core_workbook_n_rows);
1961         return watch_core_workbook_n_rows.var;
1962 }
1963
1964 void
1965 gnm_conf_set_core_workbook_n_rows (int x)
1966 {
1967         if (!watch_core_workbook_n_rows.handler)
1968                 watch_int (&watch_core_workbook_n_rows);
1969         set_int (&watch_core_workbook_n_rows, x);
1970 }
1971
1972 GOConfNode *
1973 gnm_conf_get_core_workbook_n_rows_node (void)
1974 {
1975         return get_watch_node (&watch_core_workbook_n_rows);
1976 }
1977
1978 static struct cb_watch_int watch_core_workbook_n_sheet = {
1979         0, "core/workbook/n-sheet",
1980         "Default Number of Sheets",
1981         "The number of sheets initially created in a new workbook.",
1982         1, 64, 3,
1983 };
1984
1985 int
1986 gnm_conf_get_core_workbook_n_sheet (void)
1987 {
1988         if (!watch_core_workbook_n_sheet.handler)
1989                 watch_int (&watch_core_workbook_n_sheet);
1990         return watch_core_workbook_n_sheet.var;
1991 }
1992
1993 void
1994 gnm_conf_set_core_workbook_n_sheet (int x)
1995 {
1996         if (!watch_core_workbook_n_sheet.handler)
1997                 watch_int (&watch_core_workbook_n_sheet);
1998         set_int (&watch_core_workbook_n_sheet, x);
1999 }
2000
2001 GOConfNode *
2002 gnm_conf_get_core_workbook_n_sheet_node (void)
2003 {
2004         return get_watch_node (&watch_core_workbook_n_sheet);
2005 }
2006
2007 static struct cb_watch_int watch_core_xml_compression_level = {
2008         0, "core/xml/compression-level",
2009         "Default Compression Level For Gnumeric Files",
2010         "This integer (between 0 and 9) specifies the amount of compression performed by Gnumeric when saving files in the default file format. 0 is minimal compression while 9 is maximal compression.",
2011         0, 9, 9,
2012 };
2013
2014 int
2015 gnm_conf_get_core_xml_compression_level (void)
2016 {
2017         if (!watch_core_xml_compression_level.handler)
2018                 watch_int (&watch_core_xml_compression_level);
2019         return watch_core_xml_compression_level.var;
2020 }
2021
2022 void
2023 gnm_conf_set_core_xml_compression_level (int x)
2024 {
2025         if (!watch_core_xml_compression_level.handler)
2026                 watch_int (&watch_core_xml_compression_level);
2027         set_int (&watch_core_xml_compression_level, x);
2028 }
2029
2030 GOConfNode *
2031 gnm_conf_get_core_xml_compression_level_node (void)
2032 {
2033         return get_watch_node (&watch_core_xml_compression_level);
2034 }
2035
2036 static struct cb_watch_bool watch_cut_and_paste_prefer_clipboard = {
2037         0, "cut-and-paste/prefer-clipboard",
2038         "Prefer CLIPBOARD over PRIMARY selection",
2039         "When TRUE, Gnumeric will prefer the modern CLIPBOARD selection over the legacy PRIMARY selections.  Set to FALSE if you have to deal with older applications, like Xterm or Emacs, which set only the PRIMARY selection.",
2040         TRUE,
2041 };
2042
2043 gboolean
2044 gnm_conf_get_cut_and_paste_prefer_clipboard (void)
2045 {
2046         if (!watch_cut_and_paste_prefer_clipboard.handler)
2047                 watch_bool (&watch_cut_and_paste_prefer_clipboard);
2048         return watch_cut_and_paste_prefer_clipboard.var;
2049 }
2050
2051 void
2052 gnm_conf_set_cut_and_paste_prefer_clipboard (gboolean x)
2053 {
2054         if (!watch_cut_and_paste_prefer_clipboard.handler)
2055                 watch_bool (&watch_cut_and_paste_prefer_clipboard);
2056         set_bool (&watch_cut_and_paste_prefer_clipboard, x);
2057 }
2058
2059 GOConfNode *
2060 gnm_conf_get_cut_and_paste_prefer_clipboard_node (void)
2061 {
2062         return get_watch_node (&watch_cut_and_paste_prefer_clipboard);
2063 }
2064
2065 static struct cb_watch_bool watch_dialogs_rs_unfocused = {
2066         0, "dialogs/rs/unfocused",
2067         "Allow Unfocused Range Selections",
2068         "Some dialogs contain only a single entry field that allows range selections in the workbook. Setting this variable to TRUE directs selections to this entry even if the entry does not have keyboard focus.",
2069         FALSE,
2070 };
2071
2072 gboolean
2073 gnm_conf_get_dialogs_rs_unfocused (void)
2074 {
2075         if (!watch_dialogs_rs_unfocused.handler)
2076                 watch_bool (&watch_dialogs_rs_unfocused);
2077         return watch_dialogs_rs_unfocused.var;
2078 }
2079
2080 void
2081 gnm_conf_set_dialogs_rs_unfocused (gboolean x)
2082 {
2083         if (!watch_dialogs_rs_unfocused.handler)
2084                 watch_bool (&watch_dialogs_rs_unfocused);
2085         set_bool (&watch_dialogs_rs_unfocused, x);
2086 }
2087
2088 GOConfNode *
2089 gnm_conf_get_dialogs_rs_unfocused_node (void)
2090 {
2091         return get_watch_node (&watch_dialogs_rs_unfocused);
2092 }
2093
2094 static struct cb_watch_int watch_functionselector_num_of_recent = {
2095         0, "functionselector/num-of-recent",
2096         "Maximum Length of Recently Used Functions List",
2097         "The function selector keeps a list of recently used functions. This is the maximum length of that list.",
2098         0, 40, 12,
2099 };
2100
2101 int
2102 gnm_conf_get_functionselector_num_of_recent (void)
2103 {
2104         if (!watch_functionselector_num_of_recent.handler)
2105                 watch_int (&watch_functionselector_num_of_recent);
2106         return watch_functionselector_num_of_recent.var;
2107 }
2108
2109 void
2110 gnm_conf_set_functionselector_num_of_recent (int x)
2111 {
2112         if (!watch_functionselector_num_of_recent.handler)
2113                 watch_int (&watch_functionselector_num_of_recent);
2114         set_int (&watch_functionselector_num_of_recent, x);
2115 }
2116
2117 GOConfNode *
2118 gnm_conf_get_functionselector_num_of_recent_node (void)
2119 {
2120         return get_watch_node (&watch_functionselector_num_of_recent);
2121 }
2122
2123 static struct cb_watch_string_list watch_functionselector_recentfunctions = {
2124         0, "functionselector/recentfunctions",
2125         "List of recently used functions.",
2126         "The function selector keeps a list of recently used functions. This is that list.",
2127 };
2128
2129 /**
2130  * gnm_conf_get_functionselector_recentfunctions:
2131  *
2132  * Returns: (element-type char) (transfer none):
2133  **/
2134 GSList *
2135 gnm_conf_get_functionselector_recentfunctions (void)
2136 {
2137         if (!watch_functionselector_recentfunctions.handler)
2138                 watch_string_list (&watch_functionselector_recentfunctions);
2139         return watch_functionselector_recentfunctions.var;
2140 }
2141
2142 /**
2143  * gnm_conf_set_functionselector_recentfunctions:
2144  * @x: (element-type char): list of strings
2145  *
2146  **/
2147 void
2148 gnm_conf_set_functionselector_recentfunctions (GSList *x)
2149 {
2150         if (!watch_functionselector_recentfunctions.handler)
2151                 watch_string_list (&watch_functionselector_recentfunctions);
2152         set_string_list (&watch_functionselector_recentfunctions, x);
2153 }
2154
2155 GOConfNode *
2156 gnm_conf_get_functionselector_recentfunctions_node (void)
2157 {
2158         return get_watch_node (&watch_functionselector_recentfunctions);
2159 }
2160
2161 static struct cb_watch_string watch_plugin_glpk_glpsol_path = {
2162         0, "plugin/glpk/glpsol-path",
2163         "Full path of glpsol program to use",
2164         "This is the full path to the glpsol binary that the lpsolve plugin should use.",
2165         "",
2166 };
2167
2168 const char *
2169 gnm_conf_get_plugin_glpk_glpsol_path (void)
2170 {
2171         if (!watch_plugin_glpk_glpsol_path.handler)
2172                 watch_string (&watch_plugin_glpk_glpsol_path);
2173         return watch_plugin_glpk_glpsol_path.var;
2174 }
2175
2176 void
2177 gnm_conf_set_plugin_glpk_glpsol_path (const char *x)
2178 {
2179         g_return_if_fail (x != NULL);
2180         if (!watch_plugin_glpk_glpsol_path.handler)
2181                 watch_string (&watch_plugin_glpk_glpsol_path);
2182         set_string (&watch_plugin_glpk_glpsol_path, x);
2183 }
2184
2185 GOConfNode *
2186 gnm_conf_get_plugin_glpk_glpsol_path_node (void)
2187 {
2188         return get_watch_node (&watch_plugin_glpk_glpsol_path);
2189 }
2190
2191 static struct cb_watch_bool watch_plugin_latex_use_utf8 = {
2192         0, "plugin/latex/use-utf8",
2193         "Use UTF-8 in LaTeX Export",
2194         "This setting determines whether created LaTeX files use UTF-8 (unicode) or ISO-8859-1 (Latin1). To use the UTF-8 files, you must have the ucs LaTeX package installed.",
2195         FALSE,
2196 };
2197
2198 gboolean
2199 gnm_conf_get_plugin_latex_use_utf8 (void)
2200 {
2201         if (!watch_plugin_latex_use_utf8.handler)
2202                 watch_bool (&watch_plugin_latex_use_utf8);
2203         return watch_plugin_latex_use_utf8.var;
2204 }
2205
2206 void
2207 gnm_conf_set_plugin_latex_use_utf8 (gboolean x)
2208 {
2209         if (!watch_plugin_latex_use_utf8.handler)
2210                 watch_bool (&watch_plugin_latex_use_utf8);
2211         set_bool (&watch_plugin_latex_use_utf8, x);
2212 }
2213
2214 GOConfNode *
2215 gnm_conf_get_plugin_latex_use_utf8_node (void)
2216 {
2217         return get_watch_node (&watch_plugin_latex_use_utf8);
2218 }
2219
2220 static struct cb_watch_string watch_plugin_lpsolve_lpsolve_path = {
2221         0, "plugin/lpsolve/lpsolve-path",
2222         "Full path of lp_solve program to use",
2223         "This is the full path to the lp_solve binary that the lpsolve plugin should use.",
2224         "",
2225 };
2226
2227 const char *
2228 gnm_conf_get_plugin_lpsolve_lpsolve_path (void)
2229 {
2230         if (!watch_plugin_lpsolve_lpsolve_path.handler)
2231                 watch_string (&watch_plugin_lpsolve_lpsolve_path);
2232         return watch_plugin_lpsolve_lpsolve_path.var;
2233 }
2234
2235 void
2236 gnm_conf_set_plugin_lpsolve_lpsolve_path (const char *x)
2237 {
2238         g_return_if_fail (x != NULL);
2239         if (!watch_plugin_lpsolve_lpsolve_path.handler)
2240                 watch_string (&watch_plugin_lpsolve_lpsolve_path);
2241         set_string (&watch_plugin_lpsolve_lpsolve_path, x);
2242 }
2243
2244 GOConfNode *
2245 gnm_conf_get_plugin_lpsolve_lpsolve_path_node (void)
2246 {
2247         return get_watch_node (&watch_plugin_lpsolve_lpsolve_path);
2248 }
2249
2250 static struct cb_watch_bool watch_plugins_activate_newplugins = {
2251         0, "plugins/activate-newplugins",
2252         "Activate New Plugins",
2253         "This variable determines whether to activate every new encountered plugin.",
2254         TRUE,
2255 };
2256
2257 gboolean
2258 gnm_conf_get_plugins_activate_newplugins (void)
2259 {
2260         if (!watch_plugins_activate_newplugins.handler)
2261                 watch_bool (&watch_plugins_activate_newplugins);
2262         return watch_plugins_activate_newplugins.var;
2263 }
2264
2265 void
2266 gnm_conf_set_plugins_activate_newplugins (gboolean x)
2267 {
2268         if (!watch_plugins_activate_newplugins.handler)
2269                 watch_bool (&watch_plugins_activate_newplugins);
2270         set_bool (&watch_plugins_activate_newplugins, x);
2271 }
2272
2273 GOConfNode *
2274 gnm_conf_get_plugins_activate_newplugins_node (void)
2275 {
2276         return get_watch_node (&watch_plugins_activate_newplugins);
2277 }
2278
2279 static struct cb_watch_string_list watch_plugins_active = {
2280         0, "plugins/active",
2281         "List of Active Plugins.",
2282         "This list contains all plugins that are supposed to be automatically activated.",
2283 };
2284
2285 /**
2286  * gnm_conf_get_plugins_active:
2287  *
2288  * Returns: (element-type char) (transfer none):
2289  **/
2290 GSList *
2291 gnm_conf_get_plugins_active (void)
2292 {
2293         if (!watch_plugins_active.handler)
2294                 watch_string_list (&watch_plugins_active);
2295         return watch_plugins_active.var;
2296 }
2297
2298 /**
2299  * gnm_conf_set_plugins_active:
2300  * @x: (element-type char): list of strings
2301  *
2302  **/
2303 void
2304 gnm_conf_set_plugins_active (GSList *x)
2305 {
2306         if (!watch_plugins_active.handler)
2307                 watch_string_list (&watch_plugins_active);
2308         set_string_list (&watch_plugins_active, x);
2309 }
2310
2311 GOConfNode *
2312 gnm_conf_get_plugins_active_node (void)
2313 {
2314         return get_watch_node (&watch_plugins_active);
2315 }
2316
2317 static struct cb_watch_string_list watch_plugins_extra_dirs = {
2318         0, "plugins/extra-dirs",
2319         "List of Extra Plugin Directories.",
2320         "This list contains all extra directories containing plugins.",
2321 };
2322
2323 /**
2324  * gnm_conf_get_plugins_extra_dirs:
2325  *
2326  * Returns: (element-type char) (transfer none):
2327  **/
2328 GSList *
2329 gnm_conf_get_plugins_extra_dirs (void)
2330 {
2331         if (!watch_plugins_extra_dirs.handler)
2332                 watch_string_list (&watch_plugins_extra_dirs);
2333         return watch_plugins_extra_dirs.var;
2334 }
2335
2336 /**
2337  * gnm_conf_set_plugins_extra_dirs:
2338  * @x: (element-type char): list of strings
2339  *
2340  **/
2341 void
2342 gnm_conf_set_plugins_extra_dirs (GSList *x)
2343 {
2344         if (!watch_plugins_extra_dirs.handler)
2345                 watch_string_list (&watch_plugins_extra_dirs);
2346         set_string_list (&watch_plugins_extra_dirs, x);
2347 }
2348
2349 GOConfNode *
2350 gnm_conf_get_plugins_extra_dirs_node (void)
2351 {
2352         return get_watch_node (&watch_plugins_extra_dirs);
2353 }
2354
2355 static struct cb_watch_string_list watch_plugins_file_states = {
2356         0, "plugins/file-states",
2357         "List of Plugin File States.",
2358         "This list contains all plugin file states.",
2359 };
2360
2361 /**
2362  * gnm_conf_get_plugins_file_states:
2363  *
2364  * Returns: (element-type char) (transfer none):
2365  **/
2366 GSList *
2367 gnm_conf_get_plugins_file_states (void)
2368 {
2369         if (!watch_plugins_file_states.handler)
2370                 watch_string_list (&watch_plugins_file_states);
2371         return watch_plugins_file_states.var;
2372 }
2373
2374 /**
2375  * gnm_conf_set_plugins_file_states:
2376  * @x: (element-type char): list of strings
2377  *
2378  **/
2379 void
2380 gnm_conf_set_plugins_file_states (GSList *x)
2381 {
2382         if (!watch_plugins_file_states.handler)
2383                 watch_string_list (&watch_plugins_file_states);
2384         set_string_list (&watch_plugins_file_states, x);
2385 }
2386
2387 GOConfNode *
2388 gnm_conf_get_plugins_file_states_node (void)
2389 {
2390         return get_watch_node (&watch_plugins_file_states);
2391 }
2392
2393 static struct cb_watch_string_list watch_plugins_known = {
2394         0, "plugins/known",
2395         "List of Known Plugins.",
2396         "This list contains all known plugins.",
2397 };
2398
2399 /**
2400  * gnm_conf_get_plugins_known:
2401  *
2402  * Returns: (element-type char) (transfer none):
2403  **/
2404 GSList *
2405 gnm_conf_get_plugins_known (void)
2406 {
2407         if (!watch_plugins_known.handler)
2408                 watch_string_list (&watch_plugins_known);
2409         return watch_plugins_known.var;
2410 }
2411
2412 /**
2413  * gnm_conf_set_plugins_known:
2414  * @x: (element-type char): list of strings
2415  *
2416  **/
2417 void
2418 gnm_conf_set_plugins_known (GSList *x)
2419 {
2420         if (!watch_plugins_known.handler)
2421                 watch_string_list (&watch_plugins_known);
2422         set_string_list (&watch_plugins_known, x);
2423 }
2424
2425 GOConfNode *
2426 gnm_conf_get_plugins_known_node (void)
2427 {
2428         return get_watch_node (&watch_plugins_known);
2429 }
2430
2431 static struct cb_watch_bool watch_printsetup_across_then_down = {
2432         0, "printsetup/across-then-down",
2433         "Default Print Direction",
2434         "This value determines the default setting in the Print Setup dialog whether to print first right then down. Please use the Print Setup dialog to edit this value.",
2435         FALSE,
2436 };
2437
2438 gboolean
2439 gnm_conf_get_printsetup_across_then_down (void)
2440 {
2441         if (!watch_printsetup_across_then_down.handler)
2442                 watch_bool (&watch_printsetup_across_then_down);
2443         return watch_printsetup_across_then_down.var;
2444 }
2445
2446 void
2447 gnm_conf_set_printsetup_across_then_down (gboolean x)
2448 {
2449         if (!watch_printsetup_across_then_down.handler)
2450                 watch_bool (&watch_printsetup_across_then_down);
2451         set_bool (&watch_printsetup_across_then_down, x);
2452 }
2453
2454 GOConfNode *
2455 gnm_conf_get_printsetup_across_then_down_node (void)
2456 {
2457         return get_watch_node (&watch_printsetup_across_then_down);
2458 }
2459
2460 static struct cb_watch_bool watch_printsetup_all_sheets = {
2461         0, "printsetup/all-sheets",
2462         "Apply print-setup to all sheets",
2463         "This value determines whether by default the print set-up dialog applies to all sheets simultaneously.",
2464         FALSE,
2465 };
2466
2467 gboolean
2468 gnm_conf_get_printsetup_all_sheets (void)
2469 {
2470         if (!watch_printsetup_all_sheets.handler)
2471                 watch_bool (&watch_printsetup_all_sheets);
2472         return watch_printsetup_all_sheets.var;
2473 }
2474
2475 void
2476 gnm_conf_set_printsetup_all_sheets (gboolean x)
2477 {
2478         if (!watch_printsetup_all_sheets.handler)
2479                 watch_bool (&watch_printsetup_all_sheets);
2480         set_bool (&watch_printsetup_all_sheets, x);
2481 }
2482
2483 GOConfNode *
2484 gnm_conf_get_printsetup_all_sheets_node (void)
2485 {
2486         return get_watch_node (&watch_printsetup_all_sheets);
2487 }
2488
2489 static struct cb_watch_bool watch_printsetup_center_horizontally = {
2490         0, "printsetup/center-horizontally",
2491         "Default Horizontal Centering",
2492         "This value determines whether the default setting in the Print Setup dialog is to center pages horizontally.",
2493         FALSE,
2494 };
2495
2496 gboolean
2497 gnm_conf_get_printsetup_center_horizontally (void)
2498 {
2499         if (!watch_printsetup_center_horizontally.handler)
2500                 watch_bool (&watch_printsetup_center_horizontally);
2501         return watch_printsetup_center_horizontally.var;
2502 }
2503
2504 void
2505 gnm_conf_set_printsetup_center_horizontally (gboolean x)
2506 {
2507         if (!watch_printsetup_center_horizontally.handler)
2508                 watch_bool (&watch_printsetup_center_horizontally);
2509         set_bool (&watch_printsetup_center_horizontally, x);
2510 }
2511
2512 GOConfNode *
2513 gnm_conf_get_printsetup_center_horizontally_node (void)
2514 {
2515         return get_watch_node (&watch_printsetup_center_horizontally);
2516 }
2517
2518 static struct cb_watch_bool watch_printsetup_center_vertically = {
2519         0, "printsetup/center-vertically",
2520         "Default Vertical Centering",
2521         "This value determines whether the default setting in the Print Setup dialog is to center pages vertically.",
2522         FALSE,
2523 };
2524
2525 gboolean
2526 gnm_conf_get_printsetup_center_vertically (void)
2527 {
2528         if (!watch_printsetup_center_vertically.handler)
2529                 watch_bool (&watch_printsetup_center_vertically);
2530         return watch_printsetup_center_vertically.var;
2531 }
2532
2533 void
2534 gnm_conf_set_printsetup_center_vertically (gboolean x)
2535 {
2536         if (!watch_printsetup_center_vertically.handler)
2537                 watch_bool (&watch_printsetup_center_vertically);
2538         set_bool (&watch_printsetup_center_vertically, x);
2539 }
2540
2541 GOConfNode *
2542 gnm_conf_get_printsetup_center_vertically_node (void)
2543 {
2544         return get_watch_node (&watch_printsetup_center_vertically);
2545 }
2546
2547 static struct cb_watch_string_list watch_printsetup_footer = {
2548         0, "printsetup/footer",
2549         "Page Footer",
2550         "The default page footer for new documents that can be modified using the\n     page setup dialog.",
2551 };
2552
2553 /**
2554  * gnm_conf_get_printsetup_footer:
2555  *
2556  * Returns: (element-type char) (transfer none):
2557  **/
2558 GSList *
2559 gnm_conf_get_printsetup_footer (void)
2560 {
2561         if (!watch_printsetup_footer.handler)
2562                 watch_string_list (&watch_printsetup_footer);
2563         return watch_printsetup_footer.var;
2564 }
2565
2566 /**
2567  * gnm_conf_set_printsetup_footer:
2568  * @x: (element-type char): list of strings
2569  *
2570  **/
2571 void
2572 gnm_conf_set_printsetup_footer (GSList *x)
2573 {
2574         if (!watch_printsetup_footer.handler)
2575                 watch_string_list (&watch_printsetup_footer);
2576         set_string_list (&watch_printsetup_footer, x);
2577 }
2578
2579 GOConfNode *
2580 gnm_conf_get_printsetup_footer_node (void)
2581 {
2582         return get_watch_node (&watch_printsetup_footer);
2583 }
2584
2585 static struct cb_watch_string_list watch_printsetup_gtk_setting = {
2586         0, "printsetup/gtk-setting",
2587         "GTKPrintSetting",
2588         "The configuration of GTKPrintSetting. Do not edit this variable.",
2589 };
2590
2591 /**
2592  * gnm_conf_get_printsetup_gtk_setting:
2593  *
2594  * Returns: (element-type char) (transfer none):
2595  **/
2596 GSList *
2597 gnm_conf_get_printsetup_gtk_setting (void)
2598 {
2599         if (!watch_printsetup_gtk_setting.handler)
2600                 watch_string_list (&watch_printsetup_gtk_setting);
2601         return watch_printsetup_gtk_setting.var;
2602 }
2603
2604 /**
2605  * gnm_conf_set_printsetup_gtk_setting:
2606  * @x: (element-type char): list of strings
2607  *
2608  **/
2609 void
2610 gnm_conf_set_printsetup_gtk_setting (GSList *x)
2611 {
2612         if (!watch_printsetup_gtk_setting.handler)
2613                 watch_string_list (&watch_printsetup_gtk_setting);
2614         set_string_list (&watch_printsetup_gtk_setting, x);
2615 }
2616
2617 GOConfNode *
2618 gnm_conf_get_printsetup_gtk_setting_node (void)
2619 {
2620         return get_watch_node (&watch_printsetup_gtk_setting);
2621 }
2622
2623 static struct cb_watch_string_list watch_printsetup_header = {
2624         0, "printsetup/header",
2625         "Page Header",
2626         "The default page header for new documents that can be modified using the\n     page setup dialog.",
2627 };
2628
2629 /**
2630  * gnm_conf_get_printsetup_header:
2631  *
2632  * Returns: (element-type char) (transfer none):
2633  **/
2634 GSList *
2635 gnm_conf_get_printsetup_header (void)
2636 {
2637         if (!watch_printsetup_header.handler)
2638                 watch_string_list (&watch_printsetup_header);
2639         return watch_printsetup_header.var;
2640 }
2641
2642 /**
2643  * gnm_conf_set_printsetup_header:
2644  * @x: (element-type char): list of strings
2645  *
2646  **/
2647 void
2648 gnm_conf_set_printsetup_header (GSList *x)
2649 {
2650         if (!watch_printsetup_header.handler)
2651                 watch_string_list (&watch_printsetup_header);
2652         set_string_list (&watch_printsetup_header, x);
2653 }
2654
2655 GOConfNode *
2656 gnm_conf_get_printsetup_header_node (void)
2657 {
2658         return get_watch_node (&watch_printsetup_header);
2659 }
2660
2661 static struct cb_watch_bool watch_printsetup_hf_font_bold = {
2662         0, "printsetup/hf-font-bold",
2663         "The default header/footer font is bold.",
2664         "This value determines whether the default font for headers and footers is bold.",
2665         FALSE,
2666 };
2667
2668 gboolean
2669 gnm_conf_get_printsetup_hf_font_bold (void)
2670 {
2671         if (!watch_printsetup_hf_font_bold.handler)
2672                 watch_bool (&watch_printsetup_hf_font_bold);
2673         return watch_printsetup_hf_font_bold.var;
2674 }
2675
2676 void
2677 gnm_conf_set_printsetup_hf_font_bold (gboolean x)
2678 {
2679         if (!watch_printsetup_hf_font_bold.handler)
2680                 watch_bool (&watch_printsetup_hf_font_bold);
2681         set_bool (&watch_printsetup_hf_font_bold, x);
2682 }
2683
2684 GOConfNode *
2685 gnm_conf_get_printsetup_hf_font_bold_node (void)
2686 {
2687         return get_watch_node (&watch_printsetup_hf_font_bold);
2688 }
2689
2690 static struct cb_watch_bool watch_printsetup_hf_font_italic = {
2691         0, "printsetup/hf-font-italic",
2692         "The default header/footer font is italic.",
2693         "This value determines whether the default font for headers and footers is italic.",
2694         FALSE,
2695 };
2696
2697 gboolean
2698 gnm_conf_get_printsetup_hf_font_italic (void)
2699 {
2700         if (!watch_printsetup_hf_font_italic.handler)
2701                 watch_bool (&watch_printsetup_hf_font_italic);
2702         return watch_printsetup_hf_font_italic.var;
2703 }
2704
2705 void
2706 gnm_conf_set_printsetup_hf_font_italic (gboolean x)
2707 {
2708         if (!watch_printsetup_hf_font_italic.handler)
2709                 watch_bool (&watch_printsetup_hf_font_italic);
2710         set_bool (&watch_printsetup_hf_font_italic, x);
2711 }
2712
2713 GOConfNode *
2714 gnm_conf_get_printsetup_hf_font_italic_node (void)
2715 {
2716         return get_watch_node (&watch_printsetup_hf_font_italic);
2717 }
2718
2719 static struct cb_watch_string watch_printsetup_hf_font_name = {
2720         0, "printsetup/hf-font-name",
2721         "Default header/footer font name",
2722         "The default font name for headers and footers.",
2723         "Sans",
2724 };
2725
2726 const char *
2727 gnm_conf_get_printsetup_hf_font_name (void)
2728 {
2729         if (!watch_printsetup_hf_font_name.handler)
2730                 watch_string (&watch_printsetup_hf_font_name);
2731         return watch_printsetup_hf_font_name.var;
2732 }
2733
2734 void
2735 gnm_conf_set_printsetup_hf_font_name (const char *x)
2736 {
2737         g_return_if_fail (x != NULL);
2738         if (!watch_printsetup_hf_font_name.handler)
2739                 watch_string (&watch_printsetup_hf_font_name);
2740         set_string (&watch_printsetup_hf_font_name, x);
2741 }
2742
2743 GOConfNode *
2744 gnm_conf_get_printsetup_hf_font_name_node (void)
2745 {
2746         return get_watch_node (&watch_printsetup_hf_font_name);
2747 }
2748
2749 static struct cb_watch_double watch_printsetup_hf_font_size = {
2750         0, "printsetup/hf-font-size",
2751         "Default Header/Footer Font Size",
2752         "The default font size for headers and footers.",
2753         1, 100, 10,
2754 };
2755
2756 double
2757 gnm_conf_get_printsetup_hf_font_size (void)
2758 {
2759         if (!watch_printsetup_hf_font_size.handler)
2760                 watch_double (&watch_printsetup_hf_font_size);
2761         return watch_printsetup_hf_font_size.var;
2762 }
2763
2764 void
2765 gnm_conf_set_printsetup_hf_font_size (double x)
2766 {
2767         if (!watch_printsetup_hf_font_size.handler)
2768                 watch_double (&watch_printsetup_hf_font_size);
2769         set_double (&watch_printsetup_hf_font_size, x);
2770 }
2771
2772 GOConfNode *
2773 gnm_conf_get_printsetup_hf_font_size_node (void)
2774 {
2775         return get_watch_node (&watch_printsetup_hf_font_size);
2776 }
2777
2778 static struct cb_watch_string_list watch_printsetup_hf_left = {
2779         0, "printsetup/hf-left",
2780         "Header/Footer Format (Left Portion)",
2781         "Please use the Print Setup dialog to edit this value.",
2782 };
2783
2784 /**
2785  * gnm_conf_get_printsetup_hf_left:
2786  *
2787  * Returns: (element-type char) (transfer none):
2788  **/
2789 GSList *
2790 gnm_conf_get_printsetup_hf_left (void)
2791 {
2792         if (!watch_printsetup_hf_left.handler)
2793                 watch_string_list (&watch_printsetup_hf_left);
2794         return watch_printsetup_hf_left.var;
2795 }
2796
2797 /**
2798  * gnm_conf_set_printsetup_hf_left:
2799  * @x: (element-type char): list of strings
2800  *
2801  **/
2802 void
2803 gnm_conf_set_printsetup_hf_left (GSList *x)
2804 {
2805         if (!watch_printsetup_hf_left.handler)
2806                 watch_string_list (&watch_printsetup_hf_left);
2807         set_string_list (&watch_printsetup_hf_left, x);
2808 }
2809
2810 GOConfNode *
2811 gnm_conf_get_printsetup_hf_left_node (void)
2812 {
2813         return get_watch_node (&watch_printsetup_hf_left);
2814 }
2815
2816 static struct cb_watch_string_list watch_printsetup_hf_middle = {
2817         0, "printsetup/hf-middle",
2818         "Header/Footer Format (Middle Portion)",
2819         "Please use the Print Setup dialog to edit this value.",
2820 };
2821
2822 /**
2823  * gnm_conf_get_printsetup_hf_middle:
2824  *
2825  * Returns: (element-type char) (transfer none):
2826  **/
2827 GSList *
2828 gnm_conf_get_printsetup_hf_middle (void)
2829 {
2830         if (!watch_printsetup_hf_middle.handler)
2831                 watch_string_list (&watch_printsetup_hf_middle);
2832         return watch_printsetup_hf_middle.var;
2833 }
2834
2835 /**
2836  * gnm_conf_set_printsetup_hf_middle:
2837  * @x: (element-type char): list of strings
2838  *
2839  **/
2840 void
2841 gnm_conf_set_printsetup_hf_middle (GSList *x)
2842 {
2843         if (!watch_printsetup_hf_middle.handler)
2844                 watch_string_list (&watch_printsetup_hf_middle);
2845         set_string_list (&watch_printsetup_hf_middle, x);
2846 }
2847
2848 GOConfNode *
2849 gnm_conf_get_printsetup_hf_middle_node (void)
2850 {
2851         return get_watch_node (&watch_printsetup_hf_middle);
2852 }
2853
2854 static struct cb_watch_string_list watch_printsetup_hf_right = {
2855         0, "printsetup/hf-right",
2856         "Header/Footer Format (Right Portion)",
2857         "Please use the Print Setup dialog to edit this value.",
2858 };
2859
2860 /**
2861  * gnm_conf_get_printsetup_hf_right:
2862  *
2863  * Returns: (element-type char) (transfer none):
2864  **/
2865 GSList *
2866 gnm_conf_get_printsetup_hf_right (void)
2867 {
2868         if (!watch_printsetup_hf_right.handler)
2869                 watch_string_list (&watch_printsetup_hf_right);
2870         return watch_printsetup_hf_right.var;
2871 }
2872
2873 /**
2874  * gnm_conf_set_printsetup_hf_right:
2875  * @x: (element-type char): list of strings
2876  *
2877  **/
2878 void
2879 gnm_conf_set_printsetup_hf_right (GSList *x)
2880 {
2881         if (!watch_printsetup_hf_right.handler)
2882                 watch_string_list (&watch_printsetup_hf_right);
2883         set_string_list (&watch_printsetup_hf_right, x);
2884 }
2885
2886 GOConfNode *
2887 gnm_conf_get_printsetup_hf_right_node (void)
2888 {
2889         return get_watch_node (&watch_printsetup_hf_right);
2890 }
2891
2892 static struct cb_watch_double watch_printsetup_margin_bottom = {
2893         0, "printsetup/margin-bottom",
2894         "Default Bottom Margin",
2895         "This value gives the default number of points from the bottom of a page to the end of the body. Please use the Print Setup dialog to edit this value.",
2896         0, 10000, 120,
2897 };
2898
2899 double
2900 gnm_conf_get_printsetup_margin_bottom (void)
2901 {
2902         if (!watch_printsetup_margin_bottom.handler)
2903                 watch_double (&watch_printsetup_margin_bottom);
2904         return watch_printsetup_margin_bottom.var;
2905 }
2906
2907 void
2908 gnm_conf_set_printsetup_margin_bottom (double x)
2909 {
2910         if (!watch_printsetup_margin_bottom.handler)
2911                 watch_double (&watch_printsetup_margin_bottom);
2912         set_double (&watch_printsetup_margin_bottom, x);
2913 }
2914
2915 GOConfNode *
2916 gnm_conf_get_printsetup_margin_bottom_node (void)
2917 {
2918         return get_watch_node (&watch_printsetup_margin_bottom);
2919 }
2920
2921 static struct cb_watch_double watch_printsetup_margin_gtk_bottom = {
2922         0, "printsetup/margin-gtk-bottom",
2923         "Default Bottom Outside Margin",
2924         "This value gives the default number of points from the bottom of a page to the end of the footer. Please use the Print Setup dialog to edit this value.",
2925         0, 720, 72,
2926 };
2927
2928 double
2929 gnm_conf_get_printsetup_margin_gtk_bottom (void)
2930 {
2931         if (!watch_printsetup_margin_gtk_bottom.handler)
2932                 watch_double (&watch_printsetup_margin_gtk_bottom);
2933         return watch_printsetup_margin_gtk_bottom.var;
2934 }
2935
2936 void
2937 gnm_conf_set_printsetup_margin_gtk_bottom (double x)
2938 {
2939         if (!watch_printsetup_margin_gtk_bottom.handler)
2940                 watch_double (&watch_printsetup_margin_gtk_bottom);
2941         set_double (&watch_printsetup_margin_gtk_bottom, x);
2942 }
2943
2944 GOConfNode *
2945 gnm_conf_get_printsetup_margin_gtk_bottom_node (void)
2946 {
2947         return get_watch_node (&watch_printsetup_margin_gtk_bottom);
2948 }
2949
2950 static struct cb_watch_double watch_printsetup_margin_gtk_left = {
2951         0, "printsetup/margin-gtk-left",
2952         "Default Left Margin",
2953         "This value gives the default number of points from the left of a page to the left of the body. Please use the Print Setup dialog to edit this value.",
2954         0, 720, 72,
2955 };
2956
2957 double
2958 gnm_conf_get_printsetup_margin_gtk_left (void)
2959 {
2960         if (!watch_printsetup_margin_gtk_left.handler)
2961                 watch_double (&watch_printsetup_margin_gtk_left);
2962         return watch_printsetup_margin_gtk_left.var;
2963 }
2964
2965 void
2966 gnm_conf_set_printsetup_margin_gtk_left (double x)
2967 {
2968         if (!watch_printsetup_margin_gtk_left.handler)
2969                 watch_double (&watch_printsetup_margin_gtk_left);
2970         set_double (&watch_printsetup_margin_gtk_left, x);
2971 }
2972
2973 GOConfNode *
2974 gnm_conf_get_printsetup_margin_gtk_left_node (void)
2975 {
2976         return get_watch_node (&watch_printsetup_margin_gtk_left);
2977 }
2978
2979 static struct cb_watch_double watch_printsetup_margin_gtk_right = {
2980         0, "printsetup/margin-gtk-right",
2981         "Default Right Margin",
2982         "This value gives the default number of points from the right of a page to the right of the body. Please use the Print Setup dialog to edit this value.",
2983         0, 720, 72,
2984 };
2985
2986 double
2987 gnm_conf_get_printsetup_margin_gtk_right (void)
2988 {
2989         if (!watch_printsetup_margin_gtk_right.handler)
2990                 watch_double (&watch_printsetup_margin_gtk_right);
2991         return watch_printsetup_margin_gtk_right.var;
2992 }
2993
2994 void
2995 gnm_conf_set_printsetup_margin_gtk_right (double x)
2996 {
2997         if (!watch_printsetup_margin_gtk_right.handler)
2998                 watch_double (&watch_printsetup_margin_gtk_right);
2999         set_double (&watch_printsetup_margin_gtk_right, x);
3000 }
3001
3002 GOConfNode *
3003 gnm_conf_get_printsetup_margin_gtk_right_node (void)
3004 {
3005         return get_watch_node (&watch_printsetup_margin_gtk_right);
3006 }
3007
3008 static struct cb_watch_double watch_printsetup_margin_gtk_top = {
3009         0, "printsetup/margin-gtk-top",
3010         "Default Top Outside Margin",
3011         "This value gives the default number of points from the top of a page to the top of the header. Please use the Print Setup dialog to edit this value.",
3012         0, 720, 72,
3013 };
3014
3015 double
3016 gnm_conf_get_printsetup_margin_gtk_top (void)
3017 {
3018         if (!watch_printsetup_margin_gtk_top.handler)
3019                 watch_double (&watch_printsetup_margin_gtk_top);
3020         return watch_printsetup_margin_gtk_top.var;
3021 }
3022
3023 void
3024 gnm_conf_set_printsetup_margin_gtk_top (double x)
3025 {
3026         if (!watch_printsetup_margin_gtk_top.handler)
3027                 watch_double (&watch_printsetup_margin_gtk_top);
3028         set_double (&watch_printsetup_margin_gtk_top, x);
3029 }
3030
3031 GOConfNode *
3032 gnm_conf_get_printsetup_margin_gtk_top_node (void)
3033 {
3034         return get_watch_node (&watch_printsetup_margin_gtk_top);
3035 }
3036
3037 static struct cb_watch_double watch_printsetup_margin_top = {
3038         0, "printsetup/margin-top",
3039         "Default Top Margin",
3040         "This value gives the default number of points from the top of a page to the start of the body. Please use the Print Setup dialog to edit this value.",
3041         0, 10000, 120,
3042 };
3043
3044 double
3045 gnm_conf_get_printsetup_margin_top (void)
3046 {
3047         if (!watch_printsetup_margin_top.handler)
3048                 watch_double (&watch_printsetup_margin_top);
3049         return watch_printsetup_margin_top.var;
3050 }
3051
3052 void
3053 gnm_conf_set_printsetup_margin_top (double x)
3054 {
3055         if (!watch_printsetup_margin_top.handler)
3056                 watch_double (&watch_printsetup_margin_top);
3057         set_double (&watch_printsetup_margin_top, x);
3058 }
3059
3060 GOConfNode *
3061 gnm_conf_get_printsetup_margin_top_node (void)
3062 {
3063         return get_watch_node (&watch_printsetup_margin_top);
3064 }
3065
3066 static struct cb_watch_string watch_printsetup_paper = {
3067         0, "printsetup/paper",
3068         "Paper",
3069         "This is the default paper specification. Please use the Print Setup dialog to edit this value.",
3070         "",
3071 };
3072
3073 const char *
3074 gnm_conf_get_printsetup_paper (void)
3075 {
3076         if (!watch_printsetup_paper.handler)
3077                 watch_string (&watch_printsetup_paper);
3078         return watch_printsetup_paper.var;
3079 }
3080
3081 void
3082 gnm_conf_set_printsetup_paper (const char *x)
3083 {
3084         g_return_if_fail (x != NULL);
3085         if (!watch_printsetup_paper.handler)
3086                 watch_string (&watch_printsetup_paper);
3087         set_string (&watch_printsetup_paper, x);
3088 }
3089
3090 GOConfNode *
3091 gnm_conf_get_printsetup_paper_node (void)
3092 {
3093         return get_watch_node (&watch_printsetup_paper);
3094 }
3095
3096 static struct cb_watch_int watch_printsetup_paper_orientation = {
3097         0, "printsetup/paper-orientation",
3098         "Paper orientation",
3099         "This is the default paper orientation. Please use the Print Setup dialog to edit this value.",
3100         GTK_PAGE_ORIENTATION_PORTRAIT, GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE, 0,
3101 };
3102
3103 int
3104 gnm_conf_get_printsetup_paper_orientation (void)
3105 {
3106         if (!watch_printsetup_paper_orientation.handler)
3107                 watch_int (&watch_printsetup_paper_orientation);
3108         return watch_printsetup_paper_orientation.var;
3109 }
3110
3111 void
3112 gnm_conf_set_printsetup_paper_orientation (int x)
3113 {
3114         if (!watch_printsetup_paper_orientation.handler)
3115                 watch_int (&watch_printsetup_paper_orientation);
3116         set_int (&watch_printsetup_paper_orientation, x);
3117 }
3118
3119 GOConfNode *
3120 gnm_conf_get_printsetup_paper_orientation_node (void)
3121 {
3122         return get_watch_node (&watch_printsetup_paper_orientation);
3123 }
3124
3125 static struct cb_watch_enum watch_printsetup_preferred_unit = {
3126         0, "printsetup/preferred-unit",
3127         "Preferred Display Unit",
3128         "This string gives the default unit to be used in the page setup dialog.",
3129         GTK_UNIT_MM,
3130 };
3131
3132 GtkUnit
3133 gnm_conf_get_printsetup_preferred_unit (void)
3134 {
3135         if (!watch_printsetup_preferred_unit.handler)
3136                 watch_enum (&watch_printsetup_preferred_unit, GTK_TYPE_UNIT);
3137         return watch_printsetup_preferred_unit.var;
3138 }
3139
3140 void
3141 gnm_conf_set_printsetup_preferred_unit (GtkUnit x)
3142 {
3143         if (!watch_printsetup_preferred_unit.handler)
3144                 watch_enum (&watch_printsetup_preferred_unit, GTK_TYPE_UNIT);
3145         set_enum (&watch_printsetup_preferred_unit, x);
3146 }
3147
3148 GOConfNode *
3149 gnm_conf_get_printsetup_preferred_unit_node (void)
3150 {
3151         return get_watch_node (&watch_printsetup_preferred_unit);
3152 }
3153
3154 static struct cb_watch_bool watch_printsetup_print_black_n_white = {
3155         0, "printsetup/print-black-n-white",
3156         "Default Black and White Printing",
3157         "This value determines the default setting in the Print Setup dialog whether to print in only black and white. Please use the Print Setup dialog to edit this value.",
3158         FALSE,
3159 };
3160
3161 gboolean
3162 gnm_conf_get_printsetup_print_black_n_white (void)
3163 {
3164         if (!watch_printsetup_print_black_n_white.handler)
3165                 watch_bool (&watch_printsetup_print_black_n_white);
3166         return watch_printsetup_print_black_n_white.var;
3167 }
3168
3169 void
3170 gnm_conf_set_printsetup_print_black_n_white (gboolean x)
3171 {
3172         if (!watch_printsetup_print_black_n_white.handler)
3173                 watch_bool (&watch_printsetup_print_black_n_white);
3174         set_bool (&watch_printsetup_print_black_n_white, x);
3175 }
3176
3177 GOConfNode *
3178 gnm_conf_get_printsetup_print_black_n_white_node (void)
3179 {
3180         return get_watch_node (&watch_printsetup_print_black_n_white);
3181 }
3182
3183 static struct cb_watch_bool watch_printsetup_print_even_if_only_styles = {
3184         0, "printsetup/print-even-if-only-styles",
3185         "Default Print Cells with Only Styles",
3186         "This value determines the default setting in the Print Setup dialog whether to print empty but formatted cells. Please use the Print Setup dialog to edit this value.",
3187         FALSE,
3188 };
3189
3190 gboolean
3191 gnm_conf_get_printsetup_print_even_if_only_styles (void)
3192 {
3193         if (!watch_printsetup_print_even_if_only_styles.handler)
3194                 watch_bool (&watch_printsetup_print_even_if_only_styles);
3195         return watch_printsetup_print_even_if_only_styles.var;
3196 }
3197
3198 void
3199 gnm_conf_set_printsetup_print_even_if_only_styles (gboolean x)
3200 {
3201         if (!watch_printsetup_print_even_if_only_styles.handler)
3202                 watch_bool (&watch_printsetup_print_even_if_only_styles);
3203         set_bool (&watch_printsetup_print_even_if_only_styles, x);
3204 }
3205
3206 GOConfNode *
3207 gnm_conf_get_printsetup_print_even_if_only_styles_node (void)
3208 {
3209         return get_watch_node (&watch_printsetup_print_even_if_only_styles);
3210 }
3211
3212 static struct cb_watch_bool watch_printsetup_print_grid_lines = {
3213         0, "printsetup/print-grid-lines",
3214         "Default Grid Line Printing",
3215         "This value determines the default setting in the Print Setup dialog whether print grid lines. Please use the Print Setup dialog to edit this value.",
3216         FALSE,
3217 };
3218
3219 gboolean
3220 gnm_conf_get_printsetup_print_grid_lines (void)
3221 {
3222         if (!watch_printsetup_print_grid_lines.handler)
3223                 watch_bool (&watch_printsetup_print_grid_lines);
3224         return watch_printsetup_print_grid_lines.var;
3225 }
3226
3227 void
3228 gnm_conf_set_printsetup_print_grid_lines (gboolean x)
3229 {
3230         if (!watch_printsetup_print_grid_lines.handler)
3231                 watch_bool (&watch_printsetup_print_grid_lines);
3232         set_bool (&watch_printsetup_print_grid_lines, x);
3233 }
3234
3235 GOConfNode *
3236 gnm_conf_get_printsetup_print_grid_lines_node (void)
3237 {
3238         return get_watch_node (&watch_printsetup_print_grid_lines);
3239 }
3240
3241 static struct cb_watch_bool watch_printsetup_print_titles = {
3242         0, "printsetup/print-titles",
3243         "Default Title Printing",
3244         "This value determines the default setting in the Print Setup dialog whether to print row and column headers. Please use the Print Setup dialog to edit this value.",
3245         FALSE,
3246 };
3247
3248 gboolean
3249 gnm_conf_get_printsetup_print_titles (void)
3250 {
3251         if (!watch_printsetup_print_titles.handler)
3252                 watch_bool (&watch_printsetup_print_titles);
3253         return watch_printsetup_print_titles.var;
3254 }
3255
3256 void
3257 gnm_conf_set_printsetup_print_titles (gboolean x)
3258 {
3259         if (!watch_printsetup_print_titles.handler)
3260                 watch_bool (&watch_printsetup_print_titles);
3261         set_bool (&watch_printsetup_print_titles, x);
3262 }
3263
3264 GOConfNode *
3265 gnm_conf_get_printsetup_print_titles_node (void)
3266 {
3267         return get_watch_node (&watch_printsetup_print_titles);
3268 }
3269
3270 static struct cb_watch_string watch_printsetup_repeat_left = {
3271         0, "printsetup/repeat-left",
3272         "Default Repeated Left Region",
3273         "This string gives the default region to be repeated at the left of each printed sheet. Please use the Print Setup dialog to edit this value.",
3274         "",
3275 };
3276
3277 const char *
3278 gnm_conf_get_printsetup_repeat_left (void)
3279 {
3280         if (!watch_printsetup_repeat_left.handler)
3281                 watch_string (&watch_printsetup_repeat_left);
3282         return watch_printsetup_repeat_left.var;
3283 }
3284
3285 void
3286 gnm_conf_set_printsetup_repeat_left (const char *x)
3287 {
3288         g_return_if_fail (x != NULL);
3289         if (!watch_printsetup_repeat_left.handler)
3290                 watch_string (&watch_printsetup_repeat_left);
3291         set_string (&watch_printsetup_repeat_left, x);
3292 }
3293
3294 GOConfNode *
3295 gnm_conf_get_printsetup_repeat_left_node (void)
3296 {
3297         return get_watch_node (&watch_printsetup_repeat_left);
3298 }
3299
3300 static struct cb_watch_string watch_printsetup_repeat_top = {
3301         0, "printsetup/repeat-top",
3302         "Default Repeated Top Region",
3303         "This string gives the default region to be repeated at the top of each printed sheet. Please use the Print Setup dialog to edit this value.",
3304         "",
3305 };
3306
3307 const char *
3308 gnm_conf_get_printsetup_repeat_top (void)
3309 {
3310         if (!watch_printsetup_repeat_top.handler)
3311                 watch_string (&watch_printsetup_repeat_top);
3312         return watch_printsetup_repeat_top.var;
3313 }
3314
3315 void
3316 gnm_conf_set_printsetup_repeat_top (const char *x)
3317 {
3318         g_return_if_fail (x != NULL);
3319         if (!watch_printsetup_repeat_top.handler)
3320                 watch_string (&watch_printsetup_repeat_top);
3321         set_string (&watch_printsetup_repeat_top, x);
3322 }
3323
3324 GOConfNode *
3325 gnm_conf_get_printsetup_repeat_top_node (void)
3326 {
3327         return get_watch_node (&watch_printsetup_repeat_top);
3328 }
3329
3330 static struct cb_watch_int watch_printsetup_scale_height = {
3331         0, "printsetup/scale-height",
3332         "Default Scaling Height",
3333         "This value determines the maximum number of pages that make up the height of a printout of the current sheet. The sheet will be reduced to fit within this height. This value can be changed in the Page Setup dialog.",
3334         0, 100, 0,
3335 };
3336
3337 int
3338 gnm_conf_get_printsetup_scale_height (void)
3339 {
3340         if (!watch_printsetup_scale_height.handler)
3341                 watch_int (&watch_printsetup_scale_height);
3342         return watch_printsetup_scale_height.var;
3343 }
3344
3345 void
3346 gnm_conf_set_printsetup_scale_height (int x)
3347 {
3348         if (!watch_printsetup_scale_height.handler)
3349                 watch_int (&watch_printsetup_scale_height);
3350         set_int (&watch_printsetup_scale_height, x);
3351 }
3352
3353 GOConfNode *
3354 gnm_conf_get_printsetup_scale_height_node (void)
3355 {
3356         return get_watch_node (&watch_printsetup_scale_height);
3357 }
3358
3359 static struct cb_watch_bool watch_printsetup_scale_percentage = {
3360         0, "printsetup/scale-percentage",
3361         "Default Scale Type",
3362         "This value determines the default setting in the Print Setup dialog whether to scale pages by a given percentage. Please use the Print Setup dialog to edit this value.",
3363         TRUE,
3364 };
3365
3366 gboolean
3367 gnm_conf_get_printsetup_scale_percentage (void)
3368 {
3369         if (!watch_printsetup_scale_percentage.handler)
3370                 watch_bool (&watch_printsetup_scale_percentage);
3371         return watch_printsetup_scale_percentage.var;
3372 }
3373
3374 void
3375 gnm_conf_set_printsetup_scale_percentage (gboolean x)
3376 {
3377         if (!watch_printsetup_scale_percentage.handler)
3378                 watch_bool (&watch_printsetup_scale_percentage);
3379         set_bool (&watch_printsetup_scale_percentage, x);
3380 }
3381
3382 GOConfNode *
3383 gnm_conf_get_printsetup_scale_percentage_node (void)
3384 {
3385         return get_watch_node (&watch_printsetup_scale_percentage);
3386 }
3387
3388 static struct cb_watch_double watch_printsetup_scale_percentage_value = {
3389         0, "printsetup/scale-percentage-value",
3390         "Default Scale Percentage",
3391         "This value gives the percentage by which to scale each printed page. Please use the Print Setup dialog to edit this value.",
3392         1, 500, 100,
3393 };
3394
3395 double
3396 gnm_conf_get_printsetup_scale_percentage_value (void)
3397 {
3398         if (!watch_printsetup_scale_percentage_value.handler)
3399                 watch_double (&watch_printsetup_scale_percentage_value);
3400         return watch_printsetup_scale_percentage_value.var;
3401 }
3402
3403 void
3404 gnm_conf_set_printsetup_scale_percentage_value (double x)
3405 {
3406         if (!watch_printsetup_scale_percentage_value.handler)
3407                 watch_double (&watch_printsetup_scale_percentage_value);
3408         set_double (&watch_printsetup_scale_percentage_value, x);
3409 }
3410
3411 GOConfNode *
3412 gnm_conf_get_printsetup_scale_percentage_value_node (void)
3413 {
3414         return get_watch_node (&watch_printsetup_scale_percentage_value);
3415 }
3416
3417 static struct cb_watch_int watch_printsetup_scale_width = {
3418         0, "printsetup/scale-width",
3419         "Default Scaling Width",
3420         "This value determines the maximum number of pages that make up the width of a printout of the current sheet. The sheet will be reduced to fit within this width. This value can be changed in the Page Setup dialog.",
3421         0, 100, 0,
3422 };
3423
3424 int
3425 gnm_conf_get_printsetup_scale_width (void)
3426 {
3427         if (!watch_printsetup_scale_width.handler)
3428                 watch_int (&watch_printsetup_scale_width);
3429         return watch_printsetup_scale_width.var;
3430 }
3431
3432 void
3433 gnm_conf_set_printsetup_scale_width (int x)
3434 {
3435         if (!watch_printsetup_scale_width.handler)
3436                 watch_int (&watch_printsetup_scale_width);
3437         set_int (&watch_printsetup_scale_width, x);
3438 }
3439
3440 GOConfNode *
3441 gnm_conf_get_printsetup_scale_width_node (void)
3442 {
3443         return get_watch_node (&watch_printsetup_scale_width);
3444 }
3445
3446 static struct cb_watch_bool watch_searchreplace_change_cell_expressions = {
3447         0, "searchreplace/change-cell-expressions",
3448         "Search & Replace Changes Expressions",
3449         "Search & Replace changes cells containing expressions as default",
3450         TRUE,
3451 };
3452
3453 gboolean
3454 gnm_conf_get_searchreplace_change_cell_expressions (void)
3455 {
3456         if (!watch_searchreplace_change_cell_expressions.handler)
3457                 watch_bool (&watch_searchreplace_change_cell_expressions);
3458         return watch_searchreplace_change_cell_expressions.var;
3459 }
3460
3461 void
3462 gnm_conf_set_searchreplace_change_cell_expressions (gboolean x)
3463 {
3464         if (!watch_searchreplace_change_cell_expressions.handler)
3465                 watch_bool (&watch_searchreplace_change_cell_expressions);
3466         set_bool (&watch_searchreplace_change_cell_expressions, x);
3467 }
3468
3469 GOConfNode *
3470 gnm_conf_get_searchreplace_change_cell_expressions_node (void)
3471 {
3472         return get_watch_node (&watch_searchreplace_change_cell_expressions);
3473 }
3474
3475 static struct cb_watch_bool watch_searchreplace_change_cell_other = {
3476         0, "searchreplace/change-cell-other",
3477         "Search & Replace Changes Other Values",
3478         "Search & Replace changes cells containing other values as default",
3479         TRUE,
3480 };
3481
3482 gboolean
3483 gnm_conf_get_searchreplace_change_cell_other (void)
3484 {
3485         if (!watch_searchreplace_change_cell_other.handler)
3486                 watch_bool (&watch_searchreplace_change_cell_other);
3487         return watch_searchreplace_change_cell_other.var;
3488 }
3489
3490 void
3491 gnm_conf_set_searchreplace_change_cell_other (gboolean x)
3492 {
3493         if (!watch_searchreplace_change_cell_other.handler)
3494                 watch_bool (&watch_searchreplace_change_cell_other);
3495         set_bool (&watch_searchreplace_change_cell_other, x);
3496 }
3497
3498 GOConfNode *
3499 gnm_conf_get_searchreplace_change_cell_other_node (void)
3500 {
3501         return get_watch_node (&watch_searchreplace_change_cell_other);
3502 }
3503
3504 static struct cb_watch_bool watch_searchreplace_change_cell_strings = {
3505         0, "searchreplace/change-cell-strings",
3506         "Search & Replace Changes Strings",
3507         "Search & Replace changes cells containing strings as default",
3508         TRUE,
3509 };
3510
3511 gboolean
3512 gnm_conf_get_searchreplace_change_cell_strings (void)
3513 {
3514         if (!watch_searchreplace_change_cell_strings.handler)
3515                 watch_bool (&watch_searchreplace_change_cell_strings);
3516         return watch_searchreplace_change_cell_strings.var;
3517 }
3518
3519 void
3520 gnm_conf_set_searchreplace_change_cell_strings (gboolean x)
3521 {
3522         if (!watch_searchreplace_change_cell_strings.handler)
3523                 watch_bool (&watch_searchreplace_change_cell_strings);
3524         set_bool (&watch_searchreplace_change_cell_strings, x);
3525 }
3526
3527 GOConfNode *
3528 gnm_conf_get_searchreplace_change_cell_strings_node (void)
3529 {
3530         return get_watch_node (&watch_searchreplace_change_cell_strings);
3531 }
3532
3533 static struct cb_watch_bool watch_searchreplace_change_comments = {
3534         0, "searchreplace/change-comments",
3535         "Search & Replace Changes Comments",
3536         "Search & Replace changes comments as default",
3537         FALSE,
3538 };
3539
3540 gboolean
3541 gnm_conf_get_searchreplace_change_comments (void)
3542 {
3543         if (!watch_searchreplace_change_comments.handler)
3544                 watch_bool (&watch_searchreplace_change_comments);
3545         return watch_searchreplace_change_comments.var;
3546 }
3547
3548 void
3549 gnm_conf_set_searchreplace_change_comments (gboolean x)
3550 {
3551         if (!watch_searchreplace_change_comments.handler)
3552                 watch_bool (&watch_searchreplace_change_comments);
3553         set_bool (&watch_searchreplace_change_comments, x);
3554 }
3555
3556 GOConfNode *
3557 gnm_conf_get_searchreplace_change_comments_node (void)
3558 {
3559         return get_watch_node (&watch_searchreplace_change_comments);
3560 }
3561
3562 static struct cb_watch_bool watch_searchreplace_columnmajor = {
3563         0, "searchreplace/columnmajor",
3564         "Search & Replace Column Major",
3565         "Search & Replace proceeds in column major order as default",
3566         TRUE,
3567 };
3568
3569 gboolean
3570 gnm_conf_get_searchreplace_columnmajor (void)
3571 {
3572         if (!watch_searchreplace_columnmajor.handler)
3573                 watch_bool (&watch_searchreplace_columnmajor);
3574         return watch_searchreplace_columnmajor.var;
3575 }
3576
3577 void
3578 gnm_conf_set_searchreplace_columnmajor (gboolean x)
3579 {
3580         if (!watch_searchreplace_columnmajor.handler)
3581                 watch_bool (&watch_searchreplace_columnmajor);
3582         set_bool (&watch_searchreplace_columnmajor, x);
3583 }
3584
3585 GOConfNode *
3586 gnm_conf_get_searchreplace_columnmajor_node (void)
3587 {
3588         return get_watch_node (&watch_searchreplace_columnmajor);
3589 }
3590
3591 static struct cb_watch_int watch_searchreplace_error_behaviour = {
3592         0, "searchreplace/error-behaviour",
3593         "Search & Replace Error Behavior",
3594         "This is the default error behavior of Search & Replace indicated by an integer from 0 to 4.",
3595         0, 4, 0,
3596 };
3597
3598 int
3599 gnm_conf_get_searchreplace_error_behaviour (void)
3600 {
3601         if (!watch_searchreplace_error_behaviour.handler)
3602                 watch_int (&watch_searchreplace_error_behaviour);
3603         return watch_searchreplace_error_behaviour.var;
3604 }
3605
3606 void
3607 gnm_conf_set_searchreplace_error_behaviour (int x)
3608 {
3609         if (!watch_searchreplace_error_behaviour.handler)
3610                 watch_int (&watch_searchreplace_error_behaviour);
3611         set_int (&watch_searchreplace_error_behaviour, x);
3612 }
3613
3614 GOConfNode *
3615 gnm_conf_get_searchreplace_error_behaviour_node (void)
3616 {
3617         return get_watch_node (&watch_searchreplace_error_behaviour);
3618 }
3619
3620 static struct cb_watch_bool watch_searchreplace_ignore_case = {
3621         0, "searchreplace/ignore-case",
3622         "Search & Replace Ignores Case",
3623         "Search & Replace ignores case as default",
3624         TRUE,
3625 };
3626
3627 gboolean
3628 gnm_conf_get_searchreplace_ignore_case (void)
3629 {
3630         if (!watch_searchreplace_ignore_case.handler)
3631                 watch_bool (&watch_searchreplace_ignore_case);
3632         return watch_searchreplace_ignore_case.var;
3633 }
3634
3635 void
3636 gnm_conf_set_searchreplace_ignore_case (gboolean x)
3637 {
3638         if (!watch_searchreplace_ignore_case.handler)
3639                 watch_bool (&watch_searchreplace_ignore_case);
3640         set_bool (&watch_searchreplace_ignore_case, x);
3641 }
3642
3643 GOConfNode *
3644 gnm_conf_get_searchreplace_ignore_case_node (void)
3645 {
3646         return get_watch_node (&watch_searchreplace_ignore_case);
3647 }
3648
3649 static struct cb_watch_bool watch_searchreplace_keep_strings = {
3650         0, "searchreplace/keep-strings",
3651         "Search & Replace Keeps Strings as Strings",
3652         "Search & Replace keeps strings as strings even if they look like numbers as default",
3653         TRUE,
3654 };
3655
3656 gboolean
3657 gnm_conf_get_searchreplace_keep_strings (void)
3658 {
3659         if (!watch_searchreplace_keep_strings.handler)
3660                 watch_bool (&watch_searchreplace_keep_strings);
3661         return watch_searchreplace_keep_strings.var;
3662 }
3663
3664 void
3665 gnm_conf_set_searchreplace_keep_strings (gboolean x)
3666 {
3667         if (!watch_searchreplace_keep_strings.handler)
3668                 watch_bool (&watch_searchreplace_keep_strings);
3669         set_bool (&watch_searchreplace_keep_strings, x);
3670 }
3671
3672 GOConfNode *
3673 gnm_conf_get_searchreplace_keep_strings_node (void)
3674 {
3675         return get_watch_node (&watch_searchreplace_keep_strings);
3676 }
3677
3678 static struct cb_watch_bool watch_searchreplace_preserve_case = {
3679         0, "searchreplace/preserve-case",
3680         "Search & Replace Preserves Case",
3681         "Search & Replace preserves case as default",
3682         FALSE,
3683 };
3684
3685 gboolean
3686 gnm_conf_get_searchreplace_preserve_case (void)
3687 {
3688         if (!watch_searchreplace_preserve_case.handler)
3689                 watch_bool (&watch_searchreplace_preserve_case);
3690         return watch_searchreplace_preserve_case.var;
3691 }
3692
3693 void
3694 gnm_conf_set_searchreplace_preserve_case (gboolean x)
3695 {
3696         if (!watch_searchreplace_preserve_case.handler)
3697                 watch_bool (&watch_searchreplace_preserve_case);
3698         set_bool (&watch_searchreplace_preserve_case, x);
3699 }
3700
3701 GOConfNode *
3702 gnm_conf_get_searchreplace_preserve_case_node (void)
3703 {
3704         return get_watch_node (&watch_searchreplace_preserve_case);
3705 }
3706
3707 static struct cb_watch_bool watch_searchreplace_query = {
3708         0, "searchreplace/query",
3709         "Search & Replace Poses Query",
3710         "Search & Replace poses query before each change as default",
3711         FALSE,
3712 };
3713
3714 gboolean
3715 gnm_conf_get_searchreplace_query (void)
3716 {
3717         if (!watch_searchreplace_query.handler)
3718                 watch_bool (&watch_searchreplace_query);
3719         return watch_searchreplace_query.var;
3720 }
3721
3722 void
3723 gnm_conf_set_searchreplace_query (gboolean x)
3724 {
3725         if (!watch_searchreplace_query.handler)
3726                 watch_bool (&watch_searchreplace_query);
3727         set_bool (&watch_searchreplace_query, x);
3728 }
3729
3730 GOConfNode *
3731 gnm_conf_get_searchreplace_query_node (void)
3732 {
3733         return get_watch_node (&watch_searchreplace_query);
3734 }
3735
3736 static struct cb_watch_int watch_searchreplace_regex = {
3737         0, "searchreplace/regex",
3738         "Search & Replace Search Type",
3739         "This value determines the input type for Search & Replace. 0: text; 1: regular expression; 2: number",
3740         0, 2, 0,
3741 };
3742
3743 int
3744 gnm_conf_get_searchreplace_regex (void)
3745 {
3746         if (!watch_searchreplace_regex.handler)
3747                 watch_int (&watch_searchreplace_regex);
3748         return watch_searchreplace_regex.var;
3749 }
3750
3751 void
3752 gnm_conf_set_searchreplace_regex (int x)
3753 {
3754         if (!watch_searchreplace_regex.handler)
3755                 watch_int (&watch_searchreplace_regex);
3756         set_int (&watch_searchreplace_regex, x);
3757 }
3758
3759 GOConfNode *
3760 gnm_conf_get_searchreplace_regex_node (void)
3761 {
3762         return get_watch_node (&watch_searchreplace_regex);
3763 }
3764
3765 static struct cb_watch_int watch_searchreplace_scope = {
3766         0, "searchreplace/scope",
3767         "Search & Replace Scope",
3768         "This is the default scope of Search & Replace. 0: entire workbook; 1: current sheet; 2: range",
3769         0, 2, 0,
3770 };
3771
3772 int
3773 gnm_conf_get_searchreplace_scope (void)
3774 {
3775         if (!watch_searchreplace_scope.handler)
3776                 watch_int (&watch_searchreplace_scope);
3777         return watch_searchreplace_scope.var;
3778 }
3779
3780 void
3781 gnm_conf_set_searchreplace_scope (int x)
3782 {
3783         if (!watch_searchreplace_scope.handler)
3784                 watch_int (&watch_searchreplace_scope);
3785         set_int (&watch_searchreplace_scope, x);
3786 }
3787
3788 GOConfNode *
3789 gnm_conf_get_searchreplace_scope_node (void)
3790 {
3791         return get_watch_node (&watch_searchreplace_scope);
3792 }
3793
3794 static struct cb_watch_bool watch_searchreplace_search_results = {
3795         0, "searchreplace/search-results",
3796         "Search searches in results",
3797         "Search searches in results as default",
3798         TRUE,
3799 };
3800
3801 gboolean
3802 gnm_conf_get_searchreplace_search_results (void)
3803 {
3804         if (!watch_searchreplace_search_results.handler)
3805                 watch_bool (&watch_searchreplace_search_results);
3806         return watch_searchreplace_search_results.var;
3807 }
3808
3809 void
3810 gnm_conf_set_searchreplace_search_results (gboolean x)
3811 {
3812         if (!watch_searchreplace_search_results.handler)
3813                 watch_bool (&watch_searchreplace_search_results);
3814         set_bool (&watch_searchreplace_search_results, x);
3815 }
3816
3817 GOConfNode *
3818 gnm_conf_get_searchreplace_search_results_node (void)
3819 {
3820         return get_watch_node (&watch_searchreplace_search_results);
3821 }
3822
3823 static struct cb_watch_bool watch_searchreplace_whole_words_only = {
3824         0, "searchreplace/whole-words-only",
3825         "Search & Replace Whole Words Only",
3826         "Search & Replace replaces whole words only as default",
3827         FALSE,
3828 };
3829
3830 gboolean
3831 gnm_conf_get_searchreplace_whole_words_only (void)
3832 {
3833         if (!watch_searchreplace_whole_words_only.handler)
3834                 watch_bool (&watch_searchreplace_whole_words_only);
3835         return watch_searchreplace_whole_words_only.var;
3836 }
3837
3838 void
3839 gnm_conf_set_searchreplace_whole_words_only (gboolean x)
3840 {
3841         if (!watch_searchreplace_whole_words_only.handler)
3842                 watch_bool (&watch_searchreplace_whole_words_only);
3843         set_bool (&watch_searchreplace_whole_words_only, x);
3844 }
3845
3846 GOConfNode *
3847 gnm_conf_get_searchreplace_whole_words_only_node (void)
3848 {
3849         return get_watch_node (&watch_searchreplace_whole_words_only);
3850 }
3851
3852 static struct cb_watch_string watch_stf_export_encoding = {
3853         0, "stf/export/encoding",
3854         "Text Export Encoding",
3855         "Please use the Text Export dialog to edit this value.",
3856         "",
3857 };
3858
3859 const char *
3860 gnm_conf_get_stf_export_encoding (void)
3861 {
3862         if (!watch_stf_export_encoding.handler)
3863                 watch_string (&watch_stf_export_encoding);
3864         return watch_stf_export_encoding.var;
3865 }
3866
3867 void
3868 gnm_conf_set_stf_export_encoding (const char *x)
3869 {
3870         g_return_if_fail (x != NULL);
3871         if (!watch_stf_export_encoding.handler)
3872                 watch_string (&watch_stf_export_encoding);
3873         set_string (&watch_stf_export_encoding, x);
3874 }
3875
3876 GOConfNode *
3877 gnm_conf_get_stf_export_encoding_node (void)
3878 {
3879         return get_watch_node (&watch_stf_export_encoding);
3880 }
3881
3882 static struct cb_watch_enum watch_stf_export_format = {
3883         0, "stf/export/format",
3884         "Text Export Formatting Rule",
3885         "Please use the Text Export dialog to edit this value.",
3886         GNM_STF_FORMAT_AUTO,
3887 };
3888
3889 GnmStfFormatMode
3890 gnm_conf_get_stf_export_format (void)
3891 {
3892         if (!watch_stf_export_format.handler)
3893                 watch_enum (&watch_stf_export_format, GNM_STF_FORMAT_MODE_TYPE);
3894         return watch_stf_export_format.var;
3895 }
3896
3897 void
3898 gnm_conf_set_stf_export_format (GnmStfFormatMode x)
3899 {
3900         if (!watch_stf_export_format.handler)
3901                 watch_enum (&watch_stf_export_format, GNM_STF_FORMAT_MODE_TYPE);
3902         set_enum (&watch_stf_export_format, x);
3903 }
3904
3905 GOConfNode *
3906 gnm_conf_get_stf_export_format_node (void)
3907 {
3908         return get_watch_node (&watch_stf_export_format);
3909 }
3910
3911 static struct cb_watch_string watch_stf_export_locale = {
3912         0, "stf/export/locale",
3913         "Text Export Locale",
3914         "Please use the Text Export dialog to edit this value.",
3915         "",
3916 };
3917
3918 const char *
3919 gnm_conf_get_stf_export_locale (void)
3920 {
3921         if (!watch_stf_export_locale.handler)
3922                 watch_string (&watch_stf_export_locale);
3923         return watch_stf_export_locale.var;
3924 }
3925
3926 void
3927 gnm_conf_set_stf_export_locale (const char *x)
3928 {
3929         g_return_if_fail (x != NULL);
3930         if (!watch_stf_export_locale.handler)
3931                 watch_string (&watch_stf_export_locale);
3932         set_string (&watch_stf_export_locale, x);
3933 }
3934
3935 GOConfNode *
3936 gnm_conf_get_stf_export_locale_node (void)
3937 {
3938         return get_watch_node (&watch_stf_export_locale);
3939 }
3940
3941 static struct cb_watch_enum watch_stf_export_quoting = {
3942         0, "stf/export/quoting",
3943         "Text Export String Quoting Rule",
3944         "Please use the Text Export dialog to edit this value.",
3945         GSF_OUTPUT_CSV_QUOTING_MODE_AUTO,
3946 };
3947
3948 GsfOutputCsvQuotingMode
3949 gnm_conf_get_stf_export_quoting (void)
3950 {
3951         if (!watch_stf_export_quoting.handler)
3952                 watch_enum (&watch_stf_export_quoting, GSF_OUTPUT_CSV_QUOTING_MODE_TYPE);
3953         return watch_stf_export_quoting.var;
3954 }
3955
3956 void
3957 gnm_conf_set_stf_export_quoting (GsfOutputCsvQuotingMode x)
3958 {
3959         if (!watch_stf_export_quoting.handler)
3960                 watch_enum (&watch_stf_export_quoting, GSF_OUTPUT_CSV_QUOTING_MODE_TYPE);
3961         set_enum (&watch_stf_export_quoting, x);
3962 }
3963
3964 GOConfNode *
3965 gnm_conf_get_stf_export_quoting_node (void)
3966 {
3967         return get_watch_node (&watch_stf_export_quoting);
3968 }
3969
3970 static struct cb_watch_string watch_stf_export_separator = {
3971         0, "stf/export/separator",
3972         "Text Export Field Separator",
3973         "Please use the Text Export dialog to edit this value.",
3974         ",",
3975 };
3976
3977 const char *
3978 gnm_conf_get_stf_export_separator (void)
3979 {
3980         if (!watch_stf_export_separator.handler)
3981                 watch_string (&watch_stf_export_separator);
3982         return watch_stf_export_separator.var;
3983 }
3984
3985 void
3986 gnm_conf_set_stf_export_separator (const char *x)
3987 {
3988         g_return_if_fail (x != NULL);
3989         if (!watch_stf_export_separator.handler)
3990                 watch_string (&watch_stf_export_separator);
3991         set_string (&watch_stf_export_separator, x);
3992 }
3993
3994 GOConfNode *
3995 gnm_conf_get_stf_export_separator_node (void)
3996 {
3997         return get_watch_node (&watch_stf_export_separator);
3998 }
3999
4000 static struct cb_watch_string watch_stf_export_stringindicator = {
4001         0, "stf/export/stringindicator",
4002         "Text Export String Indicator",
4003         "Please use the Text Export dialog to edit this value.",
4004         "\"",
4005 };
4006
4007 const char *
4008 gnm_conf_get_stf_export_stringindicator (void)
4009 {
4010         if (!watch_stf_export_stringindicator.handler)
4011                 watch_string (&watch_stf_export_stringindicator);
4012         return watch_stf_export_stringindicator.var;
4013 }
4014
4015 void
4016 gnm_conf_set_stf_export_stringindicator (const char *x)
4017 {
4018         g_return_if_fail (x != NULL);
4019         if (!watch_stf_export_stringindicator.handler)
4020                 watch_string (&watch_stf_export_stringindicator);
4021         set_string (&watch_stf_export_stringindicator, x);
4022 }
4023
4024 GOConfNode *
4025 gnm_conf_get_stf_export_stringindicator_node (void)
4026 {
4027         return get_watch_node (&watch_stf_export_stringindicator);
4028 }
4029
4030 static struct cb_watch_string watch_stf_export_terminator = {
4031         0, "stf/export/terminator",
4032         "Text Export Record Terminator",
4033         "Please use the Text Export dialog to edit this value.",
4034         "\n",
4035 };
4036
4037 const char *
4038 gnm_conf_get_stf_export_terminator (void)
4039 {
4040         if (!watch_stf_export_terminator.handler)
4041                 watch_string (&watch_stf_export_terminator);
4042         return watch_stf_export_terminator.var;
4043 }
4044
4045 void
4046 gnm_conf_set_stf_export_terminator (const char *x)
4047 {
4048         g_return_if_fail (x != NULL);
4049         if (!watch_stf_export_terminator.handler)
4050                 watch_string (&watch_stf_export_terminator);
4051         set_string (&watch_stf_export_terminator, x);
4052 }
4053
4054 GOConfNode *
4055 gnm_conf_get_stf_export_terminator_node (void)
4056 {
4057         return get_watch_node (&watch_stf_export_terminator);
4058 }
4059
4060 static struct cb_watch_bool watch_stf_export_transliteration = {
4061         0, "stf/export/transliteration",
4062         "Text Export Unknown Character Transliteration",
4063         "Please use the Text Export dialog to edit this value.",
4064         TRUE,
4065 };
4066
4067 gboolean
4068 gnm_conf_get_stf_export_transliteration (void)
4069 {
4070         if (!watch_stf_export_transliteration.handler)
4071                 watch_bool (&watch_stf_export_transliteration);
4072         return watch_stf_export_transliteration.var;
4073 }
4074
4075 void
4076 gnm_conf_set_stf_export_transliteration (gboolean x)
4077 {
4078         if (!watch_stf_export_transliteration.handler)
4079                 watch_bool (&watch_stf_export_transliteration);
4080         set_bool (&watch_stf_export_transliteration, x);
4081 }
4082
4083 GOConfNode *
4084 gnm_conf_get_stf_export_transliteration_node (void)
4085 {
4086         return get_watch_node (&watch_stf_export_transliteration);
4087 }
4088
4089 static struct cb_watch_enum watch_toolbar_style = {
4090         0, "toolbar-style",
4091         "Toolbar Style",
4092         "Toolbar Style. Valid values are both, both_horiz, icon, and text.",
4093         GTK_TOOLBAR_ICONS,
4094 };
4095
4096 GtkToolbarStyle
4097 gnm_conf_get_toolbar_style (void)
4098 {
4099         if (!watch_toolbar_style.handler)
4100                 watch_enum (&watch_toolbar_style, GTK_TYPE_TOOLBAR_STYLE);
4101         return watch_toolbar_style.var;
4102 }
4103
4104 void
4105 gnm_conf_set_toolbar_style (GtkToolbarStyle x)
4106 {
4107         if (!watch_toolbar_style.handler)
4108                 watch_enum (&watch_toolbar_style, GTK_TYPE_TOOLBAR_STYLE);
4109         set_enum (&watch_toolbar_style, x);
4110 }
4111
4112 static struct cb_watch_int watch_undo_max_descriptor_width = {
4113         0, "undo/max-descriptor-width",
4114         "Length of the Undo Descriptors",
4115         "This value is indicative of the maximum length of the command descriptors in the undo and redo chains.",
4116         5, 256, 40,
4117 };
4118
4119 int
4120 gnm_conf_get_undo_max_descriptor_width (void)
4121 {
4122         if (!watch_undo_max_descriptor_width.handler)
4123                 watch_int (&watch_undo_max_descriptor_width);
4124         return watch_undo_max_descriptor_width.var;
4125 }
4126
4127 void
4128 gnm_conf_set_undo_max_descriptor_width (int x)
4129 {
4130         if (!watch_undo_max_descriptor_width.handler)
4131                 watch_int (&watch_undo_max_descriptor_width);
4132         set_int (&watch_undo_max_descriptor_width, x);
4133 }
4134
4135 GOConfNode *
4136 gnm_conf_get_undo_max_descriptor_width_node (void)
4137 {
4138         return get_watch_node (&watch_undo_max_descriptor_width);
4139 }
4140
4141 static struct cb_watch_int watch_undo_maxnum = {
4142         0, "undo/maxnum",
4143         "Number of Undo Items",
4144         "This value determines the maximum number of items in the undo/redo list.",
4145         0, 10000, 20,
4146 };
4147
4148 int
4149 gnm_conf_get_undo_maxnum (void)
4150 {
4151         if (!watch_undo_maxnum.handler)
4152                 watch_int (&watch_undo_maxnum);
4153         return watch_undo_maxnum.var;
4154 }
4155
4156 void
4157 gnm_conf_set_undo_maxnum (int x)
4158 {
4159         if (!watch_undo_maxnum.handler)
4160                 watch_int (&watch_undo_maxnum);
4161         set_int (&watch_undo_maxnum, x);
4162 }
4163
4164 GOConfNode *
4165 gnm_conf_get_undo_maxnum_node (void)
4166 {
4167         return get_watch_node (&watch_undo_maxnum);
4168 }
4169
4170 static struct cb_watch_bool watch_undo_show_sheet_name = {
4171         0, "undo/show-sheet-name",
4172         "Show Sheet Name in Undo List",
4173         "This value determines whether to show the sheet names in the undo and redo lists.",
4174         FALSE,
4175 };
4176
4177 gboolean
4178 gnm_conf_get_undo_show_sheet_name (void)
4179 {
4180         if (!watch_undo_show_sheet_name.handler)
4181                 watch_bool (&watch_undo_show_sheet_name);
4182         return watch_undo_show_sheet_name.var;
4183 }
4184
4185 void
4186 gnm_conf_set_undo_show_sheet_name (gboolean x)
4187 {
4188         if (!watch_undo_show_sheet_name.handler)
4189                 watch_bool (&watch_undo_show_sheet_name);
4190         set_bool (&watch_undo_show_sheet_name, x);
4191 }
4192
4193 GOConfNode *
4194 gnm_conf_get_undo_show_sheet_name_node (void)
4195 {
4196         return get_watch_node (&watch_undo_show_sheet_name);
4197 }
4198
4199 static struct cb_watch_int watch_undo_size = {
4200         0, "undo/size",
4201         "Maximal Undo Size",
4202         "This value determines the length of the undo chain. Each editing action has a size associate with it, to compare it with the memory requirements of a simple one-cell edit (size of 1). The undo list will be truncated when its total size exceeds this configurable value.",
4203         1, 1000000, 100,
4204 };
4205
4206 int
4207 gnm_conf_get_undo_size (void)
4208 {
4209         if (!watch_undo_size.handler)
4210                 watch_int (&watch_undo_size);
4211         return watch_undo_size.var;
4212 }
4213
4214 void
4215 gnm_conf_set_undo_size (int x)
4216 {
4217         if (!watch_undo_size.handler)
4218                 watch_int (&watch_undo_size);
4219         set_int (&watch_undo_size, x);
4220 }
4221
4222 GOConfNode *
4223 gnm_conf_get_undo_size_node (void)
4224 {
4225         return get_watch_node (&watch_undo_size);
4226 }
4227
4228 GOConfNode *
4229 gnm_conf_get_autocorrect_dir_node (void)
4230 {
4231         return get_node ("autocorrect", NULL);
4232 }
4233
4234 GOConfNode *
4235 gnm_conf_get_autoformat_dir_node (void)
4236 {
4237         return get_node ("autoformat", NULL);
4238 }
4239
4240 GOConfNode *
4241 gnm_conf_get_core_defaultfont_dir_node (void)
4242 {
4243         return get_node ("core/defaultfont", NULL);
4244 }
4245
4246 GOConfNode *
4247 gnm_conf_get_core_file_save_dir_node (void)
4248 {
4249         return get_node ("core/file/save", NULL);
4250 }
4251
4252 GOConfNode *
4253 gnm_conf_get_core_gui_cells_dir_node (void)
4254 {
4255         return get_node ("core/gui/cells", NULL);
4256 }
4257
4258 GOConfNode *
4259 gnm_conf_get_core_gui_editing_dir_node (void)
4260 {
4261         return get_node ("core/gui/editing", NULL);
4262 }
4263
4264 GOConfNode *
4265 gnm_conf_get_core_gui_screen_dir_node (void)
4266 {
4267         return get_node ("core/gui/screen", NULL);
4268 }
4269
4270 GOConfNode *
4271 gnm_conf_get_core_gui_toolbars_dir_node (void)
4272 {
4273         return get_node ("core/gui/toolbars", NULL);
4274 }
4275
4276 GOConfNode *
4277 gnm_conf_get_core_gui_window_dir_node (void)
4278 {
4279         return get_node ("core/gui/window", NULL);
4280 }
4281
4282 GOConfNode *
4283 gnm_conf_get_core_sort_default_dir_node (void)
4284 {
4285         return get_node ("core/sort/default", NULL);
4286 }
4287
4288 GOConfNode *
4289 gnm_conf_get_core_sort_dialog_dir_node (void)
4290 {
4291         return get_node ("core/sort/dialog", NULL);
4292 }
4293
4294 GOConfNode *
4295 gnm_conf_get_core_workbook_dir_node (void)
4296 {
4297         return get_node ("core/workbook", NULL);
4298 }
4299
4300 GOConfNode *
4301 gnm_conf_get_core_xml_dir_node (void)
4302 {
4303         return get_node ("core/xml", NULL);
4304 }
4305
4306 GOConfNode *
4307 gnm_conf_get_cut_and_paste_dir_node (void)
4308 {
4309         return get_node ("cut-and-paste", NULL);
4310 }
4311
4312 GOConfNode *
4313 gnm_conf_get_dialogs_rs_dir_node (void)
4314 {
4315         return get_node ("dialogs/rs", NULL);
4316 }
4317
4318 GOConfNode *
4319 gnm_conf_get_functionselector_dir_node (void)
4320 {
4321         return get_node ("functionselector", NULL);
4322 }
4323
4324 GOConfNode *
4325 gnm_conf_get_plugin_glpk_dir_node (void)
4326 {
4327         return get_node ("plugin/glpk", NULL);
4328 }
4329
4330 GOConfNode *
4331 gnm_conf_get_plugin_latex_dir_node (void)
4332 {
4333         return get_node ("plugin/latex", NULL);
4334 }
4335
4336 GOConfNode *
4337 gnm_conf_get_plugin_lpsolve_dir_node (void)
4338 {
4339         return get_node ("plugin/lpsolve", NULL);
4340 }
4341
4342 GOConfNode *
4343 gnm_conf_get_plugins_dir_node (void)
4344 {
4345         return get_node ("plugins", NULL);
4346 }
4347
4348 GOConfNode *
4349 gnm_conf_get_printsetup_dir_node (void)
4350 {
4351         return get_node ("printsetup", NULL);
4352 }
4353
4354 GOConfNode *
4355 gnm_conf_get_searchreplace_dir_node (void)
4356 {
4357         return get_node ("searchreplace", NULL);
4358 }
4359
4360 GOConfNode *
4361 gnm_conf_get_stf_export_dir_node (void)
4362 {
4363         return get_node ("stf/export", NULL);
4364 }
4365
4366 GOConfNode *
4367 gnm_conf_get_toolbar_style_dir_node (void)
4368 {
4369         return get_node ("toolbar-style", NULL);
4370 }
4371
4372 GOConfNode *
4373 gnm_conf_get_undo_dir_node (void)
4374 {
4375         return get_node ("undo", NULL);
4376 }