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