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