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