src/LyXRC.cpp

   1 /**
   2  * \file LyXRC.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  * \author Angus Leeming
   9  * \author John Levon
  10  * \author André Pönitz
  11  * \author Allan Rae
  12  * \author Dekel Tsur
  13  *
  14  * Full author contact details are available in file CREDITS.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "LyXRC.h"
  20
  21 #include "ColorSet.h"
  22 #include "Converter.h"
  23 #include "FontEnums.h"
  24 #include "Format.h"
  25 #include "Lexer.h"
  26 #include "Mover.h"
  27 #include "Session.h"
  28 #include "version.h"
  29
  30 #include "graphics/GraphicsTypes.h"
  31
  32 #include "support/convert.h"
  33 #include "support/debug.h"
  34 #include "support/environment.h"
  35 #include "support/filetools.h"
  36 #include "support/gettext.h"
  37 #include "support/lstrings.h"
  38 #include "support/os.h"
  39 #include "support/userinfo.h"
  40
  41 #include <fstream>
  42 #include <iostream>
  43
  44 using namespace std;
  45 using namespace lyx::support;
  46
  47 namespace lyx {
  48
  49 namespace os = support::os;
  50
  51 namespace {
  52
  53 // when adding something to this array keep it sorted!
  54 LexerKeyword lyxrcTags[] = {
  55         { "\\accept_compound", LyXRC::RC_ACCEPT_COMPOUND },
  56         { "\\allow_geometry_session", LyXRC::RC_GEOMETRY_SESSION },
  57         { "\\alternate_language", LyXRC::RC_ALT_LANG },
  58         { "\\auto_number", LyXRC::RC_AUTO_NUMBER },
  59         { "\\auto_region_delete", LyXRC::RC_AUTOREGIONDELETE },
  60         { "\\auto_reset_options", LyXRC::RC_AUTORESET_OPTIONS },
  61         { "\\autocorrection_math", LyXRC::RC_AUTOCORRECTION_MATH },
  62         { "\\autosave", LyXRC::RC_AUTOSAVE },
  63         { "\\backupdir_path", LyXRC::RC_BACKUPDIR_PATH },
  64         { "\\bibtex_alternatives", LyXRC::RC_BIBTEX_ALTERNATIVES },
  65         { "\\bibtex_command", LyXRC::RC_BIBTEX_COMMAND },
  66         { "\\bind_file", LyXRC::RC_BINDFILE },
  67         { "\\check_lastfiles", LyXRC::RC_CHECKLASTFILES },
  68         { "\\chktex_command", LyXRC::RC_CHKTEX_COMMAND },
  69         { "\\completion_cursor_text", LyXRC::RC_COMPLETION_CURSOR_TEXT },
  70         { "\\completion_inline_delay", LyXRC::RC_COMPLETION_INLINE_DELAY },
  71         { "\\completion_inline_dots", LyXRC::RC_COMPLETION_INLINE_DOTS },
  72         { "\\completion_inline_math", LyXRC::RC_COMPLETION_INLINE_MATH },
  73         { "\\completion_inline_text", LyXRC::RC_COMPLETION_INLINE_TEXT },
  74         { "\\completion_popup_after_complete", LyXRC::RC_COMPLETION_POPUP_AFTER_COMPLETE },
  75         { "\\completion_popup_delay", LyXRC::RC_COMPLETION_POPUP_DELAY },
  76         { "\\completion_popup_math", LyXRC::RC_COMPLETION_POPUP_MATH },
  77         { "\\completion_popup_text", LyXRC::RC_COMPLETION_POPUP_TEXT },
  78         { "\\converter", LyXRC::RC_CONVERTER },
  79         { "\\converter_cache_maxage", LyXRC::RC_CONVERTER_CACHE_MAXAGE },
  80         { "\\copier", LyXRC::RC_COPIER },
  81         { "\\cursor_follows_scrollbar", LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR },
  82         { "\\date_insert_format", LyXRC::RC_DATE_INSERT_FORMAT },
  83         { "\\def_file", LyXRC::RC_DEFFILE },
  84         { "\\default_language", LyXRC::RC_DEFAULT_LANGUAGE },
  85         { "\\default_papersize", LyXRC::RC_DEFAULT_PAPERSIZE },
  86         { "\\default_view_format", LyXRC::RC_DEFAULT_VIEW_FORMAT },
  87         { "\\dialogs_iconify_with_main", LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN },
  88         { "\\display_graphics", LyXRC::RC_DISPLAY_GRAPHICS },
  89         { "\\document_path", LyXRC::RC_DOCUMENTPATH },
  90         { "\\escape_chars", LyXRC::RC_ESC_CHARS },
  91         { "\\example_path", LyXRC::RC_EXAMPLEPATH },
  92         { "\\font_encoding", LyXRC::RC_FONT_ENCODING },
  93         { "\\format", LyXRC::RC_FORMAT },
  94         { "\\fullscreen_limit", LyXRC::RC_FULL_SCREEN_LIMIT },
  95         { "\\fullscreen_menubar", LyXRC::RC_FULL_SCREEN_MENUBAR },
  96         { "\\fullscreen_scrollbar", LyXRC::RC_FULL_SCREEN_SCROLLBAR },
  97         { "\\fullscreen_tabbar", LyXRC::RC_FULL_SCREEN_TABBAR },
  98         { "\\fullscreen_toolbars", LyXRC::RC_FULL_SCREEN_TOOLBARS },
  99         { "\\fullscreen_width", LyXRC::RC_FULL_SCREEN_WIDTH },
 100         { "\\group_layouts", LyXRC::RC_GROUP_LAYOUTS },
 101         { "\\gui_language", LyXRC::RC_GUI_LANGUAGE },
 102         { "\\index_alternatives", LyXRC::RC_INDEX_ALTERNATIVES },
 103         { "\\index_command", LyXRC::RC_INDEX_COMMAND },
 104         { "\\input", LyXRC::RC_INPUT },
 105         { "\\jbibtex_command", LyXRC::RC_JBIBTEX_COMMAND },
 106         { "\\jindex_command", LyXRC::RC_JINDEX_COMMAND },
 107         { "\\kbmap", LyXRC::RC_KBMAP },
 108         { "\\kbmap_primary", LyXRC::RC_KBMAP_PRIMARY },
 109         { "\\kbmap_secondary", LyXRC::RC_KBMAP_SECONDARY },
 110         { "\\label_init_length", LyXRC::RC_LABEL_INIT_LENGTH },
 111         { "\\language_auto_begin", LyXRC::RC_LANGUAGE_AUTO_BEGIN },
 112         { "\\language_auto_end", LyXRC::RC_LANGUAGE_AUTO_END },
 113         { "\\language_command_begin", LyXRC::RC_LANGUAGE_COMMAND_BEGIN },
 114         { "\\language_command_end", LyXRC::RC_LANGUAGE_COMMAND_END },
 115         { "\\language_command_local", LyXRC::RC_LANGUAGE_COMMAND_LOCAL },
 116         { "\\language_global_options", LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS },
 117         { "\\language_package", LyXRC::RC_LANGUAGE_PACKAGE },
 118         { "\\language_use_babel", LyXRC::RC_LANGUAGE_USE_BABEL },
 119         { "\\load_session", LyXRC::RC_LOADSESSION },
 120         { "\\mac_like_word_movement", LyXRC::RC_MAC_LIKE_WORD_MOVEMENT },
 121         { "\\macro_edit_style", LyXRC::RC_MACRO_EDIT_STYLE },
 122         { "\\make_backup", LyXRC::RC_MAKE_BACKUP },
 123         { "\\mark_foreign_language", LyXRC::RC_MARK_FOREIGN_LANGUAGE },
 124         { "\\mouse_wheel_speed", LyXRC::RC_MOUSE_WHEEL_SPEED },
 125         { "\\nomencl_command", LyXRC::RC_NOMENCL_COMMAND },
 126         { "\\num_lastfiles", LyXRC::RC_NUMLASTFILES },
 127         { "\\open_buffers_in_tabs", LyXRC::RC_OPEN_BUFFERS_IN_TABS },
 128         { "\\path_prefix", LyXRC::RC_PATH_PREFIX },
 129         { "\\personal_dictionary", LyXRC::RC_PERS_DICT },
 130         { "\\plaintext_linelen", LyXRC::RC_PLAINTEXT_LINELEN },
 131         { "\\plaintext_roff_command", LyXRC::RC_PLAINTEXT_ROFF_COMMAND },
 132         { "\\preview", LyXRC::RC_PREVIEW },
 133         { "\\preview_hashed_labels", LyXRC::RC_PREVIEW_HASHED_LABELS },
 134         { "\\preview_scale_factor", LyXRC::RC_PREVIEW_SCALE_FACTOR },
 135         { "\\print_adapt_output", LyXRC::RC_PRINT_ADAPTOUTPUT },
 136         { "\\print_collcopies_flag", LyXRC::RC_PRINTCOLLCOPIESFLAG },
 137         { "\\print_command", LyXRC::RC_PRINT_COMMAND },
 138         { "\\print_copies_flag", LyXRC::RC_PRINTCOPIESFLAG },
 139         { "\\print_evenpage_flag", LyXRC::RC_PRINTEVENPAGEFLAG },
 140         { "\\print_extra_options", LyXRC::RC_PRINTEXSTRAOPTIONS },
 141         { "\\print_file_extension", LyXRC::RC_PRINTFILEEXTENSION },
 142         { "\\print_landscape_flag", LyXRC::RC_PRINTLANDSCAPEFLAG },
 143         { "\\print_oddpage_flag", LyXRC::RC_PRINTODDPAGEFLAG },
 144         { "\\print_pagerange_flag", LyXRC::RC_PRINTPAGERANGEFLAG },
 145         { "\\print_paper_dimension_flag", LyXRC::RC_PRINTPAPERDIMENSIONFLAG },
 146         { "\\print_paper_flag", LyXRC::RC_PRINTPAPERFLAG },
 147         { "\\print_reverse_flag", LyXRC::RC_PRINTREVERSEFLAG },
 148         { "\\print_spool_command", LyXRC::RC_PRINTSPOOL_COMMAND },
 149         { "\\print_spool_printerprefix", LyXRC::RC_PRINTSPOOL_PRINTERPREFIX },
 150         { "\\print_to_file", LyXRC::RC_PRINTTOFILE },
 151         { "\\print_to_printer", LyXRC::RC_PRINTTOPRINTER },
 152         { "\\printer", LyXRC::RC_PRINTER },
 153         { "\\rtl", LyXRC::RC_RTL_SUPPORT },
 154         { "\\screen_dpi", LyXRC::RC_SCREEN_DPI },
 155         { "\\screen_font_roman", LyXRC::RC_SCREEN_FONT_ROMAN },
 156         { "\\screen_font_roman_foundry", LyXRC::RC_SCREEN_FONT_ROMAN_FOUNDRY },
 157         { "\\screen_font_sans", LyXRC::RC_SCREEN_FONT_SANS },
 158         { "\\screen_font_sans_foundry", LyXRC::RC_SCREEN_FONT_SANS_FOUNDRY },
 159         { "\\screen_font_scalable", LyXRC::RC_SCREEN_FONT_SCALABLE },
 160         { "\\screen_font_sizes", LyXRC::RC_SCREEN_FONT_SIZES },
 161         { "\\screen_font_typewriter", LyXRC::RC_SCREEN_FONT_TYPEWRITER },
 162         { "\\screen_font_typewriter_foundry", LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY },
 163         { "\\screen_zoom", LyXRC::RC_SCREEN_ZOOM },
 164         { "\\scroll_below_document", LyXRC::RC_SCROLL_BELOW_DOCUMENT },
 165         { "\\serverpipe", LyXRC::RC_SERVERPIPE },
 166         { "\\set_color", LyXRC::RC_SET_COLOR },
 167         { "\\show_banner", LyXRC::RC_SHOW_BANNER },
 168         { "\\sort_layouts", LyXRC::RC_SORT_LAYOUTS },
 169         { "\\spell_command", LyXRC::RC_SPELL_COMMAND },
 170         { "\\spellcheck_continuously", LyXRC::RC_SPELLCHECK_CONTINUOUSLY },
 171         { "\\splitindex_command", LyXRC::RC_SPLITINDEX_COMMAND },
 172         { "\\tempdir_path", LyXRC::RC_TEMPDIRPATH },
 173         { "\\template_path", LyXRC::RC_TEMPLATEPATH },
 174         { "\\tex_allows_spaces", LyXRC::RC_TEX_ALLOWS_SPACES },
 175         { "\\tex_expects_windows_paths", LyXRC::RC_TEX_EXPECTS_WINDOWS_PATHS },
 176         { "\\thesaurusdir_path", LyXRC::RC_THESAURUSDIRPATH },
 177         { "\\ui_file", LyXRC::RC_UIFILE },
 178         { "\\use_alt_language", LyXRC::RC_USE_ALT_LANG },
 179         { "\\use_converter_cache", LyXRC::RC_USE_CONVERTER_CACHE },
 180         { "\\use_escape_chars", LyXRC::RC_USE_ESC_CHARS },
 181         { "\\use_input_encoding", LyXRC::RC_USE_INP_ENC },
 182         { "\\use_lastfilepos", LyXRC::RC_USELASTFILEPOS },
 183         { "\\use_personal_dictionary", LyXRC::RC_USE_PERS_DICT },
 184         { "\\use_pixmap_cache", LyXRC::RC_USE_PIXMAP_CACHE },
 185         // compatibility with versions older than 1.4.0 only
 186         { "\\use_pspell", LyXRC::RC_USE_SPELL_LIB },
 187         // compatibility with versions older than 1.4.0 only
 188         { "\\use_tempdir", LyXRC::RC_USETEMPDIR },
 189         { "\\use_tooltip", LyXRC::RC_USE_TOOLTIP },
 190         { "\\user_email", LyXRC::RC_USER_EMAIL },
 191         { "\\user_name", LyXRC::RC_USER_NAME },
 192         { "\\view_dvi_paper_option", LyXRC::RC_VIEWDVI_PAPEROPTION },
 193         // compatibility with versions older than 1.4.0 only
 194         { "\\viewer", LyXRC::RC_VIEWER},
 195         { "\\visual_cursor" ,LyXRC::RC_VISUAL_CURSOR}
 196 };
 197
 198 const int lyxrcCount = sizeof(lyxrcTags) / sizeof(lyxrcTags[0]);
 199
 200 } // namespace anon
 201
 202
 203 LyXRC::LyXRC()
 204 {
 205         setDefaults();
 206 }
 207
 208
 209 void LyXRC::setDefaults()
 210 {
 211         bind_file = "cua";
 212         def_file = "default";
 213         ui_file = "default";
 214         // Get printer from the environment. If fail, use default "",
 215         // assuming that everything is set up correctly.
 216         printer = getEnv("PRINTER");
 217         print_adapt_output = false;
 218         print_command = "dvips";
 219         print_evenpage_flag = "-B";
 220         print_oddpage_flag = "-A";
 221         print_pagerange_flag = "-pp";
 222         print_copies_flag = "-c";
 223         print_collcopies_flag = "-C";
 224         print_reverse_flag = "-r";
 225         print_landscape_flag = "-t landscape";
 226         print_to_printer = "-P";
 227         print_to_file = "-o ";
 228         print_file_extension = ".ps";
 229         print_paper_flag = "-t";
 230         print_paper_dimension_flag = "-T";
 231         document_path.erase();
 232         view_dvi_paper_option.erase();
 233         default_papersize = PAPER_DEFAULT;
 234         default_view_format = "pdf2";
 235         chktex_command = "chktex -n1 -n3 -n6 -n9 -n22 -n25 -n30 -n38";
 236         bibtex_command = "bibtex";
 237         fontenc = "default";
 238         index_command = "makeindex -c -q";
 239         nomencl_command = "makeindex -s nomencl.ist";
 240         dpi = 75;
 241         // Because a screen typically is wider than a piece of paper:
 242         zoom = 150;
 243         allow_geometry_session = true;
 244         // Default LaTeX font size:
 245         font_sizes[FONT_SIZE_TINY] = "5.0";
 246         font_sizes[FONT_SIZE_SCRIPT] = "7.0";
 247         font_sizes[FONT_SIZE_FOOTNOTE] = "8.0";
 248         font_sizes[FONT_SIZE_SMALL] = "9.0";
 249         font_sizes[FONT_SIZE_NORMAL] = "10.0";
 250         font_sizes[FONT_SIZE_LARGE] = "12.0";
 251         font_sizes[FONT_SIZE_LARGER] = "14.4";
 252         font_sizes[FONT_SIZE_LARGEST] = "17.26";
 253         font_sizes[FONT_SIZE_HUGE] = "20.74";
 254         font_sizes[FONT_SIZE_HUGER] = "24.88";
 255         use_scalable_fonts = true;
 256         roman_font_name = "";
 257         sans_font_name = "";
 258         typewriter_font_name = "";
 259         autosave = 300;
 260         auto_region_delete = true;
 261         auto_reset_options = false;
 262         plaintext_linelen = 65;
 263         mouse_wheel_speed = 1.0;
 264         num_lastfiles = maxlastfiles;
 265         check_lastfiles = true;
 266         use_lastfilepos = true;
 267         load_session = false;
 268         make_backup = true;
 269         backupdir_path.erase();
 270         display_graphics = true;
 271         // Spellchecker settings:
 272         spellchecker_accept_compound = false;
 273         spellchecker_use_input_encoding = false;
 274         spellchecker_use_alt_lang = false;
 275         spellchecker_use_pers_dict = false;
 276         spellchecker_use_esc_chars = false;
 277         spellcheck_continuously = false;
 278         use_kbmap = false;
 279         rtl_support = true;
 280         visual_cursor = false;
 281         auto_number = true;
 282         mark_foreign_language = true;
 283         language_auto_begin = true;
 284         language_auto_end = true;
 285         language_global_options = true;
 286         language_use_babel = true;
 287         language_package = "\\usepackage{babel}";
 288         language_command_begin = "\\selectlanguage{$$lang}";
 289         language_command_local = "\\foreignlanguage{$$lang}{";
 290         sort_layouts = false;
 291         group_layouts = true;
 292         default_language = "english";
 293         gui_language = "auto";
 294         show_banner = true;
 295         windows_style_tex_paths = false;
 296         tex_allows_spaces = false;
 297         date_insert_format = "%x";
 298         cursor_follows_scrollbar = false;
 299         scroll_below_document = false;
 300         mac_like_word_movement = false;
 301         macro_edit_style = MACRO_EDIT_INLINE_BOX;
 302         dialogs_iconify_with_main = false;
 303         label_init_length = 3;
 304         preview = PREVIEW_OFF;
 305         preview_hashed_labels  = false;
 306         preview_scale_factor = "0.9";
 307         use_converter_cache = true;
 308         use_tooltip = true;
 309         use_pixmap_cache = false;
 310         converter_cache_maxage = 6 * 30 * 24 * 3600; // 6 months
 311         user_name = to_utf8(support::user_name());
 312         user_email = to_utf8(support::user_email());
 313         open_buffers_in_tabs = true;
 314
 315         // Fullscreen settings
 316         full_screen_limit = false;
 317         full_screen_toolbars = true;
 318         full_screen_tabbar = true;
 319         full_screen_menubar = true;
 320         full_screen_scrollbar = true;
 321         full_screen_width = 700;
 322
 323         completion_cursor_text = true;
 324         completion_popup_math = true;
 325         completion_popup_text = false;
 326         completion_popup_delay = 2.0;
 327         completion_popup_after_complete = true;
 328         autocorrection_math = false;
 329         completion_inline_math = true;
 330         completion_inline_text = false;
 331         completion_inline_dots = -1;
 332         completion_inline_delay = 0.2;
 333 }
 334
 335
 336 namespace {
 337
 338 void oldFontFormat(string & family, string & foundry)
 339 {
 340         if (family.empty() || family[0] != '-')
 341                 return;
 342         foundry = token(family, '-', 1);
 343         family = token(family, '-', 2);
 344         if (foundry == "*")
 345                 foundry.erase();
 346 }
 347
 348 } // namespace anon
 349
 350
 351 int LyXRC::read(FileName const & filename)
 352 {
 353         Lexer lexrc(lyxrcTags);
 354         if (lyxerr.debugging(Debug::PARSER))
 355                 lexrc.printTable(lyxerr);
 356
 357         lexrc.setFile(filename);
 358         if (!lexrc.isOK())
 359                 return -2;
 360
 361         LYXERR(Debug::LYXRC, "Reading '" << filename << "'...");
 362
 363         return read(lexrc);
 364 }
 365
 366
 367 int LyXRC::read(istream & is)
 368 {
 369         Lexer lexrc(lyxrcTags);
 370         if (lyxerr.debugging(Debug::PARSER))
 371                 lexrc.printTable(lyxerr);
 372
 373         lexrc.setStream(is);
 374         if (!lexrc.isOK())
 375                 return -2;
 376
 377         LYXERR(Debug::LYXRC, "Reading istream...");
 378
 379         return read(lexrc);
 380 }
 381
 382
 383 int LyXRC::read(Lexer & lexrc)
 384 {
 385         if (!lexrc.isOK())
 386                 return -2;
 387
 388         while (lexrc.isOK()) {
 389                 // By using two switches we take advantage of the compiler
 390                 // telling us if we have missed a LyXRCTags element in
 391                 // the second switch.
 392                 // Note that this also shows a problem with Lexer since it
 393                 // helps us avoid taking advantage of the strictness of the
 394                 // compiler.
 395
 396                 int le = lexrc.lex();
 397                 switch (le) {
 398                 case Lexer::LEX_UNDEF:
 399                         lexrc.printError("Unknown tag `$$Token'");
 400                         continue;
 401                 case Lexer::LEX_FEOF:
 402                         continue;
 403                 default:
 404                         break;
 405                 }
 406                 switch (static_cast<LyXRCTags>(le)) {
 407                 case RC_INPUT: // Include file
 408                         if (lexrc.next()) {
 409                                 FileName const tmp =
 410                                         libFileSearch(string(),
 411                                                       lexrc.getString());
 412                                 if (read(tmp)) {
 413                                         lexrc.printError("Error reading "
 414                                                          "included file: " + tmp.absFilename());
 415                                 }
 416                         }
 417                         break;
 418                 case RC_BINDFILE:
 419                         if (lexrc.next())
 420                                 bind_file = os::internal_path(lexrc.getString());
 421                         break;
 422
 423                 case RC_DEFFILE:
 424                         if (lexrc.next())
 425                                 def_file = os::internal_path(lexrc.getString());
 426                         break;
 427
 428                 case RC_UIFILE:
 429                         if (lexrc.next())
 430                                 ui_file = os::internal_path(lexrc.getString());
 431                         break;
 432
 433                 case RC_AUTORESET_OPTIONS:
 434                         lexrc >> auto_reset_options;
 435                         break;
 436
 437                 case RC_DISPLAY_GRAPHICS:
 438                         if (lexrc.next())
 439                                 display_graphics = lexrc.getString() == "true";
 440                         break;
 441
 442                 case RC_TEX_EXPECTS_WINDOWS_PATHS:
 443                         lexrc >> windows_style_tex_paths;
 444                         break;
 445
 446                 case RC_TEX_ALLOWS_SPACES:
 447                         lexrc >> tex_allows_spaces;
 448                         break;
 449
 450                 case RC_KBMAP:
 451                         lexrc >> use_kbmap;
 452                         break;
 453
 454                 case RC_KBMAP_PRIMARY:
 455                         if (lexrc.next()) {
 456                                 string const kmap(os::internal_path(lexrc.getString()));
 457                                 if (kmap.empty()) {
 458                                         // nothing
 459                                 } else if (!libFileSearch("kbd", kmap,
 460                                                           "kmap").empty()) {
 461                                         primary_kbmap = kmap;
 462                                 } else {
 463                                         lexrc.printError("LyX: Keymap `$$Token' not found");
 464                                 }
 465                         }
 466                         break;
 467
 468                 case RC_KBMAP_SECONDARY:
 469                         if (lexrc.next()) {
 470                                 string const kmap(os::internal_path(lexrc.getString()));
 471                                 if (kmap.empty()) {
 472                                         // nothing
 473                                 } else if (!libFileSearch("kbd", kmap,
 474                                                           "kmap").empty()) {
 475                                         secondary_kbmap = kmap;
 476                                 } else {
 477                                         lexrc.printError("LyX: Keymap `$$Token' not found");
 478                                 }
 479                         }
 480                         break;
 481
 482                 case RC_FONT_ENCODING:
 483                         lexrc >> fontenc;
 484                         break;
 485
 486                 case RC_PRINTER:
 487                         lexrc >> printer;
 488                         break;
 489
 490                 case RC_PRINT_COMMAND:
 491                         if (lexrc.next(true)) {
 492                                 print_command = lexrc.getString();
 493                         }
 494                         break;
 495
 496                 case RC_PRINTEVENPAGEFLAG:
 497                         lexrc >> print_evenpage_flag;
 498                         break;
 499
 500                 case RC_PRINTODDPAGEFLAG:
 501                         lexrc >> print_oddpage_flag;
 502                         break;
 503
 504                 case RC_PRINTPAGERANGEFLAG:
 505                         lexrc >> print_pagerange_flag;
 506                         break;
 507
 508                 case RC_PRINTCOPIESFLAG:
 509                         lexrc >> print_copies_flag;
 510                         break;
 511
 512                 case RC_PRINTCOLLCOPIESFLAG:
 513                         lexrc >> print_collcopies_flag;
 514                         break;
 515
 516                 case RC_PRINTREVERSEFLAG:
 517                         lexrc >> print_reverse_flag;
 518                         break;
 519
 520                 case RC_PRINTLANDSCAPEFLAG:
 521                         lexrc >> print_landscape_flag;
 522                         break;
 523
 524                 case RC_PRINTTOPRINTER:
 525                         lexrc >> print_to_printer;
 526                         break;
 527
 528                 case RC_PRINT_ADAPTOUTPUT:
 529                         lexrc >> print_adapt_output;
 530                         break;
 531
 532                 case RC_PRINTTOFILE:
 533                         if (lexrc.next()) {
 534                                 print_to_file = os::internal_path(lexrc.getString());
 535                         }
 536                         break;
 537
 538                 case RC_PRINTFILEEXTENSION:
 539                         lexrc >> print_file_extension;
 540                         break;
 541
 542                 case RC_PRINTEXSTRAOPTIONS:
 543                         lexrc >> print_extra_options;
 544                         break;
 545
 546                 case RC_PRINTSPOOL_COMMAND:
 547                         if (lexrc.next(true)) {
 548                                 print_spool_command = lexrc.getString();
 549                         }
 550                         break;
 551
 552                 case RC_PRINTSPOOL_PRINTERPREFIX:
 553                         lexrc >> print_spool_printerprefix;
 554                         break;
 555
 556                 case RC_PRINTPAPERDIMENSIONFLAG:
 557                         lexrc >> print_paper_dimension_flag;
 558                         break;
 559
 560                 case RC_PRINTPAPERFLAG:
 561                         lexrc >> print_paper_flag;
 562                         break;
 563
 564                 case RC_DEFAULT_PAPERSIZE:
 565                         if (lexrc.next()) {
 566                                 string const size = ascii_lowercase(lexrc.getString());
 567                                 if (size == "usletter")
 568                                         default_papersize = PAPER_USLETTER;
 569                                 else if (size == "legal")
 570                                         default_papersize = PAPER_USLEGAL;
 571                                 else if (size == "executive")
 572                                         default_papersize = PAPER_USEXECUTIVE;
 573                                 else if (size == "a3")
 574                                         default_papersize = PAPER_A3;
 575                                 else if (size == "a4")
 576                                         default_papersize = PAPER_A4;
 577                                 else if (size == "a5")
 578                                         default_papersize = PAPER_A5;
 579                                 else if (size == "b5")
 580                                         default_papersize = PAPER_B5;
 581                                 else if (size == "default")
 582                                         default_papersize = PAPER_DEFAULT;
 583                         }
 584                         break;
 585
 586                 case RC_VIEWDVI_PAPEROPTION:
 587                         if (lexrc.next())
 588                                 view_dvi_paper_option = lexrc.getString();
 589                         else
 590                                 view_dvi_paper_option.erase();
 591                         break;
 592
 593                 case RC_CHKTEX_COMMAND:
 594                         if (lexrc.next(true)) {
 595                                 chktex_command = lexrc.getString();
 596                         }
 597                         break;
 598
 599                 case RC_BIBTEX_ALTERNATIVES:
 600                         if (lexrc.next(true)) {
 601                                 bibtex_alternatives.push_back(lexrc.getString());
 602                         }
 603                         break;
 604
 605                 case RC_BIBTEX_COMMAND:
 606                         if (lexrc.next(true)) {
 607                                 bibtex_command = lexrc.getString();
 608                         }
 609                         break;
 610
 611                 case RC_JBIBTEX_COMMAND:
 612                         if (lexrc.next(true)) {
 613                                 jbibtex_command = lexrc.getString();
 614                         }
 615                         break;
 616
 617                 case RC_INDEX_ALTERNATIVES:
 618                         if (lexrc.next(true)) {
 619                                 index_alternatives.push_back(lexrc.getString());
 620                         }
 621                         break;
 622
 623                 case RC_INDEX_COMMAND:
 624                         if (lexrc.next(true)) {
 625                                 index_command = lexrc.getString();
 626                         }
 627                         break;
 628
 629                 case RC_JINDEX_COMMAND:
 630                         if (lexrc.next(true)) {
 631                                 jindex_command = lexrc.getString();
 632                         }
 633                         break;
 634
 635                 case RC_SPLITINDEX_COMMAND:
 636                         if (lexrc.next(true)) {
 637                                 splitindex_command = lexrc.getString();
 638                         }
 639                         break;
 640
 641                 case RC_NOMENCL_COMMAND:
 642                         if (lexrc.next(true)) {
 643                                 nomencl_command = lexrc.getString();
 644                         }
 645                         break;
 646
 647                 case RC_SCREEN_DPI:
 648                         lexrc >> dpi;
 649                         break;
 650
 651                 case RC_SCREEN_ZOOM:
 652                         lexrc >> zoom;
 653                         break;
 654
 655                 case RC_GEOMETRY_SESSION:
 656                         lexrc >> allow_geometry_session;
 657                         break;
 658
 659                 case RC_SCREEN_FONT_SIZES:
 660                         lexrc >> font_sizes[FONT_SIZE_TINY];
 661                         lexrc >> font_sizes[FONT_SIZE_SCRIPT];
 662                         lexrc >> font_sizes[FONT_SIZE_FOOTNOTE];
 663                         lexrc >> font_sizes[FONT_SIZE_SMALL];
 664                         lexrc >> font_sizes[FONT_SIZE_NORMAL];
 665                         lexrc >> font_sizes[FONT_SIZE_LARGE];
 666                         lexrc >> font_sizes[FONT_SIZE_LARGER];
 667                         lexrc >> font_sizes[FONT_SIZE_LARGEST];
 668                         lexrc >> font_sizes[FONT_SIZE_HUGE];
 669                         lexrc >> font_sizes[FONT_SIZE_HUGER];
 670                         break;
 671
 672                 case RC_SCREEN_FONT_SCALABLE:
 673                         lexrc >> use_scalable_fonts;
 674                         break;
 675
 676                 case RC_AUTOSAVE:
 677                         lexrc >> autosave;
 678                         break;
 679
 680                 case RC_DOCUMENTPATH:
 681                         if (lexrc.next()) {
 682                                 document_path = os::internal_path(lexrc.getString());
 683                                 document_path = expandPath(document_path);
 684                         }
 685                         break;
 686
 687                 case RC_EXAMPLEPATH:
 688                         if (lexrc.next()) {
 689                                 example_path = os::internal_path(lexrc.getString());
 690                                 example_path = expandPath(example_path);
 691                         }
 692                         break;
 693
 694                 case RC_TEMPLATEPATH:
 695                         if (lexrc.next()) {
 696                                 template_path = os::internal_path(lexrc.getString());
 697                                 template_path = expandPath(template_path);
 698                         }
 699                         break;
 700
 701                 case RC_TEMPDIRPATH:
 702                         if (lexrc.next()) {
 703                                 tempdir_path = os::internal_path(lexrc.getString());
 704                                 tempdir_path = expandPath(tempdir_path);
 705                         }
 706                         break;
 707
 708                 case RC_THESAURUSDIRPATH:
 709                         if (lexrc.next()) {
 710                                 thesaurusdir_path = os::internal_path(lexrc.getString());
 711                                 thesaurusdir_path = expandPath(thesaurusdir_path);
 712                         }
 713                         break;
 714
 715                 case RC_USETEMPDIR:
 716                         if (lexrc.next())
 717                                 LYXERR0("Ignoring obsolete use_tempdir flag.");
 718                         break;
 719
 720                 case RC_USELASTFILEPOS:
 721                         lexrc >> use_lastfilepos;
 722                         break;
 723
 724                 case RC_LOADSESSION:
 725                         lexrc >> load_session;
 726                         break;
 727
 728                 case RC_MOUSE_WHEEL_SPEED:
 729                         lexrc >> mouse_wheel_speed;
 730                         break;
 731
 732                 case RC_COMPLETION_INLINE_DELAY:
 733                         lexrc >> completion_inline_delay;
 734                         break;
 735
 736                 case RC_COMPLETION_INLINE_MATH:
 737                         lexrc >> completion_inline_math;
 738                         break;
 739
 740                 case RC_COMPLETION_INLINE_TEXT:
 741                         lexrc >> completion_inline_text;
 742                         break;
 743
 744                 case RC_COMPLETION_INLINE_DOTS:
 745                         lexrc >> completion_inline_dots;
 746                         break;
 747
 748                 case RC_AUTOCORRECTION_MATH:
 749                         lexrc >> autocorrection_math;
 750                         break;
 751
 752                 case RC_COMPLETION_POPUP_DELAY:
 753                         lexrc >> completion_popup_delay;
 754                         break;
 755
 756                 case RC_COMPLETION_POPUP_MATH:
 757                         lexrc >> completion_popup_math;
 758                         break;
 759
 760                 case RC_COMPLETION_POPUP_TEXT:
 761                         lexrc >> completion_popup_text;
 762                         break;
 763
 764                 case RC_COMPLETION_CURSOR_TEXT:
 765                         lexrc >> completion_cursor_text;
 766                         break;
 767
 768                 case RC_COMPLETION_POPUP_AFTER_COMPLETE:
 769                         lexrc >> completion_popup_after_complete;
 770                         break;
 771
 772                 case RC_NUMLASTFILES:
 773                         lexrc >> num_lastfiles;
 774                         break;
 775
 776                 case RC_CHECKLASTFILES:
 777                         lexrc >> check_lastfiles;
 778                         break;
 779
 780                 case RC_SCREEN_FONT_ROMAN:
 781                         if (lexrc.next()) {
 782                                 roman_font_name = lexrc.getString();
 783                                 oldFontFormat(roman_font_name,
 784                                               roman_font_foundry);
 785                         }
 786                         break;
 787
 788                 case RC_SCREEN_FONT_SANS:
 789                         if (lexrc.next()) {
 790                                 sans_font_name = lexrc.getString();
 791                                 oldFontFormat(sans_font_name, sans_font_foundry);
 792                         }
 793                         break;
 794
 795                 case RC_SCREEN_FONT_TYPEWRITER:
 796                         if (lexrc.next()) {
 797                                 typewriter_font_name = lexrc.getString();
 798                                 oldFontFormat(typewriter_font_name,
 799                                               typewriter_font_foundry);
 800                         }
 801                         break;
 802
 803                 case RC_SCREEN_FONT_ROMAN_FOUNDRY:
 804                         lexrc >> roman_font_foundry;
 805                         break;
 806
 807                 case RC_SCREEN_FONT_SANS_FOUNDRY:
 808                         lexrc >> sans_font_foundry;
 809                         break;
 810
 811                 case RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
 812                         lexrc >> typewriter_font_foundry;
 813                         break;
 814
 815                 case RC_SET_COLOR: {
 816                         if (!lexrc.next()) {
 817                                 lexrc.printError("Missing color tag.");
 818                                 break;
 819                         }
 820                         string lyx_name = lexrc.getString();
 821
 822                         if (!lexrc.next()) {
 823                                 lexrc.printError("Missing color name for color: `$$Token'");
 824                                 break;
 825                         }
 826                         string x11_name = lexrc.getString();
 827
 828                         ColorCode const col =
 829                                 lcolor.getFromLyXName(lyx_name);
 830                         if (col == Color_none ||
 831                             col == Color_inherit ||
 832                             col == Color_ignore)
 833                                 break;
 834
 835                         if (!lcolor.setColor(col, x11_name))
 836                                 LYXERR0("Bad lyxrc set_color for " << lyx_name);
 837                         break;
 838                 }
 839
 840                 case RC_AUTOREGIONDELETE:
 841                         // Auto region delete defaults to true
 842                         lexrc >> auto_region_delete;
 843                         break;
 844
 845                 case RC_SERVERPIPE:
 846                         if (lexrc.next()) {
 847                                 lyxpipes = os::internal_path(lexrc.getString());
 848                                 lyxpipes = expandPath(lyxpipes);
 849                         }
 850                         break;
 851
 852                 case RC_CURSOR_FOLLOWS_SCROLLBAR:
 853                         lexrc >> cursor_follows_scrollbar;
 854                         break;
 855
 856                 case RC_SCROLL_BELOW_DOCUMENT:
 857                         lexrc >> scroll_below_document;
 858                         break;
 859
 860                 case RC_MAC_LIKE_WORD_MOVEMENT:
 861                         lexrc >> mac_like_word_movement;
 862                         break;
 863
 864                 case RC_MACRO_EDIT_STYLE:
 865                         if (lexrc.next()) {
 866                                 switch (lexrc.getInteger()) {
 867                                 case 0: macro_edit_style = MACRO_EDIT_INLINE_BOX; break;
 868                                 case 1: macro_edit_style = MACRO_EDIT_INLINE; break;
 869                                 case 2: macro_edit_style = MACRO_EDIT_LIST; break;
 870                                 }
 871                         }
 872                         break;
 873
 874                 case RC_DIALOGS_ICONIFY_WITH_MAIN:
 875                         lexrc >> dialogs_iconify_with_main;
 876                         break;
 877
 878                 case RC_PLAINTEXT_ROFF_COMMAND:
 879                         (void) lexrc.getString(); // Obsoleted in 2.0
 880                         break;
 881                 case RC_PLAINTEXT_LINELEN:
 882                         lexrc >> plaintext_linelen;
 883                         break;
 884                         // Spellchecker settings:
 885                 case RC_ACCEPT_COMPOUND:
 886                         lexrc >> spellchecker_accept_compound;
 887                         break;
 888                 case RC_USE_INP_ENC:
 889                         lexrc >> spellchecker_use_input_encoding;
 890                         break;
 891                 case RC_USE_ALT_LANG:
 892                         lexrc >> spellchecker_use_alt_lang;
 893                         break;
 894                 case RC_USE_PERS_DICT:
 895                         lexrc >> spellchecker_use_pers_dict;
 896                         break;
 897                 case RC_USE_TOOLTIP:
 898                         lexrc >> use_tooltip;
 899                         break;
 900                 case RC_USE_PIXMAP_CACHE:
 901                         lexrc >> use_pixmap_cache;
 902                         break;
 903                 case RC_USE_ESC_CHARS:
 904                         lexrc >> spellchecker_use_esc_chars;
 905                         break;
 906                 case RC_ALT_LANG:
 907                         lexrc >> spellchecker_alt_lang;
 908                         break;
 909                 case RC_PERS_DICT:
 910                         if (lexrc.next())
 911                                 spellchecker_pers_dict = os::internal_path(lexrc.getString());
 912                         break;
 913                 case RC_ESC_CHARS:
 914                         lexrc >> spellchecker_esc_chars;
 915                         break;
 916                 case RC_SPELLCHECK_CONTINUOUSLY:
 917                         lexrc >> spellcheck_continuously;
 918                         break;
 919                 case RC_MAKE_BACKUP:
 920                         lexrc >> make_backup;
 921                         break;
 922                 case RC_BACKUPDIR_PATH:
 923                         if (lexrc.next()) {
 924                                 backupdir_path = os::internal_path(lexrc.getString());
 925                                 backupdir_path = expandPath(backupdir_path);
 926                         }
 927                         break;
 928                 case RC_DATE_INSERT_FORMAT:
 929                         lexrc >> date_insert_format;
 930                         break;
 931                 case RC_LANGUAGE_PACKAGE:
 932                         lexrc >> language_package;
 933                         break;
 934                 case RC_LANGUAGE_AUTO_BEGIN:
 935                         lexrc >> language_auto_begin;
 936                         break;
 937                 case RC_LANGUAGE_AUTO_END:
 938                         lexrc >> language_auto_end;
 939                         break;
 940                 case RC_LANGUAGE_GLOBAL_OPTIONS:
 941                         lexrc >> language_global_options;
 942                         break;
 943                 case RC_LANGUAGE_USE_BABEL:
 944                         lexrc >> language_use_babel;
 945                         break;
 946                 case RC_LANGUAGE_COMMAND_BEGIN:
 947                         lexrc >> language_command_begin;
 948                         break;
 949                 case RC_LANGUAGE_COMMAND_END:
 950                         lexrc >> language_command_end;
 951                         break;
 952                 case RC_LANGUAGE_COMMAND_LOCAL:
 953                         lexrc >> language_command_local;
 954                         break;
 955                 case RC_RTL_SUPPORT:
 956                         lexrc >> rtl_support;
 957                         break;
 958                 case RC_VISUAL_CURSOR:
 959                         lexrc >> visual_cursor;
 960                         break;
 961                 case RC_AUTO_NUMBER:
 962                         lexrc >> auto_number;
 963                         break;
 964                 case RC_MARK_FOREIGN_LANGUAGE:
 965                         lexrc >> mark_foreign_language;
 966                         break;
 967
 968                 case RC_COPIER: {
 969                         string fmt, command;
 970                         if (lexrc.next())
 971                                 fmt = lexrc.getString();
 972                         if (lexrc.next(true))
 973                                 command = lexrc.getString();
 974                         setMover(fmt, command);
 975                         break;
 976                 }
 977
 978                 case RC_CONVERTER: {
 979                         string from, to, command, flags;
 980                         if (lexrc.next())
 981                                 from = lexrc.getString();
 982                         if (lexrc.next())
 983                                 to = lexrc.getString();
 984                         if (lexrc.next(true))
 985                                 command = lexrc.getString();
 986                         if (lexrc.next())
 987                                 flags = lexrc.getString();
 988                         if (command.empty())
 989                                 theConverters().erase(from, to);
 990                         else
 991                                 theConverters().add(from, to, command, flags);
 992                         break;
 993                 }
 994                 // compatibility with versions older than 1.4.0 only
 995                 case RC_VIEWER: {
 996                         string format, command;
 997                         lexrc >> format >> command;
 998                         formats.setViewer(format, command);
 999                         break;
1000                 }
1001                 case RC_FORMAT: {
1002                         string format, extension, prettyname, shortcut;
1003                         lexrc >> format >> extension >> prettyname >> shortcut;
1004                         string viewer, editor;
1005                         if (lexrc.next(true))
1006                                 viewer = lexrc.getString();
1007                         if (lexrc.next(true))
1008                                 editor = lexrc.getString();
1009                         string flags;
1010                         // Hack to ensure compatibility with versions older
1011                         // than 1.5.0
1012                         int le = lexrc.lex();
1013                         if (le != Lexer::LEX_FEOF && le != Lexer::LEX_UNDEF) {
1014                                 flags = lexrc.getString();
1015                                 if (le != Lexer::LEX_DATA) {
1016                                         // We have got a known token.
1017                                         // Therefore this is an old style
1018                                         // format definition without
1019                                         // flags.
1020                                         lexrc.pushToken(flags);
1021                                         flags.erase();
1022                                 }
1023                         }
1024                         int flgs = Format::none;
1025                         while (!flags.empty()) {
1026                                 string flag;
1027                                 flags = split(flags, flag, ',');
1028                                 if (flag == "document")
1029                                         flgs |= Format::document;
1030                                 else if (flag == "vector")
1031                                         flgs |= Format::vector;
1032                                 else
1033                                         LYXERR0("Ignoring unknown flag `"
1034                                                << flag << "' for format `"
1035                                                << format << "'.");
1036                         }
1037                         if (prettyname.empty()) {
1038                                 if (theConverters().formatIsUsed(format))
1039                                         LYXERR0("Can't delete format " << format);
1040                                 else
1041                                         formats.erase(format);
1042                         } else {
1043                                 formats.add(format, extension, prettyname,
1044                                             shortcut, viewer, editor, flgs);
1045                         }
1046                         break;
1047                 }
1048                 case RC_DEFAULT_VIEW_FORMAT:
1049                         lexrc >> default_view_format;
1050                         break;
1051
1052                 case RC_DEFAULT_LANGUAGE:
1053                         lexrc >> default_language;
1054                         break;
1055
1056                 case RC_GUI_LANGUAGE:
1057                         lexrc >> gui_language;
1058                         break;
1059
1060                 case RC_LABEL_INIT_LENGTH:
1061                         lexrc >> label_init_length;
1062                         break;
1063
1064                 case RC_SHOW_BANNER:
1065                         lexrc >> show_banner;
1066                         break;
1067
1068                 case RC_PREVIEW:
1069                         if (lexrc.next()) {
1070                                 string const tmp = lexrc.getString();
1071                                 if (tmp == "true" || tmp == "on")
1072                                         preview = PREVIEW_ON;
1073                                 else if (tmp == "no_math")
1074                                         preview = PREVIEW_NO_MATH;
1075                                 else {
1076                                         preview = PREVIEW_OFF;
1077                                         if (tmp != "false" && tmp != "off")
1078                                                 LYXERR0("Unrecognized preview status \""
1079                                                        << tmp << '\n');
1080                                 }
1081                         }
1082                         break;
1083
1084                 case RC_PREVIEW_HASHED_LABELS:
1085                         lexrc >> preview_hashed_labels;
1086                         break;
1087
1088                 case RC_PREVIEW_SCALE_FACTOR:
1089                         lexrc >> preview_scale_factor;
1090                         break;
1091
1092                 case RC_USER_NAME:
1093                         lexrc >> user_name;
1094                         break;
1095                 case RC_USER_EMAIL:
1096                         lexrc >> user_email;
1097                         break;
1098
1099                 case RC_PATH_PREFIX:
1100                         lexrc >> path_prefix;
1101                         break;
1102
1103                 case RC_USE_CONVERTER_CACHE:
1104                         lexrc >> use_converter_cache;
1105                         break;
1106                 case RC_CONVERTER_CACHE_MAXAGE:
1107                         lexrc >> converter_cache_maxage;
1108                         break;
1109
1110                 case RC_SORT_LAYOUTS:
1111                         lexrc >> sort_layouts;
1112                         break;
1113                 case RC_GROUP_LAYOUTS:
1114                         lexrc >> group_layouts;
1115                         break;
1116                 case RC_FULL_SCREEN_LIMIT:
1117                         lexrc >> full_screen_limit;
1118                         break;
1119                 case RC_FULL_SCREEN_TOOLBARS:
1120                         lexrc >> full_screen_toolbars;
1121                         break;
1122                 case RC_FULL_SCREEN_SCROLLBAR:
1123                         lexrc >> full_screen_scrollbar;
1124                         break;
1125                 case RC_FULL_SCREEN_TABBAR:
1126                         lexrc >> full_screen_tabbar;
1127                         break;
1128                 case RC_FULL_SCREEN_MENUBAR:
1129                         lexrc >> full_screen_menubar;
1130                         break;
1131                 case RC_FULL_SCREEN_WIDTH:
1132                         lexrc >> full_screen_width;
1133                         break;
1134                 case RC_OPEN_BUFFERS_IN_TABS:
1135                         lexrc >> open_buffers_in_tabs;
1136                         break;
1137
1138                 // Obsoleted in 2.0
1139                 case RC_SPELL_COMMAND:
1140                 case RC_USE_SPELL_LIB:
1141                         (void) lexrc.getString();
1142                         break;
1143
1144                 case RC_LAST:
1145                         break; // this is just a dummy
1146                 }
1147         }
1148
1149         /// Update converters data-structures
1150         theConverters().update(formats);
1151         theConverters().buildGraph();
1152
1153         return 0;
1154 }
1155
1156
1157 void LyXRC::write(FileName const & filename, bool ignore_system_lyxrc) const
1158 {
1159         ofstream ofs(filename.toFilesystemEncoding().c_str());
1160         if (ofs)
1161                 write(ofs, ignore_system_lyxrc);
1162 }
1163
1164
1165 void LyXRC::print() const
1166 {
1167         if (lyxerr.debugging())
1168                 write(lyxerr, false);
1169         else
1170                 write(cout, false);
1171 }
1172
1173
1174 class SameMover {
1175 public:
1176         typedef pair<string, SpecialisedMover> Data;
1177
1178         SameMover(Data const & comparison)
1179                 : comparison_(comparison) {}
1180
1181         bool operator()(Data const & data) const
1182         {
1183                 return data.first == comparison_.first &&
1184                         data.second.command() == comparison_.second.command();
1185         }
1186
1187 private:
1188         Data comparison_;
1189 };
1190
1191
1192 namespace {
1193
1194         // Escape \ and " so that LyXLex can read the string later
1195         string escapeCommand(string const & str) {
1196                 return subst(subst(str , "\\", "\\\\"),
1197                              "\"", "\\\"");
1198         }
1199
1200 }
1201
1202
1203 void LyXRC::write(ostream & os, bool ignore_system_lyxrc, string const & name) const
1204 {
1205         LyXRCTags tag = RC_LAST;
1206
1207         if (!name.empty()) {
1208                 for (int i = 0; i != lyxrcCount; ++i)
1209                         if ("\\" + name == lyxrcTags[i].tag)
1210                                 tag = static_cast<LyXRCTags>(lyxrcTags[i].code);
1211         }
1212
1213         if (tag == RC_LAST)
1214                 os << "# LyX " << lyx_version
1215                    << " generated this file. If you want to make your own\n"
1216                    << "# modifications you should do them from inside LyX and save.\n"
1217                    << "\n";
1218
1219         // Why the switch you might ask. It is a trick to ensure that all
1220         // the elements in the LyXRCTags enum are handled. As you can see
1221         // there are no breaks at all. So it is just a huge fall-through.
1222         // The nice thing is that we will get a warning from the compiler
1223         // if we forget an element.
1224         switch (tag) {
1225         case RC_LAST:
1226         case RC_INPUT:
1227                 // input/include files are not done here
1228         case RC_BINDFILE:
1229                 if (ignore_system_lyxrc ||
1230                     bind_file != system_lyxrc.bind_file) {
1231                         string const path = os::external_path(bind_file);
1232                         os << "\\bind_file \"" << path << "\"\n";
1233                 }
1234                 if (tag != RC_LAST)
1235                         break;
1236
1237         case RC_DEFFILE:
1238                 if (ignore_system_lyxrc ||
1239                     def_file != system_lyxrc.def_file) {
1240                         string const path = os::external_path(def_file);
1241                         os << "\\def_file \"" << path << "\"\n";
1242                 }
1243                 if (tag != RC_LAST)
1244                         break;
1245
1246                 //
1247                 // Misc Section
1248                 //
1249                 os << "\n#\n"
1250                    << "# MISC SECTION ######################################\n"
1251                    << "#\n\n";
1252                 // bind files are not done here.
1253
1254         case RC_PATH_PREFIX:
1255                 if (ignore_system_lyxrc ||
1256                     path_prefix != system_lyxrc.path_prefix) {
1257                         os << "\\path_prefix \"" << path_prefix << "\"\n";
1258                 }
1259                 if (tag != RC_LAST)
1260                         break;
1261         case RC_UIFILE:
1262                 if (ignore_system_lyxrc ||
1263                     ui_file != system_lyxrc.ui_file) {
1264                         string const path = os::external_path(ui_file);
1265                         os << "\\ui_file \"" << path << "\"\n";
1266                 }
1267                 if (tag != RC_LAST)
1268                         break;
1269         case RC_AUTOREGIONDELETE:
1270                 if (ignore_system_lyxrc ||
1271                     auto_region_delete != system_lyxrc.auto_region_delete) {
1272                         os << "# Set to false to inhibit automatic replacement of\n"
1273                            << "# the current selection.\n"
1274                            << "\\auto_region_delete " << convert<string>(auto_region_delete)
1275                            << '\n';
1276                 }
1277                 if (tag != RC_LAST)
1278                         break;
1279         case RC_AUTORESET_OPTIONS:
1280                 if (ignore_system_lyxrc ||
1281                     auto_reset_options != system_lyxrc.auto_reset_options) {
1282                         os << "# Set to false to inhibit automatic reset of\n"
1283                            << "# the class options to defaults on class change.\n"
1284                            << "\\auto_reset_options "
1285                            << convert<string>(auto_reset_options)
1286                            << '\n';
1287                 }
1288                 if (tag != RC_LAST)
1289                         break;
1290         case RC_AUTOSAVE:
1291                 if (ignore_system_lyxrc ||
1292                     autosave != system_lyxrc.autosave) {
1293                         os << "# The time interval between auto-saves in seconds.\n"
1294                            << "\\autosave " << autosave << '\n';
1295                 }
1296                 if (tag != RC_LAST)
1297                         break;
1298         case RC_DISPLAY_GRAPHICS:
1299                 if (ignore_system_lyxrc ||
1300                     display_graphics != system_lyxrc.display_graphics) {
1301                         os << "# Display graphics within LyX\n"
1302                            << "# true|false\n"
1303                            << "\\display_graphics "
1304                            << (display_graphics ? "true" : "false")
1305                            << '\n';
1306                 }
1307                 if (tag != RC_LAST)
1308                         break;
1309         case RC_SORT_LAYOUTS:
1310                 if (ignore_system_lyxrc ||
1311                     sort_layouts != system_lyxrc.sort_layouts) {
1312                         os << "# Sort layouts alphabetically.\n"
1313                            << "\\sort_layouts " << convert<string>(sort_layouts) << '\n';
1314                 }
1315                 if (tag != RC_LAST)
1316                         break;
1317         case RC_GROUP_LAYOUTS:
1318                 if (ignore_system_lyxrc ||
1319                     group_layouts != system_lyxrc.group_layouts) {
1320                         os << "# Group layouts by their category.\n"
1321                            << "\\group_layouts " << convert<string>(group_layouts) << '\n';
1322                 }
1323                 if (tag != RC_LAST)
1324                         break;
1325         case RC_VIEWDVI_PAPEROPTION:
1326                 if (ignore_system_lyxrc ||
1327                     view_dvi_paper_option
1328                     != system_lyxrc.view_dvi_paper_option) {
1329                         os << "# Options used to specify paper size to the\n"
1330                            << "# view_dvi_command (e.g. -paper)\n"
1331                            << "\\view_dvi_paper_option \""
1332                            << view_dvi_paper_option << "\"\n";
1333                 }
1334                 if (tag != RC_LAST)
1335                         break;
1336         case RC_DEFAULT_PAPERSIZE:
1337                 if (ignore_system_lyxrc ||
1338                     default_papersize != system_lyxrc.default_papersize) {
1339                         os << "# The default papersize to use.\n"
1340                            << "\\default_papersize \"";
1341                         switch (default_papersize) {
1342                         case PAPER_DEFAULT:
1343                                 os << "default"; break;
1344                         case PAPER_USLETTER:
1345                                 os << "usletter"; break;
1346                         case PAPER_USLEGAL:
1347                                 os << "legal"; break;
1348                         case PAPER_USEXECUTIVE:
1349                                 os << "executive"; break;
1350                         case PAPER_A3:
1351                                 os << "a3"; break;
1352                         case PAPER_A4:
1353                                 os << "a4"; break;
1354                         case PAPER_A5:
1355                                 os << "a5"; break;
1356                         case PAPER_B5:
1357                                 os << "b5"; break;
1358                         case PAPER_CUSTOM:
1359                         case PAPER_B3:
1360                         case PAPER_B4: break;
1361                         }
1362                         os << "\"\n";
1363                 }
1364                 if (tag != RC_LAST)
1365                         break;
1366         case RC_CHKTEX_COMMAND:
1367                 if (ignore_system_lyxrc ||
1368                     chktex_command != system_lyxrc.chktex_command) {
1369                         os << "\\chktex_command \"" << escapeCommand(chktex_command) << "\"\n";
1370                 }
1371                 if (tag != RC_LAST)
1372                         break;
1373         case RC_BIBTEX_ALTERNATIVES:
1374                 if (ignore_system_lyxrc ||
1375                     bibtex_alternatives != system_lyxrc.bibtex_alternatives) {
1376                         for (vector<string>::const_iterator it = bibtex_alternatives.begin();
1377                              it != bibtex_alternatives.end(); ++it)
1378                         os << "\\bibtex_alternatives \"" << *it << "\"\n";
1379                 }
1380                 if (tag != RC_LAST)
1381                         break;
1382         case RC_BIBTEX_COMMAND:
1383                 if (ignore_system_lyxrc ||
1384                     bibtex_command != system_lyxrc.bibtex_command) {
1385                         os << "\\bibtex_command \"" << escapeCommand(bibtex_command) << "\"\n";
1386                 }
1387                 if (tag != RC_LAST)
1388                         break;
1389         case RC_JBIBTEX_COMMAND:
1390                 if (ignore_system_lyxrc ||
1391                     jbibtex_command != system_lyxrc.jbibtex_command) {
1392                         os << "\\jbibtex_command \"" << escapeCommand(jbibtex_command) << "\"\n";
1393                 }
1394                 if (tag != RC_LAST)
1395                         break;
1396         case RC_INDEX_ALTERNATIVES:
1397                 if (ignore_system_lyxrc ||
1398                     index_alternatives != system_lyxrc.index_alternatives) {
1399                         for (vector<string>::const_iterator it = index_alternatives.begin();
1400                              it != index_alternatives.end(); ++it)
1401                         os << "\\index_alternatives \"" << *it << "\"\n";
1402                 }
1403                 if (tag != RC_LAST)
1404                         break;
1405         case RC_INDEX_COMMAND:
1406                 if (ignore_system_lyxrc ||
1407                     index_command != system_lyxrc.index_command) {
1408                         os << "\\index_command \"" << escapeCommand(index_command) << "\"\n";
1409                 }
1410                 if (tag != RC_LAST)
1411                         break;
1412         case RC_JINDEX_COMMAND:
1413                 if (ignore_system_lyxrc ||
1414                     jindex_command != system_lyxrc.jindex_command) {
1415                         os << "\\jindex_command \"" << escapeCommand(jindex_command) << "\"\n";
1416                 }
1417                 if (tag != RC_LAST)
1418                         break;
1419         case RC_SPLITINDEX_COMMAND:
1420                 if (ignore_system_lyxrc ||
1421                     splitindex_command != system_lyxrc.splitindex_command) {
1422                         os << "\\splitindex_command \"" << escapeCommand(splitindex_command) << "\"\n";
1423                 }
1424                 if (tag != RC_LAST)
1425                         break;
1426         case RC_NOMENCL_COMMAND:
1427                 if (ignore_system_lyxrc ||
1428                     nomencl_command != system_lyxrc.nomencl_command) {
1429                         os << "\\nomencl_command \"" << escapeCommand(nomencl_command) << "\"\n";
1430                 }
1431                 if (tag != RC_LAST)
1432                         break;
1433         case RC_TEX_EXPECTS_WINDOWS_PATHS:
1434                 if (ignore_system_lyxrc ||
1435                     windows_style_tex_paths != system_lyxrc.windows_style_tex_paths) {
1436                         os << "\\tex_expects_windows_paths "
1437                            << convert<string>(windows_style_tex_paths) << '\n';
1438                 }
1439                 if (tag != RC_LAST)
1440                         break;
1441         case RC_TEX_ALLOWS_SPACES:
1442                 if (tex_allows_spaces != system_lyxrc.tex_allows_spaces) {
1443                         os << "\\tex_allows_spaces "
1444                            << convert<string>(tex_allows_spaces) << '\n';
1445                 }
1446                 if (tag != RC_LAST)
1447                         break;
1448         case RC_KBMAP:
1449                 if (ignore_system_lyxrc ||
1450                     use_kbmap != system_lyxrc.use_kbmap) {
1451                         os << "\\kbmap " << convert<string>(use_kbmap) << '\n';
1452                 }
1453                 if (tag != RC_LAST)
1454                         break;
1455         case RC_KBMAP_PRIMARY:
1456                 if (ignore_system_lyxrc ||
1457                     primary_kbmap != system_lyxrc.primary_kbmap) {
1458                         string const path = os::external_path(primary_kbmap);
1459                         os << "\\kbmap_primary \"" << path << "\"\n";
1460                 }
1461                 if (tag != RC_LAST)
1462                         break;
1463         case RC_KBMAP_SECONDARY:
1464                 if (ignore_system_lyxrc ||
1465                     secondary_kbmap != system_lyxrc.secondary_kbmap) {
1466                         string const path = os::external_path(secondary_kbmap);
1467                         os << "\\kbmap_secondary \"" << path << "\"\n";
1468                 }
1469                 if (tag != RC_LAST)
1470                         break;
1471         case RC_SERVERPIPE:
1472                 if (ignore_system_lyxrc ||
1473                     lyxpipes != system_lyxrc.lyxpipes) {
1474                         string const path = os::external_path(lyxpipes);
1475                         os << "\\serverpipe \"" << path << "\"\n";
1476                 }
1477                 if (tag != RC_LAST)
1478                         break;
1479         case RC_DATE_INSERT_FORMAT:
1480                 if (ignore_system_lyxrc ||
1481                     date_insert_format != system_lyxrc.date_insert_format) {
1482                         os << "\\date_insert_format \"" << date_insert_format
1483                            << "\"\n";
1484                 }
1485                 if (tag != RC_LAST)
1486                         break;
1487         case RC_LABEL_INIT_LENGTH:
1488                 if (ignore_system_lyxrc ||
1489                     label_init_length != system_lyxrc.label_init_length) {
1490                         os << "\\label_init_length " << label_init_length
1491                            << '\n';
1492                 }
1493                 if (tag != RC_LAST)
1494                         break;
1495
1496         case RC_USER_NAME:
1497                 os << "\\user_name \"" << user_name << "\"\n";
1498                 if (tag != RC_LAST)
1499                         break;
1500
1501         case RC_USER_EMAIL:
1502                 os << "\\user_email \"" << user_email << "\"\n";
1503                 if (tag != RC_LAST)
1504                         break;
1505
1506         case RC_SHOW_BANNER:
1507                 if (ignore_system_lyxrc ||
1508                     show_banner != system_lyxrc.show_banner) {
1509                         os << "\\show_banner " << convert<string>(show_banner) << '\n';
1510                 }
1511                 if (tag != RC_LAST)
1512                         break;
1513
1514         case RC_PREVIEW:
1515                 if (ignore_system_lyxrc ||
1516                     preview != system_lyxrc.preview) {
1517                         string status;
1518                         switch (preview) {
1519                         case PREVIEW_ON:
1520                                 status = "on";
1521                                 break;
1522                         case PREVIEW_NO_MATH:
1523                                 status = "no_math";
1524                                 break;
1525                         case PREVIEW_OFF:
1526                                 status = "off";
1527                                 break;
1528                         }
1529                         os << "\\preview " << status << '\n';
1530                 }
1531                 if (tag != RC_LAST)
1532                         break;
1533
1534         case RC_PREVIEW_HASHED_LABELS:
1535                 if (ignore_system_lyxrc ||
1536                     preview_hashed_labels !=
1537                     system_lyxrc.preview_hashed_labels) {
1538                         os << "\\preview_hashed_labels "
1539                            << convert<string>(preview_hashed_labels) << '\n';
1540                 }
1541                 if (tag != RC_LAST)
1542                         break;
1543
1544         case RC_PREVIEW_SCALE_FACTOR:
1545                 if (ignore_system_lyxrc ||
1546                     preview_scale_factor != system_lyxrc.preview_scale_factor) {
1547                         os << "\\preview_scale_factor "
1548                            << preview_scale_factor << '\n';
1549                 }
1550                 if (tag != RC_LAST)
1551                         break;
1552
1553         case RC_USE_CONVERTER_CACHE:
1554                 if (ignore_system_lyxrc ||
1555                     use_converter_cache != system_lyxrc.use_converter_cache) {
1556                         os << "\\use_converter_cache "
1557                            << convert<string>(use_converter_cache) << '\n';
1558                 }
1559                 if (tag != RC_LAST)
1560                         break;
1561
1562         case RC_CONVERTER_CACHE_MAXAGE:
1563                 if (ignore_system_lyxrc ||
1564                     converter_cache_maxage != system_lyxrc.converter_cache_maxage) {
1565                         os << "\\converter_cache_maxage "
1566                            << converter_cache_maxage << '\n';
1567                 }
1568                 if (tag != RC_LAST)
1569                         break;
1570
1571                 os << "\n#\n"
1572                    << "# SCREEN & FONTS SECTION ############################\n"
1573                    << "#\n\n";
1574
1575         case RC_SCREEN_DPI:
1576                 if (ignore_system_lyxrc ||
1577                     dpi != system_lyxrc.dpi) {
1578                         os << "\\screen_dpi " << dpi << '\n';
1579                 }
1580                 if (tag != RC_LAST)
1581                         break;
1582         case RC_SCREEN_ZOOM:
1583                 if (ignore_system_lyxrc ||
1584                     zoom != system_lyxrc.zoom) {
1585                         os << "\\screen_zoom " << zoom << '\n';
1586                 }
1587                 if (tag != RC_LAST)
1588                         break;
1589         case RC_GEOMETRY_SESSION:
1590                 if (ignore_system_lyxrc ||
1591                     allow_geometry_session != system_lyxrc.allow_geometry_session) {
1592                         os << "\\allow_geometry_session " << convert<string>(allow_geometry_session)
1593                            << '\n';
1594                 }
1595                 if (tag != RC_LAST)
1596                         break;
1597         case RC_CURSOR_FOLLOWS_SCROLLBAR:
1598                 if (ignore_system_lyxrc ||
1599                     cursor_follows_scrollbar
1600                     != system_lyxrc.cursor_follows_scrollbar) {
1601                         os << "\\cursor_follows_scrollbar "
1602                            << convert<string>(cursor_follows_scrollbar) << '\n';
1603                 }
1604                 if (tag != RC_LAST)
1605                         break;
1606         case RC_SCROLL_BELOW_DOCUMENT:
1607                 if (ignore_system_lyxrc ||
1608                     scroll_below_document
1609                     != system_lyxrc.scroll_below_document) {
1610                         os << "\\scroll_below_document "
1611                            << convert<string>(scroll_below_document) << '\n';
1612                 }
1613                 if (tag != RC_LAST)
1614                         break;
1615         case RC_MAC_LIKE_WORD_MOVEMENT:
1616                 if (ignore_system_lyxrc ||
1617                     mac_like_word_movement
1618                     != system_lyxrc.mac_like_word_movement) {
1619                         os << "\\mac_like_word_movement "
1620                            << convert<string>(mac_like_word_movement) << '\n';
1621                 }
1622                 if (tag != RC_LAST)
1623                         break;
1624         case RC_MACRO_EDIT_STYLE:
1625                 if (ignore_system_lyxrc ||
1626                     macro_edit_style
1627                     != system_lyxrc.macro_edit_style) {
1628                         os << "\\macro_edit_style ";
1629                         switch (macro_edit_style) {
1630                         case MACRO_EDIT_INLINE_BOX: os << "0\n"; break;
1631                         case MACRO_EDIT_INLINE: os << "1\n"; break;
1632                         case MACRO_EDIT_LIST: os << "2\n"; break;
1633                         }
1634                 }
1635                 if (tag != RC_LAST)
1636                         break;
1637         case RC_DIALOGS_ICONIFY_WITH_MAIN:
1638                 if (ignore_system_lyxrc ||
1639                     dialogs_iconify_with_main
1640                    != system_lyxrc.dialogs_iconify_with_main) {
1641                         os << "\\dialogs_iconify_with_main "
1642                           <<  convert<string>(dialogs_iconify_with_main) << '\n';
1643                 }
1644                 if (tag != RC_LAST)
1645                         break;
1646         case RC_SCREEN_FONT_ROMAN:
1647                 if (ignore_system_lyxrc ||
1648                     roman_font_name != system_lyxrc.roman_font_name) {
1649                         os << "\\screen_font_roman \"" << roman_font_name
1650                            << "\"\n";
1651                 }
1652                 if (tag != RC_LAST)
1653                         break;
1654         case RC_SCREEN_FONT_ROMAN_FOUNDRY:
1655                 if (ignore_system_lyxrc ||
1656                     roman_font_foundry != system_lyxrc.roman_font_foundry) {
1657                         os << "\\screen_font_roman_foundry \"" << roman_font_foundry
1658                            << "\"\n";
1659                 }
1660                 if (tag != RC_LAST)
1661                         break;
1662         case RC_SCREEN_FONT_SANS:
1663                 if (ignore_system_lyxrc ||
1664                     sans_font_name != system_lyxrc.sans_font_name) {
1665                         os << "\\screen_font_sans \"" << sans_font_name
1666                            << "\"\n";
1667                 }
1668                 if (tag != RC_LAST)
1669                         break;
1670         case RC_SCREEN_FONT_SANS_FOUNDRY:
1671                 if (ignore_system_lyxrc ||
1672                     sans_font_foundry != system_lyxrc.sans_font_foundry) {
1673                         os << "\\screen_font_sans_foundry \"" << sans_font_foundry
1674                            << "\"\n";
1675                 }
1676                 if (tag != RC_LAST)
1677                         break;
1678         case RC_SCREEN_FONT_TYPEWRITER:
1679                 if (ignore_system_lyxrc ||
1680                     typewriter_font_name != system_lyxrc.typewriter_font_name) {
1681                         os << "\\screen_font_typewriter \""
1682                            << typewriter_font_name << "\"\n";
1683                 }
1684                 if (tag != RC_LAST)
1685                         break;
1686         case RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
1687                 if (ignore_system_lyxrc ||
1688                     typewriter_font_foundry != system_lyxrc.typewriter_font_foundry) {
1689                         os << "\\screen_font_typewriter_foundry \""
1690                            << typewriter_font_foundry << "\"\n";
1691                 }
1692                 if (tag != RC_LAST)
1693                         break;
1694
1695         case RC_SCREEN_FONT_SCALABLE:
1696                 if (ignore_system_lyxrc ||
1697                     use_scalable_fonts != system_lyxrc.use_scalable_fonts) {
1698                         os << "\\screen_font_scalable "
1699                            << convert<string>(use_scalable_fonts)
1700                            << '\n';
1701                 }
1702                 if (tag != RC_LAST)
1703                         break;
1704         case RC_SCREEN_FONT_SIZES:
1705                 if (ignore_system_lyxrc ||
1706                     font_sizes[FONT_SIZE_TINY]
1707                     != system_lyxrc.font_sizes[FONT_SIZE_TINY] ||
1708                     font_sizes[FONT_SIZE_SCRIPT]
1709                     != system_lyxrc.font_sizes[FONT_SIZE_SCRIPT] ||
1710                     font_sizes[FONT_SIZE_FOOTNOTE]
1711                     != system_lyxrc.font_sizes[FONT_SIZE_FOOTNOTE] ||
1712                     font_sizes[FONT_SIZE_SMALL]
1713                     != system_lyxrc.font_sizes[FONT_SIZE_SMALL] ||
1714                     font_sizes[FONT_SIZE_NORMAL]
1715                     != system_lyxrc.font_sizes[FONT_SIZE_NORMAL] ||
1716                     font_sizes[FONT_SIZE_LARGE]
1717                     != system_lyxrc.font_sizes[FONT_SIZE_LARGE] ||
1718                     font_sizes[FONT_SIZE_LARGER]
1719                     != system_lyxrc.font_sizes[FONT_SIZE_LARGER] ||
1720                     font_sizes[FONT_SIZE_LARGEST]
1721                     != system_lyxrc.font_sizes[FONT_SIZE_LARGEST] ||
1722                     font_sizes[FONT_SIZE_HUGE]
1723                     != system_lyxrc.font_sizes[FONT_SIZE_HUGE] ||
1724                     font_sizes[FONT_SIZE_HUGER]
1725                     != system_lyxrc.font_sizes[FONT_SIZE_HUGER]) {
1726                         os.setf(ios::fixed);
1727                         os.precision(2);
1728                         os << "\\screen_font_sizes"
1729                            << ' ' << font_sizes[FONT_SIZE_TINY]
1730                            << ' ' << font_sizes[FONT_SIZE_SCRIPT]
1731                            << ' ' << font_sizes[FONT_SIZE_FOOTNOTE]
1732                            << ' ' << font_sizes[FONT_SIZE_SMALL]
1733                            << ' ' << font_sizes[FONT_SIZE_NORMAL]
1734                            << ' ' << font_sizes[FONT_SIZE_LARGE]
1735                            << ' ' << font_sizes[FONT_SIZE_LARGER]
1736                            << ' ' << font_sizes[FONT_SIZE_LARGEST]
1737                            << ' ' << font_sizes[FONT_SIZE_HUGE]
1738                            << ' ' << font_sizes[FONT_SIZE_HUGER]
1739                            << '\n';
1740                 }
1741                 if (tag != RC_LAST)
1742                         break;
1743         case RC_FULL_SCREEN_LIMIT:
1744                 if (ignore_system_lyxrc ||
1745                     full_screen_limit != system_lyxrc.full_screen_limit) {
1746                         os << "\\fullscreen_limit "
1747                            << convert<string>(full_screen_limit)
1748                            << '\n';
1749                 }
1750                 if (tag != RC_LAST)
1751                         break;
1752         case RC_FULL_SCREEN_TOOLBARS:
1753                 if (ignore_system_lyxrc ||
1754                     full_screen_toolbars != system_lyxrc.full_screen_toolbars) {
1755                         os << "\\fullscreen_toolbars "
1756                            << convert<string>(full_screen_toolbars)
1757                            << '\n';
1758                 }
1759                 if (tag != RC_LAST)
1760                         break;
1761         case RC_FULL_SCREEN_SCROLLBAR:
1762                 if (ignore_system_lyxrc ||
1763                     full_screen_scrollbar != system_lyxrc.full_screen_scrollbar) {
1764                         os << "\\fullscreen_scrollbar "
1765                            << convert<string>(full_screen_scrollbar)
1766                            << '\n';
1767                 }
1768                 if (tag != RC_LAST)
1769                         break;
1770         case RC_FULL_SCREEN_TABBAR:
1771                 if (ignore_system_lyxrc ||
1772                     full_screen_tabbar != system_lyxrc.full_screen_tabbar) {
1773                         os << "\\fullscreen_tabbar "
1774                            << convert<string>(full_screen_tabbar)
1775                            << '\n';
1776                 }
1777                 if (tag != RC_LAST)
1778                         break;
1779         case RC_FULL_SCREEN_MENUBAR:
1780                 if (ignore_system_lyxrc ||
1781                     full_screen_menubar != system_lyxrc.full_screen_menubar) {
1782                         os << "\\fullscreen_menubar "
1783                            << convert<string>(full_screen_menubar)
1784                            << '\n';
1785                 }
1786                 if (tag != RC_LAST)
1787                         break;
1788         case RC_FULL_SCREEN_WIDTH:
1789                 if (ignore_system_lyxrc ||
1790                     full_screen_width != system_lyxrc.full_screen_width) {
1791                         os << "\\fullscreen_width "
1792                            << convert<string>(full_screen_width)
1793                            << '\n';
1794                 }
1795                 if (tag != RC_LAST)
1796                         break;
1797         case RC_OPEN_BUFFERS_IN_TABS:
1798                 if (ignore_system_lyxrc ||
1799                     open_buffers_in_tabs != system_lyxrc.open_buffers_in_tabs) {
1800                         os << "\\open_buffers_in_tabs "
1801                            << convert<string>(open_buffers_in_tabs)
1802                            << '\n';
1803                 }
1804                 if (tag != RC_LAST)
1805                         break;
1806
1807         os << "\n#\n"
1808                         << "# COLOR SECTION ###################################\n"
1809                         << "#\n\n";
1810
1811         case RC_SET_COLOR:
1812                 for (int i = 0; i < Color_ignore; ++i) {
1813                         ColorCode lc = static_cast<ColorCode>(i);
1814                         string const col = lcolor.getX11Name(lc);
1815                         if (ignore_system_lyxrc
1816                             || col != system_lcolor.getX11Name(lc)) {
1817                                 os << "\\set_color \""
1818                                    << lcolor.getLyXName(lc) << "\" \""
1819                                    << col << "\"\n";
1820                         }
1821                 }
1822                 if (tag != RC_LAST)
1823                         break;
1824
1825                 os << "\n#\n"
1826                    << "# PRINTER SECTION ###################################\n"
1827                    << "#\n\n";
1828
1829         case RC_PRINTER:
1830                 if (ignore_system_lyxrc ||
1831                     printer != system_lyxrc.printer) {
1832                         os << "\\printer \"" << printer << "\"\n";
1833                 }
1834                 if (tag != RC_LAST)
1835                         break;
1836         case RC_PRINT_ADAPTOUTPUT:
1837                 if (ignore_system_lyxrc ||
1838                     print_adapt_output != system_lyxrc.print_adapt_output) {
1839                         os << "\\print_adapt_output "
1840                            << convert<string>(print_adapt_output)
1841                            << '\n';
1842                 }
1843                 if (tag != RC_LAST)
1844                         break;
1845         case RC_PRINT_COMMAND:
1846                 if (ignore_system_lyxrc ||
1847                     print_command != system_lyxrc.print_command) {
1848                         os << "\\print_command \"" << escapeCommand(print_command) << "\"\n";
1849                 }
1850                 if (tag != RC_LAST)
1851                         break;
1852         case RC_PRINTEXSTRAOPTIONS:
1853                 if (ignore_system_lyxrc ||
1854                     print_extra_options != system_lyxrc.print_extra_options) {
1855                         os << "\\print_extra_options \"" << print_extra_options
1856                            << "\"\n";
1857                 }
1858                 if (tag != RC_LAST)
1859                         break;
1860         case RC_PRINTSPOOL_COMMAND:
1861                 if (ignore_system_lyxrc ||
1862                     print_spool_command != system_lyxrc.print_spool_command) {
1863                         os << "\\print_spool_command \"" << escapeCommand(print_spool_command)
1864                            << "\"\n";
1865                 }
1866                 if (tag != RC_LAST)
1867                         break;
1868         case RC_PRINTSPOOL_PRINTERPREFIX:
1869                 if (ignore_system_lyxrc ||
1870                     print_spool_printerprefix
1871                     != system_lyxrc.print_spool_printerprefix) {
1872                         os << "\\print_spool_printerprefix \""
1873                            << print_spool_printerprefix << "\"\n";
1874                 }
1875                 if (tag != RC_LAST)
1876                         break;
1877         case RC_PRINTEVENPAGEFLAG:
1878                 if (ignore_system_lyxrc ||
1879                     print_evenpage_flag != system_lyxrc.print_evenpage_flag) {
1880                         os << "\\print_evenpage_flag \"" << print_evenpage_flag
1881                            << "\"\n";
1882                 }
1883                 if (tag != RC_LAST)
1884                         break;
1885         case RC_PRINTODDPAGEFLAG:
1886                 if (ignore_system_lyxrc ||
1887                     print_oddpage_flag != system_lyxrc.print_oddpage_flag) {
1888                         os << "\\print_oddpage_flag \"" << print_oddpage_flag
1889                            << "\"\n";
1890                 }
1891                 if (tag != RC_LAST)
1892                         break;
1893         case RC_PRINTREVERSEFLAG:
1894                 if (ignore_system_lyxrc ||
1895                     print_reverse_flag != system_lyxrc.print_reverse_flag) {
1896                         os << "\\print_reverse_flag \"" << print_reverse_flag
1897                            << "\"\n";
1898                 }
1899                 if (tag != RC_LAST)
1900                         break;
1901         case RC_PRINTLANDSCAPEFLAG:
1902                 if (ignore_system_lyxrc ||
1903                     print_landscape_flag != system_lyxrc.print_landscape_flag) {
1904                         os << "\\print_landscape_flag \"" << print_landscape_flag
1905                            << "\"\n";
1906                 }
1907                 if (tag != RC_LAST)
1908                         break;
1909         case RC_PRINTPAGERANGEFLAG:
1910                 if (ignore_system_lyxrc ||
1911                     print_pagerange_flag != system_lyxrc.print_pagerange_flag) {
1912                         os << "\\print_pagerange_flag \"" << print_pagerange_flag
1913                            << "\"\n";
1914                 }
1915                 if (tag != RC_LAST)
1916                         break;
1917         case RC_PRINTCOPIESFLAG:
1918                 if (ignore_system_lyxrc ||
1919                     print_copies_flag != system_lyxrc.print_copies_flag) {
1920                         os << "\\print_copies_flag \"" << print_copies_flag
1921                            << "\"\n";
1922                 }
1923                 if (tag != RC_LAST)
1924                         break;
1925         case RC_PRINTCOLLCOPIESFLAG:
1926                 if (ignore_system_lyxrc ||
1927                     print_collcopies_flag
1928                     != system_lyxrc.print_collcopies_flag) {
1929                         os << "\\print_collcopies_flag \""
1930                            << print_collcopies_flag
1931                            << "\"\n";
1932                 }
1933                 if (tag != RC_LAST)
1934                         break;
1935         case RC_PRINTPAPERFLAG:
1936                 if (ignore_system_lyxrc ||
1937                     print_paper_flag != system_lyxrc.print_paper_flag) {
1938                         os << "\\print_paper_flag \"" << print_paper_flag
1939                            << "\"\n";
1940                 }
1941                 if (tag != RC_LAST)
1942                         break;
1943         case RC_PRINTPAPERDIMENSIONFLAG:
1944                 if (ignore_system_lyxrc ||
1945                     print_paper_dimension_flag
1946                     != system_lyxrc.print_paper_dimension_flag) {
1947                         os << "\\print_paper_dimension_flag \""
1948                            << print_paper_dimension_flag << "\"\n";
1949                 }
1950                 if (tag != RC_LAST)
1951                         break;
1952         case RC_PRINTTOPRINTER:
1953                 if (ignore_system_lyxrc ||
1954                     print_to_printer != system_lyxrc.print_to_printer) {
1955                         os << "\\print_to_printer \"" << print_to_printer
1956                            << "\"\n";
1957                 }
1958                 if (tag != RC_LAST)
1959                         break;
1960         case RC_PRINTTOFILE:
1961                 if (ignore_system_lyxrc ||
1962                     print_to_file != system_lyxrc.print_to_file) {
1963                         string const path = os::external_path(print_to_file);
1964                         os << "\\print_to_file \"" << path << "\"\n";
1965                 }
1966                 if (tag != RC_LAST)
1967                         break;
1968         case RC_PRINTFILEEXTENSION:
1969                 if (ignore_system_lyxrc ||
1970                     print_file_extension != system_lyxrc.print_file_extension) {
1971                         os << "\\print_file_extension \""
1972                            << print_file_extension
1973                            << "\"\n";
1974                 }
1975                 if (tag != RC_LAST)
1976                         break;
1977
1978                 os << "\n#\n"
1979                    << "# TEX SECTION #######################################\n"
1980                    << "#\n\n";
1981
1982         case RC_FONT_ENCODING:
1983                 if (ignore_system_lyxrc ||
1984                     fontenc != system_lyxrc.fontenc) {
1985                         os << "\\font_encoding \"" << fontenc << "\"\n";
1986                 }
1987                 if (tag != RC_LAST)
1988                         break;
1989
1990                 os << "\n#\n"
1991                    << "# FILE SECTION ######################################\n"
1992                    << "#\n\n";
1993
1994         case RC_DOCUMENTPATH:
1995                 if (ignore_system_lyxrc ||
1996                     document_path != system_lyxrc.document_path) {
1997                         string const path = os::external_path(document_path);
1998                         os << "\\document_path \"" << path << "\"\n";
1999                 }
2000                 if (tag != RC_LAST)
2001                         break;
2002         case RC_USELASTFILEPOS:
2003                 if (ignore_system_lyxrc ||
2004                     use_lastfilepos != system_lyxrc.use_lastfilepos) {
2005                         os << "\\use_lastfilepos " << convert<string>(use_lastfilepos)
2006                            << '\n';
2007                 }
2008                 if (tag != RC_LAST)
2009                         break;
2010         case RC_LOADSESSION:
2011                 if (ignore_system_lyxrc ||
2012                     load_session != system_lyxrc.load_session) {
2013                         os << "\\load_session " << convert<string>(load_session)
2014                            << "\n";
2015                 }
2016                 if (tag != RC_LAST)
2017                         break;
2018         case RC_MOUSE_WHEEL_SPEED:
2019                 if (ignore_system_lyxrc ||
2020                     mouse_wheel_speed != system_lyxrc.mouse_wheel_speed) {
2021                         os << "\\mouse_wheel_speed " << mouse_wheel_speed << '\n';
2022                 }
2023                 if (tag != RC_LAST)
2024                         break;
2025         case RC_COMPLETION_INLINE_DELAY:
2026                 if (ignore_system_lyxrc ||
2027                     completion_inline_delay != system_lyxrc.completion_inline_delay) {
2028                         os << "\\completion_inline_delay " << completion_inline_delay << '\n';
2029                 }
2030                 if (tag != RC_LAST)
2031                         break;
2032         case RC_COMPLETION_INLINE_MATH:
2033                 if (ignore_system_lyxrc ||
2034                     completion_inline_math != system_lyxrc.completion_inline_math) {
2035                         os << "\\completion_inline_math "
2036                                 << convert<string>(completion_inline_math) << '\n';
2037                 }
2038                 if (tag != RC_LAST)
2039                         break;
2040         case RC_COMPLETION_INLINE_TEXT:
2041                 if (ignore_system_lyxrc ||
2042                     completion_inline_text != system_lyxrc.completion_inline_text) {
2043                         os << "\\completion_inline_text "
2044                                 << convert<string>(completion_inline_text) << '\n';
2045                 }
2046                 if (tag != RC_LAST)
2047                         break;
2048         case RC_COMPLETION_INLINE_DOTS:
2049                 if (ignore_system_lyxrc ||
2050                     completion_inline_dots != system_lyxrc.completion_inline_dots) {
2051                         os << "\\completion_inline_dots "
2052                                 << convert<string>(completion_inline_dots) << '\n';
2053                 }
2054                 if (tag != RC_LAST)
2055                         break;
2056         case RC_AUTOCORRECTION_MATH:
2057                 if (ignore_system_lyxrc ||
2058                     autocorrection_math != system_lyxrc.autocorrection_math) {
2059                         os << "\\autocorrection_math "
2060                                 << convert<string>(autocorrection_math) << '\n';
2061                 }
2062                 if (tag != RC_LAST)
2063                         break;
2064         case RC_COMPLETION_POPUP_DELAY:
2065                 if (ignore_system_lyxrc ||
2066                     completion_popup_delay != system_lyxrc.completion_popup_delay) {
2067                         os << "\\completion_popup_delay " << completion_popup_delay << '\n';
2068                 }
2069                 if (tag != RC_LAST)
2070                         break;
2071         case RC_COMPLETION_POPUP_MATH:
2072                 if (ignore_system_lyxrc ||
2073                     completion_popup_math != system_lyxrc.completion_popup_math) {
2074                         os << "\\completion_popup_math "
2075                                 << convert<string>(completion_popup_math) << '\n';
2076                 }
2077                 if (tag != RC_LAST)
2078                         break;
2079         case RC_COMPLETION_POPUP_TEXT:
2080                 if (ignore_system_lyxrc ||
2081                     completion_popup_text != system_lyxrc.completion_popup_text) {
2082                         os << "\\completion_popup_text "
2083                                 << convert<string>(completion_popup_text) << '\n';
2084                 }
2085                 if (tag != RC_LAST)
2086                         break;
2087         case RC_COMPLETION_CURSOR_TEXT:
2088                 if (ignore_system_lyxrc ||
2089                     completion_cursor_text != system_lyxrc.completion_cursor_text) {
2090                         os << "\\completion_cursor_text "
2091                            << convert<string>(completion_cursor_text) << '\n';
2092                 }
2093                 if (tag != RC_LAST)
2094                         break;
2095         case RC_COMPLETION_POPUP_AFTER_COMPLETE:
2096                 if (ignore_system_lyxrc ||
2097                     completion_popup_after_complete
2098                     != system_lyxrc.completion_popup_after_complete) {
2099                         os << "\\completion_popup_after_complete "
2100                                 << convert<string>(completion_popup_after_complete) << '\n';
2101                 }
2102                 if (tag != RC_LAST)
2103                         break;
2104         case RC_NUMLASTFILES:
2105                 if (ignore_system_lyxrc ||
2106                     num_lastfiles != system_lyxrc.num_lastfiles) {
2107                         os << "\\num_lastfiles " << num_lastfiles << '\n';
2108                 }
2109                 if (tag != RC_LAST)
2110                         break;
2111         case RC_CHECKLASTFILES:
2112                 if (ignore_system_lyxrc ||
2113                     check_lastfiles != system_lyxrc.check_lastfiles) {
2114                         os << "\\check_lastfiles " << convert<string>(check_lastfiles)
2115                            << '\n';
2116                 }
2117                 if (tag != RC_LAST)
2118                         break;
2119         case RC_EXAMPLEPATH:
2120                 if (ignore_system_lyxrc ||
2121                     example_path != system_lyxrc.example_path) {
2122                         string const path = os::external_path(example_path);
2123                         os << "\\example_path \"" << path << "\"\n";
2124                 }
2125                 if (tag != RC_LAST)
2126                         break;
2127         case RC_TEMPLATEPATH:
2128                 if (ignore_system_lyxrc ||
2129                     template_path != system_lyxrc.template_path) {
2130                         string const path = os::external_path(template_path);
2131                         os << "\\template_path \"" << path << "\"\n";
2132                 }
2133                 if (tag != RC_LAST)
2134                         break;
2135         case RC_TEMPDIRPATH:
2136                 if (ignore_system_lyxrc ||
2137                     tempdir_path != system_lyxrc.tempdir_path) {
2138                         string const path = os::external_path(tempdir_path);
2139                         os << "\\tempdir_path \"" << path << "\"\n";
2140                 }
2141                 if (tag != RC_LAST)
2142                         break;
2143         case RC_THESAURUSDIRPATH:
2144                 if (ignore_system_lyxrc ||
2145                     thesaurusdir_path != system_lyxrc.thesaurusdir_path) {
2146                         string const path = os::external_path(thesaurusdir_path);
2147                         os << "\\thesaurusdir_path \"" << path << "\"\n";
2148                 }
2149                 if (tag != RC_LAST)
2150                         break;
2151         case RC_USETEMPDIR:
2152                 if (tag != RC_LAST)
2153                         break;
2154                 // Ignore it
2155         case RC_PLAINTEXT_ROFF_COMMAND: // Obsoleted in 2.0
2156                 if (tag != RC_LAST)
2157                         break;
2158         case RC_PLAINTEXT_LINELEN:
2159                 if (ignore_system_lyxrc ||
2160                     plaintext_linelen != system_lyxrc.plaintext_linelen) {
2161                         os << "\\plaintext_linelen " << plaintext_linelen << '\n';
2162                 }
2163                 if (tag != RC_LAST)
2164                         break;
2165         case RC_MAKE_BACKUP:
2166                 if (ignore_system_lyxrc ||
2167                     make_backup != system_lyxrc.make_backup) {
2168                         os << "\\make_backup " << convert<string>(make_backup) << '\n';
2169                 }
2170                 if (tag != RC_LAST)
2171                         break;
2172         case RC_BACKUPDIR_PATH:
2173                 if (ignore_system_lyxrc ||
2174                     backupdir_path != system_lyxrc.backupdir_path) {
2175                         string const path = os::external_path(backupdir_path);
2176                         os << "\\backupdir_path \"" << path << "\"\n";
2177                 }
2178                 if (tag != RC_LAST)
2179                         break;
2180
2181                 os << "\n#\n"
2182                    << "# PLAIN TEXT EXPORT SECTION ##############################\n"
2183                    << "#\n\n";
2184
2185                 os << "\n#\n"
2186                    << "# SPELLCHECKER SECTION ##############################\n"
2187                    << "#\n\n";
2188
2189         case RC_SPELL_COMMAND:
2190         case RC_USE_SPELL_LIB:
2191                 // Obsoleted in 2.0
2192                 if (tag != RC_LAST)
2193                         break;
2194         case RC_ACCEPT_COMPOUND:
2195                 if (ignore_system_lyxrc ||
2196                     spellchecker_accept_compound != system_lyxrc.spellchecker_accept_compound) {
2197                         os << "\\accept_compound " << convert<string>(spellchecker_accept_compound)
2198                            << '\n';
2199                 }
2200                 if (tag != RC_LAST)
2201                         break;
2202         case RC_USE_ALT_LANG:
2203                 if (ignore_system_lyxrc ||
2204                     spellchecker_use_alt_lang != system_lyxrc.spellchecker_use_alt_lang) {
2205                         os << "\\use_alt_language " << convert<string>(spellchecker_use_alt_lang)
2206                            << '\n';
2207                 }
2208                 if (tag != RC_LAST)
2209                         break;
2210         case RC_ALT_LANG:
2211                 if (ignore_system_lyxrc ||
2212                     spellchecker_alt_lang != system_lyxrc.spellchecker_alt_lang) {
2213                         os << "\\alternate_language \"" << spellchecker_alt_lang
2214                            << "\"\n";
2215                 }
2216                 if (tag != RC_LAST)
2217                         break;
2218         case RC_USE_ESC_CHARS:
2219                 if (ignore_system_lyxrc ||
2220                     spellchecker_use_esc_chars != system_lyxrc.spellchecker_use_esc_chars) {
2221                         os << "\\use_escape_chars " << convert<string>(spellchecker_use_esc_chars)
2222                            << '\n';
2223                 }
2224                 if (tag != RC_LAST)
2225                         break;
2226         case RC_ESC_CHARS:
2227                 if (ignore_system_lyxrc ||
2228                     spellchecker_esc_chars != system_lyxrc.spellchecker_esc_chars) {
2229                         os << "\\escape_chars \"" << spellchecker_esc_chars << "\"\n";
2230                 }
2231                 if (tag != RC_LAST)
2232                         break;
2233         case RC_USE_PERS_DICT:
2234                 if (ignore_system_lyxrc ||
2235                     spellchecker_use_pers_dict != system_lyxrc.spellchecker_use_pers_dict) {
2236                         os << "\\use_personal_dictionary "
2237                            << convert<string>(spellchecker_use_pers_dict)
2238                            << '\n';
2239                 }
2240                 if (tag != RC_LAST)
2241                         break;
2242         case RC_USE_TOOLTIP:
2243                 if (ignore_system_lyxrc ||
2244                     use_tooltip != system_lyxrc.use_tooltip) {
2245                         os << "\\use_tooltip "
2246                            << convert<string>(use_tooltip)
2247                            << '\n';
2248                 }
2249         case RC_USE_PIXMAP_CACHE:
2250                 if (ignore_system_lyxrc ||
2251                     use_pixmap_cache != system_lyxrc.use_pixmap_cache) {
2252                         os << "\\use_pixmap_cache "
2253                            << convert<string>(use_pixmap_cache)
2254                            << '\n';
2255                 }
2256         case RC_PERS_DICT:
2257                 if (spellchecker_pers_dict != system_lyxrc.spellchecker_pers_dict) {
2258                         string const path = os::external_path(spellchecker_pers_dict);
2259                         os << "\\personal_dictionary \"" << path << "\"\n";
2260                 }
2261                 if (tag != RC_LAST)
2262                         break;
2263         case RC_USE_INP_ENC:
2264                 if (ignore_system_lyxrc ||
2265                     spellchecker_use_input_encoding
2266                     != system_lyxrc.spellchecker_use_input_encoding) {
2267                         os << "\\use_input_encoding "
2268                            << convert<string>(spellchecker_use_input_encoding)
2269                            << '\n';
2270                 }
2271                 if (tag != RC_LAST)
2272                         break;
2273
2274                 os << "\n#\n"
2275                    << "# LANGUAGE SUPPORT SECTION ##########################\n"
2276                    << "#\n\n";
2277
2278         case RC_SPELLCHECK_CONTINUOUSLY:
2279                 if (ignore_system_lyxrc ||
2280                     spellcheck_continuously != system_lyxrc.spellcheck_continuously) {
2281                         os << "\\spellcheck_continuously " << convert<string>(spellcheck_continuously)
2282                            << '\n';
2283                 }
2284                 if (tag != RC_LAST)
2285                         break;
2286
2287         case RC_RTL_SUPPORT:
2288                 if (ignore_system_lyxrc ||
2289                     rtl_support != system_lyxrc.rtl_support) {
2290                         os << "\\rtl " << convert<string>(rtl_support) << '\n';
2291                 }
2292                 if (tag != RC_LAST)
2293                         break;
2294         case RC_VISUAL_CURSOR:
2295                 if (ignore_system_lyxrc ||
2296                         visual_cursor != system_lyxrc.visual_cursor) {
2297                         os << "\\visual_cursor " << convert<string>(visual_cursor) << '\n';
2298                 }
2299                 if (tag != RC_LAST)
2300                         break;
2301         case RC_LANGUAGE_PACKAGE:
2302                 if (ignore_system_lyxrc ||
2303                     language_package != system_lyxrc.language_package) {
2304                         os << "\\language_package \"" << language_package
2305                            << "\"\n";
2306                 }
2307                 if (tag != RC_LAST)
2308                         break;
2309         case RC_LANGUAGE_GLOBAL_OPTIONS:
2310                 if (ignore_system_lyxrc ||
2311                     language_global_options
2312                     != system_lyxrc.language_global_options) {
2313                         os << "\\language_global_options \""
2314                            << convert<string>(language_global_options)
2315                            << "\"\n";
2316                 }
2317                 if (tag != RC_LAST)
2318                         break;
2319         case RC_LANGUAGE_USE_BABEL:
2320                 if (ignore_system_lyxrc ||
2321                     language_use_babel != system_lyxrc.language_use_babel) {
2322                         os << "\\language_use_babel \""
2323                            << convert<string>(language_use_babel)
2324                            << "\"\n";
2325                 }
2326                 if (tag != RC_LAST)
2327                         break;
2328         case RC_LANGUAGE_COMMAND_BEGIN:
2329                 if (ignore_system_lyxrc ||
2330                     language_command_begin
2331                     != system_lyxrc.language_command_begin) {
2332                         os << "\\language_command_begin \""
2333                            << language_command_begin
2334                            << "\"\n";
2335                 }
2336                 if (tag != RC_LAST)
2337                         break;
2338         case RC_LANGUAGE_COMMAND_END:
2339                 if (ignore_system_lyxrc ||
2340                     language_command_end
2341                     != system_lyxrc.language_command_end) {
2342                         os << "\\language_command_end \"" << language_command_end
2343                            << "\"\n";
2344                 }
2345                 if (tag != RC_LAST)
2346                         break;
2347         case RC_LANGUAGE_COMMAND_LOCAL:
2348                 if (ignore_system_lyxrc ||
2349                     language_command_local
2350                     != system_lyxrc.language_command_local) {
2351                         os << "\\language_command_local \""
2352                            << language_command_local
2353                            << "\"\n";
2354                 }
2355                 if (tag != RC_LAST)
2356                         break;
2357         case RC_LANGUAGE_AUTO_BEGIN:
2358                 if (ignore_system_lyxrc ||
2359                     language_auto_begin != system_lyxrc.language_auto_begin) {
2360                         os << "\\language_auto_begin "
2361                            << convert<string>(language_auto_begin) << '\n';
2362                 }
2363                 if (tag != RC_LAST)
2364                         break;
2365         case RC_LANGUAGE_AUTO_END:
2366                 if (ignore_system_lyxrc ||
2367                     language_auto_end != system_lyxrc.language_auto_end) {
2368                         os << "\\language_auto_end "
2369                            << convert<string>(language_auto_end) << '\n';
2370                 }
2371                 if (tag != RC_LAST)
2372                         break;
2373         case RC_MARK_FOREIGN_LANGUAGE:
2374                 if (ignore_system_lyxrc ||
2375                     mark_foreign_language
2376                     != system_lyxrc.mark_foreign_language) {
2377                         os << "\\mark_foreign_language " <<
2378                                 convert<string>(mark_foreign_language) << '\n';
2379                 }
2380                 if (tag != RC_LAST)
2381                         break;
2382
2383                 os << "\n#\n"
2384                    << "# 2nd MISC SUPPORT SECTION ##########################\n"
2385                    << "#\n\n";
2386
2387         case RC_AUTO_NUMBER:
2388                 if (ignore_system_lyxrc ||
2389                     auto_number != system_lyxrc.auto_number) {
2390                         os << "\\auto_number " << convert<string>(auto_number) << '\n';
2391                 }
2392                 if (tag != RC_LAST)
2393                         break;
2394         case RC_DEFAULT_LANGUAGE:
2395                 if (ignore_system_lyxrc ||
2396                     default_language != system_lyxrc.default_language) {
2397                         os << "\\default_language " << default_language << '\n';
2398                 }
2399                 if (tag != RC_LAST)
2400                         break;
2401         case RC_GUI_LANGUAGE:
2402                 if (ignore_system_lyxrc ||
2403                     gui_language != system_lyxrc.gui_language) {
2404                         os << "\\gui_language " << gui_language << '\n';
2405                 }
2406                 if (tag != RC_LAST)
2407                         break;
2408
2409                 os << "\n#\n"
2410                    << "# FORMATS SECTION ##########################\n"
2411                    << "#\n\n";
2412
2413         case RC_FORMAT:
2414                 // New/modified formats
2415                 for (Formats::const_iterator cit = formats.begin();
2416                      cit != formats.end(); ++cit) {
2417                         Format const * format =
2418                                 system_formats.getFormat(cit->name());
2419                         if (!format ||
2420                             format->extension() != cit->extension() ||
2421                             format->prettyname() != cit->prettyname() ||
2422                             format->shortcut() != cit->shortcut() ||
2423                             format->viewer() != cit->viewer() ||
2424                             format->editor() != cit->editor() ||
2425                             format->documentFormat() != cit->documentFormat() ||
2426                             format->vectorFormat() != cit->vectorFormat()) {
2427                                 os << "\\format \"" << cit->name() << "\" \""
2428                                    << cit->extension() << "\" \""
2429                                    << cit->prettyname() << "\" \""
2430                                    << cit->shortcut() << "\" \""
2431                                    << escapeCommand(cit->viewer()) << "\" \""
2432                                    << escapeCommand(cit->editor()) << "\" \"";
2433                                 vector<string> flags;
2434                                 if (cit->documentFormat())
2435                                         flags.push_back("document");
2436                                 if (cit->vectorFormat())
2437                                         flags.push_back("vector");
2438                                 os << getStringFromVector(flags);
2439                                 os << "\"\n";
2440                         }
2441                 }
2442
2443                 // Look for deleted formats
2444                 for (Formats::const_iterator cit = system_formats.begin();
2445                      cit != system_formats.end(); ++cit)
2446                         if (!formats.getFormat(cit->name()))
2447                                 os << "\\format \"" << cit->name()
2448                                    << "\" \"\" \"\" \"\" \"\" \"\" \"\"\n";
2449                 if (tag != RC_LAST)
2450                         break;
2451         case RC_DEFAULT_VIEW_FORMAT:
2452                 if (ignore_system_lyxrc ||
2453                     default_view_format != system_lyxrc.default_view_format) {
2454                         os << "\\default_view_format " << default_view_format << '\n';
2455                 }
2456                 if (tag != RC_LAST)
2457                         break;
2458         case RC_VIEWER:
2459                 // Ignore it
2460                 if (tag != RC_LAST)
2461                         break;
2462
2463                 os << "\n#\n"
2464                    << "# CONVERTERS SECTION ##########################\n"
2465                    << "#\n\n";
2466
2467         case RC_CONVERTER:
2468                 // Look for new converters
2469                 for (Converters::const_iterator cit = theConverters().begin();
2470                      cit != theConverters().end(); ++cit) {
2471                         Converter const * converter =
2472                                 theSystemConverters().getConverter(cit->from,
2473                                                                cit->to);
2474                         if (!converter ||
2475                             converter->command != cit->command ||
2476                             converter->flags != cit->flags)
2477                                 os << "\\converter \"" << cit->from << "\" \""
2478                                    << cit->to << "\" \""
2479                                    << escapeCommand(cit->command) << "\" \""
2480                                    << cit->flags << "\"\n";
2481                 }
2482
2483                 // New/modifed converters
2484                 for (Converters::const_iterator cit = theSystemConverters().begin();
2485                      cit != theSystemConverters().end(); ++cit)
2486                         if (!theConverters().getConverter(cit->from, cit->to))
2487                                 os << "\\converter \"" << cit->from
2488                                    << "\" \"" << cit->to << "\" \"\" \"\"\n";
2489                 if (tag != RC_LAST)
2490                         break;
2491
2492         case RC_COPIER:
2493                 if (tag == RC_LAST)
2494                         os << "\n#\n"
2495                            << "# COPIERS SECTION ##########################\n"
2496                            << "#\n\n";
2497
2498                 // Look for new movers
2499                 Movers::const_iterator const sysbegin = theSystemMovers().begin();
2500                 Movers::const_iterator const sysend = theSystemMovers().end();
2501                 Movers::const_iterator it = theMovers().begin();
2502                 Movers::const_iterator end = theMovers().end();
2503
2504                 for (; it != end; ++it) {
2505                         Movers::const_iterator const sysit =
2506                                 find_if(sysbegin, sysend, SameMover(*it));
2507                         if (sysit == sysend) {
2508                                 string const & fmt = it->first;
2509                                 string const & command =
2510                                         it->second.command();
2511
2512                                 os << "\\copier " << fmt
2513                                    << " \"" << escapeCommand(command) << "\"\n";
2514                         }
2515                 }
2516                 if (tag != RC_LAST)
2517                         break;
2518
2519                 // We don't actually delete SpecialisedMover(s) from the
2520                 // map, just clear their 'command', so there's no need
2521                 // to test for anything else.
2522         }
2523
2524         os.flush();
2525 }
2526
2527
2528 #if 0
2529 string const LyXRC::getDescription(LyXRCTags tag)
2530 {
2531         docstring str;
2532
2533         switch (tag) {
2534         case RC_ACCEPT_COMPOUND:
2535                 str = _("Consider run-together words, such as \"diskdrive\" for \"disk drive\", as legal words?");
2536                 break;
2537
2538         case RC_ALT_LANG:
2539         case RC_USE_ALT_LANG:
2540                 str = _("Specify an alternate language. The default is to use the language of the document.");
2541                 break;
2542
2543         case RC_PLAINTEXT_ROFF_COMMAND:
2544                 str = _("Use to define an external program to render tables in plain text output. E.g. \"groff -t -Tlatin1 $$FName\" where $$FName is the input file. If \"\" is specified, an internal routine is used.");
2545                 break;
2546
2547         case RC_PLAINTEXT_LINELEN:
2548                 str = _("The maximum line length of exported plain text/LaTeX/SGML files. If set to 0, paragraphs are output in a single line; if the line length is > 0, paragraphs are separated by a blank line.");
2549                 break;
2550
2551         case RC_AUTOREGIONDELETE:
2552                 str = _("De-select if you don't want the current selection to be replaced automatically by what you type.");
2553                 break;
2554
2555         case RC_AUTORESET_OPTIONS:
2556                 str = _("De-select if you don't want the class options to be reset to defaults after class change.");
2557                 break;
2558
2559         case RC_AUTOSAVE:
2560                 str = _("The time interval between auto-saves (in seconds). 0 means no auto-save.");
2561                 break;
2562
2563         case RC_AUTO_NUMBER:
2564                 break;
2565
2566         case RC_BACKUPDIR_PATH:
2567                 str = _("The path for storing backup files. If it is an empty string, LyX will store the backup file in the same directory as the original file.");
2568                 break;
2569
2570         case RC_BIBTEX_COMMAND:
2571                 str = _("Define the options of bibtex (cf. man bibtex) or select an alternative compiler (e.g. mlbibtex or bibulus).");
2572                 break;
2573
2574         case RC_JBIBTEX_COMMAND:
2575                 str = _("Define the options of the bibtex program for PLaTeX (Japanese LaTeX).");
2576                 break;
2577
2578         case RC_BINDFILE:
2579                 str = _("Keybindings file. Can either specify an absolute path, or LyX will look in its global and local bind/ directories.");
2580                 break;
2581
2582         case RC_CHECKLASTFILES:
2583                 str = _("Select to check whether the lastfiles still exist.");
2584                 break;
2585
2586         case RC_CHKTEX_COMMAND:
2587                 str = _("Define how to run chktex. E.g. \"chktex -n11 -n1 -n3 -n6 -n9 -22 -n25 -n30 -n38\" Refer to the ChkTeX documentation.");
2588                 break;
2589
2590         case RC_CONVERTER:
2591                 break;
2592
2593         case RC_COPIER:
2594                 break;
2595
2596         case RC_CURSOR_FOLLOWS_SCROLLBAR:
2597                 str = _("LyX normally doesn't update the cursor position if you move the scrollbar. Set to true if you'd prefer to always have the cursor on screen.");
2598                 break;
2599
2600         case RC_SCROLL_BELOW_DOCUMENT:
2601                 str = _("LyX normally doesn't allow the user to scroll further than the bottom of the document. Set to true if you prefer to scroll the bottom of the document to the top of the screen");
2602                 break;
2603
2604         case RC_MAC_LIKE_WORD_MOVEMENT:
2605                 str = _("Use the Mac OS X conventions for the word-level cursor movement");
2606                 break;
2607
2608         case RC_SHOW_MACRO_LABEL:
2609                 str = _("Show a small box around a Math Macro with the macro name when the cursor is inside.");
2610                 break;
2611
2612         case RC_DATE_INSERT_FORMAT:
2613                 //xgettext:no-c-format
2614                 str = _("This accepts the normal strftime formats; see man strftime for full details. E.g.\"%A, %e. %B %Y\".");
2615                 break;
2616
2617         case RC_DEFFILE:
2618                 str = _("Command definition file. Can either specify an absolute path, or LyX will look in its global and local commands/ directories.");
2619                 break;
2620
2621         case RC_DEFAULT_VIEW_FORMAT:
2622                 str = _("The default format used with LFUN_BUFFER_[VIEW|UPDATE].");
2623                 break;
2624
2625         case RC_DEFAULT_LANGUAGE:
2626                 str = _("New documents will be assigned this language.");
2627                 break;
2628
2629         case RC_DEFAULT_PAPERSIZE:
2630                 str = _("Specify the default paper size.");
2631                 break;
2632
2633         case RC_DIALOGS_ICONIFY_WITH_MAIN:
2634                 str = _("Iconify the dialogs when the main window is iconified. (Affects only dialogs shown after the change has been made.)");
2635                 break;
2636
2637         case RC_DISPLAY_GRAPHICS:
2638                 str = _("Select how LyX will display any graphics.");
2639                 break;
2640
2641         case RC_DOCUMENTPATH:
2642                 str = _("The default path for your documents. An empty value selects the directory LyX was started from.");
2643                 break;
2644
2645         case RC_ESC_CHARS:
2646         case RC_USE_ESC_CHARS:
2647                 str = _("Specify additional chars that can be part of a word.");
2648                 break;
2649
2650         case RC_EXAMPLEPATH:
2651                 str = _("The path that LyX will set when offering to choose an example. An empty value selects the directory LyX was started from.");
2652                 break;
2653
2654         case RC_FONT_ENCODING:
2655                 str = _("The font encoding used for the LaTeX2e fontenc package. T1 is highly recommended for non-English languages.");
2656                 break;
2657
2658         case RC_FORMAT:
2659                 break;
2660
2661         case RC_INDEX_COMMAND:
2662                 str = _("Define the options of makeindex (cf. man makeindex) or select an alternative compiler. E.g., using xindy/make-rules, the command string would be \"makeindex.sh -m $$lang\".");
2663                 break;
2664
2665         case RC_JINDEX_COMMAND:
2666                 str = _("Define the options of the index program for PLaTeX (Japanese LaTeX).");
2667                 break;
2668
2669         case RC_NOMENCL_COMMAND:
2670                 str = _("Define the options of makeindex (cf. man makeindex) to be used for nomenclatures. This might differ from the index processing options.");
2671                 break;
2672
2673         case RC_INPUT:
2674                 break;
2675
2676         case RC_KBMAP:
2677         case RC_KBMAP_PRIMARY:
2678         case RC_KBMAP_SECONDARY:
2679                 str = _("Use this to set the correct mapping file for your keyboard. You'll need this if you for instance want to type German documents on an American keyboard.");
2680                 break;
2681
2682         case RC_LABEL_INIT_LENGTH:
2683                 str = _("Maximum number of words in the initialization string for a new label");
2684                 break;
2685
2686         case RC_LANGUAGE_AUTO_BEGIN:
2687                 str = _("Select if a language switching command is needed at the beginning of the document.");
2688                 break;
2689
2690         case RC_LANGUAGE_AUTO_END:
2691                 str = _("Select if a language switching command is needed at the end of the document.");
2692                 break;
2693
2694         case RC_LANGUAGE_COMMAND_BEGIN:
2695                 str = _("The LaTeX command for changing from the language of the document to another language. E.g. \\selectlanguage{$$lang} where $$lang is substituted by the name of the second language.");
2696                 break;
2697
2698         case RC_LANGUAGE_COMMAND_END:
2699                 str = _("The LaTeX command for changing back to the language of the document.");
2700                 break;
2701
2702         case RC_LANGUAGE_COMMAND_LOCAL:
2703                 str = _("The LaTeX command for local changing of the language.");
2704                 break;
2705
2706         case RC_LANGUAGE_GLOBAL_OPTIONS:
2707                 str = _("De-select if you don't want the language(s) used as an argument to \\documentclass.");
2708                 break;
2709
2710         case RC_LANGUAGE_PACKAGE:
2711                 str = _("The LaTeX command for loading the language package. E.g. \"\\usepackage{babel}\", \"\\usepackage{omega}\".");
2712                 break;
2713
2714         case RC_LANGUAGE_USE_BABEL:
2715                 str = _("De-select if you don't want babel to be used when the language of the document is the default language.");
2716                 break;
2717
2718         case RC_USELASTFILEPOS:
2719                 str = _("De-select if you do not want LyX to scroll to saved position.");
2720                 break;
2721
2722         case RC_LOADSESSION:
2723                 str = _("De-select to prevent loading files opened from the last LyX session.");
2724                 break;
2725
2726         case RC_MAKE_BACKUP:
2727                 str = _("De-select if you don't want LyX to create backup files.");
2728                 break;
2729
2730         case RC_MARK_FOREIGN_LANGUAGE:
2731                 str = _("Select to control the highlighting of words with a language foreign to that of the document.");
2732                 break;
2733
2734         case RC_MOUSE_WHEEL_SPEED:
2735                 str = bformat(_("The scrolling speed of the mouse wheel."),
2736                       maxlastfiles);
2737                 break;
2738
2739         case RC_COMPLETION_POPUP_DELAY:
2740                 str = _("The completion popup delay.");
2741                 break;
2742
2743         case RC_COMPLETION_POPUP_MATH:
2744                 str = _("Select to display the completion popup in math mode.");
2745                 break;
2746
2747         case RC_COMPLETION_POPUP_TEXT:
2748                 str = _("Select to display the completion popup in text mode.");
2749                 break;
2750
2751         case RC_COMPLETION_POPUP_AFTER_COMPLETE:
2752                 str = _("Show the completion popup without delay after non-unique completion attempt.");
2753                 break;
2754
2755         case RC_COMPLETION_POPUP_TEXT:
2756                 str = _("Show a small triangle on the cursor to indicate that a completion is available.");
2757                 break;
2758
2759         case RC_COMPLETION_POPUP_DELAY:
2760                 str = _("The inline completion delay.");
2761                 break;
2762
2763         case RC_COMPLETION_INLINE_MATH:
2764                 str = _("Select to display the inline completion in math mode.");
2765                 break;
2766
2767         case RC_COMPLETION_INLINE_TEXT:
2768                 str = _("Select to display the inline completion in text mode.");
2769                 break;
2770
2771         case RC_COMPLETION_INLINE_DOTS:
2772                 str = _("Use \"...\" to shorten long completions.");
2773                 break;
2774
2775         case RC_AUTOCORRECTION_MATH:
2776                 str = _("Allow TeXMacs shorthand, like => converting to \Rightarrow.");
2777                 break;
2778
2779         case RC_NUMLASTFILES:
2780                 str = bformat(_("Maximal number of lastfiles. Up to %1$d can appear in the file menu."),
2781                         maxlastfiles);
2782                 break;
2783
2784         case RC_PATH_PREFIX:
2785                 str = _("Specify those directories which should be "
2786                          "prepended to the PATH environment variable. "
2787                          "Use the OS native format.");
2788                 break;
2789
2790         case RC_PERS_DICT:
2791         case RC_USE_PERS_DICT:
2792                 str = _("Specify an alternate personal dictionary file. E.g. \".aspell_english\".");
2793                 break;
2794
2795         case RC_PREVIEW:
2796                 str = _("Shows a typeset preview of things such as math");
2797                 break;
2798
2799         case RC_PREVIEW_HASHED_LABELS:
2800                 str = _("Previewed equations will have \"(#)\" labels rather than numbered ones");
2801                 break;
2802
2803         case RC_PREVIEW_SCALE_FACTOR:
2804                 str = _("Scale the preview size to suit.");
2805                 break;
2806
2807         case RC_PRINTCOLLCOPIESFLAG:
2808                 str = _("The option for specifying whether the copies should be collated.");
2809                 break;
2810
2811         case RC_PRINTCOPIESFLAG:
2812                 str = _("The option for specifying the number of copies to print.");
2813                 break;
2814
2815         case RC_PRINTER:
2816                 str = _("The default printer to print on. If none is specified, LyX will use the environment variable PRINTER.");
2817                 break;
2818
2819         case RC_PRINTEVENPAGEFLAG:
2820                 str = _("The option to print only even pages.");
2821                 break;
2822
2823         case RC_PRINTEXSTRAOPTIONS:
2824                 str = _("Extra options to pass to printing program after everything else, but before the filename of the DVI file to be printed.");
2825                 break;
2826
2827         case RC_PRINTFILEEXTENSION:
2828                 str = _("Extension of printer program output file. Usually \".ps\".");
2829                 break;
2830
2831         case RC_PRINTLANDSCAPEFLAG:
2832                 str = _("The option to print out in landscape.");
2833                 break;
2834
2835         case RC_PRINTODDPAGEFLAG:
2836                 str = _("The option to print only odd pages.");
2837                 break;
2838
2839         case RC_PRINTPAGERANGEFLAG:
2840                 str = _("The option for specifying a comma-separated list of pages to print.");
2841                 break;
2842
2843         case RC_PRINTPAPERDIMENSIONFLAG:
2844                                    str = _("Option to specify the dimensions of the print paper.");
2845                 break;
2846
2847         case RC_PRINTPAPERFLAG:
2848                 str = _("The option to specify paper type.");
2849                 break;
2850
2851         case RC_PRINTREVERSEFLAG:
2852                 str = _("The option to reverse the order of the pages printed.");
2853                 break;
2854
2855         case RC_PRINTSPOOL_COMMAND:
2856                 str = _("When set, this printer option automatically prints to a file and then calls a separate print spooling program on that file with the given name and arguments.");
2857                 break;
2858
2859         case RC_PRINTSPOOL_PRINTERPREFIX:
2860                 str = _("If you specify a printer name in the print dialog, the following argument is prepended along with the printer name after the spool command.");
2861                 break;
2862
2863         case RC_PRINTTOFILE:
2864                 str = _("Option to pass to the print program to print to a file.");
2865                 break;
2866
2867         case RC_PRINTTOPRINTER:
2868                 str = _("Option to pass to the print program to print on a specific printer.");
2869                 break;
2870
2871         case RC_PRINT_ADAPTOUTPUT:
2872                 str = _("Select for LyX to pass the name of the destination printer to your print command.");
2873                 break;
2874
2875         case RC_PRINT_COMMAND:
2876                 str = _("Your favorite print program, e.g. \"dvips\", \"dvilj4\".");
2877                 break;
2878
2879         case RC_RTL_SUPPORT:
2880                 str = _("Select to enable support of right-to-left languages (e.g. Hebrew, Arabic).");
2881                 break;
2882
2883         case RC_VISUAL_CURSOR:
2884                 str = _("Select to have visual bidi cursor movement, unselect for logical movement.");
2885                 break;
2886
2887         case RC_SCREEN_DPI:
2888                 str = _("DPI (dots per inch) of your monitor is auto-detected by LyX. If that goes wrong, override the setting here.");
2889                 break;
2890
2891         case RC_SCREEN_FONT_ROMAN:
2892         case RC_SCREEN_FONT_SANS:
2893         case RC_SCREEN_FONT_TYPEWRITER:
2894                 str = _("The screen fonts used to display the text while editing.");
2895                 break;
2896
2897         case RC_SCREEN_FONT_ROMAN_FOUNDRY:
2898         case RC_SCREEN_FONT_SANS_FOUNDRY:
2899         case RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
2900                 break;
2901
2902         case RC_SCREEN_FONT_SCALABLE:
2903                 str = _("Allow bitmap fonts to be resized. If you are using a bitmap font, selecting this option may make some fonts look blocky in LyX. Deselecting this option makes LyX use the nearest bitmap font size available, instead of scaling.");
2904                 break;
2905
2906         case RC_SCREEN_FONT_SIZES:
2907                 str = _("The font sizes used for calculating the scaling of the screen fonts.");
2908                 break;
2909
2910         case RC_SCREEN_ZOOM:
2911                 //xgettext:no-c-format
2912                 str = _("The zoom percentage for screen fonts. A setting of 100% will make the fonts roughly the same size as on paper.");
2913                 break;
2914
2915         case RC_GEOMETRY_SESSION:
2916                 str = _("Allow session manager to save and restore windows geometry.");
2917                 break;
2918
2919         case RC_SERVERPIPE:
2920                 str = _("This starts the lyxserver. The pipes get an additional extension \".in\" and \".out\". Only for advanced users.");
2921                 break;
2922
2923         case RC_SET_COLOR:
2924                 break;
2925
2926         case RC_SHOW_BANNER:
2927                 str = _("De-select if you don't want the startup banner.");
2928                 break;
2929
2930         case RC_TEMPDIRPATH:
2931                 str = _("LyX will place its temporary directories in this path. They will be deleted when you quit LyX.");
2932                 break;
2933
2934         case RC_THESAURUSDIRPATH:
2935                 str = _("This is the place where the files of the thesaurus library reside.");
2936                 break;
2937
2938         case RC_TEMPLATEPATH:
2939                 str = _("The path that LyX will set when offering to choose a template. An empty value selects the directory LyX was started from.");
2940                 break;
2941
2942         case RC_TEX_ALLOWS_SPACES:
2943                 break;
2944
2945         case RC_TEX_EXPECTS_WINDOWS_PATHS:
2946                 break;
2947
2948         case RC_UIFILE:
2949                 str = _("The UI (user interface) file. Can either specify an absolute path, or LyX will look in its global and local ui/ directories.");
2950                 break;
2951
2952         case RC_USER_EMAIL:
2953                 break;
2954
2955         case RC_USER_NAME:
2956                 break;
2957
2958         case RC_USETEMPDIR:
2959                 break;
2960
2961         case RC_USE_INP_ENC:
2962                 str = _("Specify whether to pass the -T input encoding option to aspell. Enable this if you cannot check the spelling of words containing accented letters. This may not work with all dictionaries.");
2963                 break;
2964
2965         case RC_USE_TOOLTIP:
2966                 str = _("Enable the automatic appearance of tool tips in the work area.");
2967                 break;
2968
2969         case RC_USE_PIXMAP_CACHE:
2970                 str = _("Enable the pixmap cache that might improve performance on Mac and Windows.");
2971                 break;
2972
2973         case RC_USE_SPELL_LIB:
2974                 break;
2975
2976         case RC_VIEWDVI_PAPEROPTION:
2977                 _("Specify the paper command to DVI viewer (leave empty or use \"-paper\")");
2978                 break;
2979
2980         case RC_VIEWER:
2981                 break;
2982
2983         case RC_LAST:
2984                 break;
2985         }
2986
2987         return str;
2988 }
2989 #endif
2990
2991
2992 // The global instance
2993 LyXRC lyxrc;
2994
2995 // The global copy of the system lyxrc entries (everything except preferences)
2996 LyXRC system_lyxrc;
2997
2998
2999 } // namespace lyx