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