src/LyXRC.cpp

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