src/frontends/xforms/FormPreferences.C

   1 /**
   2  * \file FormPreferences.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "FormPreferences.h"
  14 #include "forms/form_preferences.h"
  15
  16 #include "FormColorpicker.h"
  17 #include "forms_gettext.h"
  18 #include "input_validators.h"
  19 #include "xformsBC.h"
  20 #include "xforms_helpers.h"
  21
  22 #include "controllers/ControlPrefs.h"
  23 #include "controllers/frnt_lang.h"
  24 #include "controllers/helper_funcs.h" // getSecond
  25
  26 #include "buffer.h"
  27 #include "lastfiles.h"
  28 #include "LColor.h"
  29 #include "lyxfont.h"
  30
  31 #include "support/convert.h"
  32 #include "support/lstrings.h"
  33 #include "support/package.h"
  34 #include "support/filetools.h"
  35
  36 #include "lyx_forms.h"
  37 #include "combox.h"
  38
  39 #include <iomanip>
  40
  41 using std::endl;
  42 using std::make_pair;
  43 using std::max;
  44 using std::min;
  45
  46 using std::pair;
  47 using std::vector;
  48 using std::string;
  49
  50 namespace lyx {
  51
  52 using support::AddName;
  53 using support::ChangeExtension;
  54 using support::package;
  55 using support::rtrim;
  56 using support::trim;
  57
  58 namespace frontend {
  59
  60 namespace {
  61
  62 string makeFontName(string const & family, string const & foundry)
  63 {
  64         if (foundry.empty())
  65                 return family;
  66         return family + ',' + foundry;
  67 }
  68
  69
  70 pair<string,string> parseFontName(string const & name)
  71 {
  72         string::size_type const idx = name.find(',');
  73         if (idx == string::npos)
  74                 return make_pair(name, string());
  75         return make_pair(name.substr(0, idx),
  76                          name.substr(idx+1));
  77 }
  78
  79
  80
  81 #if FL_VERSION == 0 || (FL_REVISION == 0 && FL_FIXLEVEL < 2)
  82 bool const scalableTabfolders = false;
  83 #else
  84 bool const scalableTabfolders = true;
  85 #endif
  86
  87 } // namespace anon
  88
  89
  90 typedef FormController<ControlPrefs, FormView<FD_preferences> > base_class;
  91
  92
  93 FormPreferences::FormPreferences(Dialog & parent)
  94         : base_class(parent, _("Preferences"), scalableTabfolders),
  95           colors_(*this), converters_(*this), copiers_(*this),
  96           formats_(*this), identity_(*this), inputs_misc_(*this),
  97           interface_(*this), language_(*this), lnf_misc_(*this),
  98           outputs_misc_(*this), paths_(*this), printer_(*this),
  99           screen_fonts_(*this), spelloptions_(*this)
 100 {}
 101
 102
 103 void FormPreferences::redraw()
 104 {
 105         if (!(form() && form()->visible))
 106                 return;
 107         fl_redraw_form(form());
 108
 109         FL_FORM * form2 = fl_get_active_folder(dialog_->tabfolder_prefs);
 110         if (!(form2 && form2->visible))
 111                 return;
 112         fl_redraw_form(form2);
 113
 114         FL_FORM * form3 = 0;
 115         if (form2 == converters_tab_->form)
 116                 form3 = fl_get_active_folder(converters_tab_->tabfolder_inner);
 117
 118         else if (form2 == look_n_feel_tab_->form)
 119                 form3 = fl_get_active_folder(look_n_feel_tab_->tabfolder_inner);
 120
 121         else if (form2 == inputs_tab_->form)
 122                 form3 = fl_get_active_folder(inputs_tab_->tabfolder_inner);
 123
 124         else if (form2 == outputs_tab_->form)
 125                 form3 = fl_get_active_folder(outputs_tab_->tabfolder_inner);
 126
 127         else if (form2 == lang_opts_tab_->form)
 128                 form3 = fl_get_active_folder(lang_opts_tab_->tabfolder_inner);
 129
 130         if (form3 && form3->visible)
 131                 fl_redraw_form(form3);
 132 }
 133
 134
 135 void FormPreferences::hide()
 136 {
 137         // We need to hide the active tabfolder otherwise we get a
 138         // BadDrawable error from X window and LyX crashes without saving.
 139         FL_FORM * inner_form = fl_get_active_folder(dialog_->tabfolder_prefs);
 140         if (inner_form && inner_form->visible)
 141                 fl_hide_form(inner_form);
 142         FormDialogView::hide();
 143 }
 144
 145
 146 void FormPreferences::build()
 147 {
 148         dialog_.reset(build_preferences(this));
 149
 150         // Manage the restore, save, apply and cancel/close buttons
 151         bcview().setOK(dialog_->button_ok);
 152         bcview().setApply(dialog_->button_apply);
 153         bcview().setCancel(dialog_->button_close);
 154         bcview().setRestore(dialog_->button_restore);
 155
 156         // Allow the base class to control messages
 157         setMessageWidget(dialog_->text_warning);
 158
 159         // build the tab folders
 160         converters_tab_.reset(build_preferences_inner_tab(this));
 161         look_n_feel_tab_.reset(build_preferences_inner_tab(this));
 162         inputs_tab_.reset(build_preferences_inner_tab(this));
 163         outputs_tab_.reset(build_preferences_inner_tab(this));
 164         lang_opts_tab_.reset(build_preferences_inner_tab(this));
 165
 166         // build actual tabfolder contents
 167         // these will become nested tabfolders
 168         colors_.build();
 169         converters_.build();
 170         copiers_.build();
 171         formats_.build();
 172         inputs_misc_.build();
 173         interface_.build();
 174         language_.build();
 175         lnf_misc_.build();
 176         identity_.build();
 177         outputs_misc_.build();
 178         paths_.build();
 179         printer_.build();
 180         screen_fonts_.build();
 181         spelloptions_.build();
 182
 183         // Enable the tabfolders to be rescaled correctly.
 184         if (scalableTabfolders) {
 185                 FL_OBJECT * folder = dialog_->tabfolder_prefs;
 186                 fl_set_tabfolder_autofit(folder, FL_FIT);
 187
 188                 folder = look_n_feel_tab_->tabfolder_inner;
 189                 fl_set_tabfolder_autofit(folder, FL_FIT);
 190
 191                 folder = converters_tab_->tabfolder_inner;
 192                 fl_set_tabfolder_autofit(folder, FL_FIT);
 193
 194                 folder = inputs_tab_->tabfolder_inner;
 195                 fl_set_tabfolder_autofit(folder, FL_FIT);
 196
 197                 folder = outputs_tab_->tabfolder_inner;
 198                 fl_set_tabfolder_autofit(folder, FL_FIT);
 199
 200                 folder = lang_opts_tab_->tabfolder_inner;
 201                 fl_set_tabfolder_autofit(folder, FL_FIT);
 202         }
 203
 204         // Stack tabs
 205         // Now add them to the tabfolder
 206         fl_addto_tabfolder(dialog_->tabfolder_prefs,
 207                            _("Look & Feel").c_str(),
 208                            look_n_feel_tab_->form);
 209         fl_addto_tabfolder(dialog_->tabfolder_prefs,
 210                            _("Lang Opts").c_str(),
 211                            lang_opts_tab_->form);
 212         fl_addto_tabfolder(dialog_->tabfolder_prefs,
 213                            _("Conversion").c_str(),
 214                            converters_tab_->form);
 215         fl_addto_tabfolder(dialog_->tabfolder_prefs,
 216                            _("Inputs").c_str(),
 217                            inputs_tab_->form);
 218         fl_addto_tabfolder(dialog_->tabfolder_prefs,
 219                            _("Outputs").c_str(),
 220                            outputs_tab_->form);
 221
 222         // now build the nested tabfolders
 223         // Starting with look and feel
 224         fl_addto_tabfolder(look_n_feel_tab_->tabfolder_inner,
 225                            _("Screen Fonts").c_str(),
 226                            screen_fonts_.dialog()->form);
 227         fl_addto_tabfolder(look_n_feel_tab_->tabfolder_inner,
 228                            _("Interface").c_str(),
 229                            interface_.dialog()->form);
 230         fl_addto_tabfolder(look_n_feel_tab_->tabfolder_inner,
 231                            _("Colors").c_str(),
 232                            colors_.dialog()->form);
 233         fl_addto_tabfolder(look_n_feel_tab_->tabfolder_inner,
 234                            _("Misc").c_str(),
 235                            lnf_misc_.dialog()->form);
 236         fl_addto_tabfolder(look_n_feel_tab_->tabfolder_inner,
 237                            _("Identity").c_str(),
 238                            identity_.dialog()->form);
 239
 240         // then build converters
 241         fl_addto_tabfolder(converters_tab_->tabfolder_inner,
 242                            _("Formats").c_str(),
 243                            formats_.dialog()->form);
 244         fl_addto_tabfolder(converters_tab_->tabfolder_inner,
 245                            _("Converters").c_str(),
 246                            converters_.dialog()->form);
 247         fl_addto_tabfolder(converters_tab_->tabfolder_inner,
 248                            _("Copiers").c_str(),
 249                            copiers_.dialog()->form);
 250
 251         // then build inputs
 252         // Paths should probably go in a few inner_tab called Files
 253         fl_addto_tabfolder(inputs_tab_->tabfolder_inner,
 254                            _("Paths").c_str(),
 255                            paths_.dialog()->form);
 256         fl_addto_tabfolder(inputs_tab_->tabfolder_inner,
 257                            _("Misc").c_str(),
 258                            inputs_misc_.dialog()->form);
 259
 260         // then building outputs
 261         fl_addto_tabfolder(outputs_tab_->tabfolder_inner,
 262                            _("Printer").c_str(),
 263                            printer_.dialog()->form);
 264         fl_addto_tabfolder(outputs_tab_->tabfolder_inner,
 265                            _("Misc").c_str(),
 266                            outputs_misc_.dialog()->form);
 267
 268         // then building usage
 269         fl_addto_tabfolder(lang_opts_tab_->tabfolder_inner,
 270                            _("Spell checker").c_str(),
 271                            spelloptions_.dialog()->form);
 272         fl_addto_tabfolder(lang_opts_tab_->tabfolder_inner,
 273                            _("Language").c_str(),
 274                            language_.dialog()->form);
 275 }
 276
 277
 278 void FormPreferences::apply()
 279 {
 280         // set the new lyxrc entries
 281         // many of these need to trigger other functions when the assignment
 282         // is made.  For example, screen zoom and font types.  These could be
 283         // handled either by signals/slots in lyxrc or just directly call the
 284         // associated functions here.
 285         // There are other problems with this scheme.  We really should check
 286         // what we copy to make sure that it really is necessary to do things
 287         // like update the screen fonts because that flushes the textcache
 288         // and other stuff which may cost us a lot on slower/high-load
 289         // machines.
 290
 291         LyXRC & rc(controller().rc());
 292
 293         colors_.apply();
 294         inputs_misc_.apply(rc);
 295         interface_.apply(rc);
 296         language_.apply(rc);
 297         lnf_misc_.apply(rc);
 298         identity_.apply(rc);
 299         outputs_misc_.apply(rc);
 300         paths_.apply(rc);
 301         printer_.apply(rc);
 302         screen_fonts_.apply(rc);
 303         spelloptions_.apply(rc);
 304
 305         // The "Save" button has been pressed.
 306         if (dialog().isClosing() && colors_.modifiedXformsPrefs) {
 307                 string const filename =
 308                         AddName(package().user_support(), "preferences.xform");
 309                 colors_.modifiedXformsPrefs = !XformsColor::write(filename);
 310         }
 311 }
 312
 313
 314 string const FormPreferences::getFeedback(FL_OBJECT * ob)
 315 {
 316         BOOST_ASSERT(ob);
 317
 318         if (ob->form->fdui == colors_.dialog())
 319                 return colors_.feedback(ob);
 320         if (ob->form->fdui == converters_.dialog())
 321                 return converters_.feedback(ob);
 322         if (ob->form->fdui == copiers_.dialog())
 323                 return copiers_.feedback(ob);
 324         if (ob->form->fdui == formats_.dialog())
 325                 return formats_.feedback(ob);
 326         if (ob->form->fdui == inputs_misc_.dialog())
 327                 return inputs_misc_.feedback(ob);
 328         if (ob->form->fdui == interface_.dialog())
 329                 return interface_.feedback(ob);
 330         if (ob->form->fdui == language_.dialog())
 331                 return language_.feedback(ob);
 332         if (ob->form->fdui == lnf_misc_.dialog())
 333                 return lnf_misc_.feedback(ob);
 334         if (ob->form->fdui == outputs_misc_.dialog())
 335                 return outputs_misc_.feedback(ob);
 336         if (ob->form->fdui == paths_.dialog())
 337                 return paths_.feedback(ob);
 338         if (ob->form->fdui == printer_.dialog())
 339                 return printer_.feedback(ob);
 340         if (ob->form->fdui == screen_fonts_.dialog())
 341                 return screen_fonts_.feedback(ob);
 342         if (ob->form->fdui == spelloptions_.dialog())
 343                 return spelloptions_.feedback(ob);
 344
 345         return string();
 346 }
 347
 348
 349 ButtonPolicy::SMInput FormPreferences::input(FL_OBJECT * ob, long)
 350 {
 351         BOOST_ASSERT(ob);
 352
 353         bool valid = true;
 354
 355         // whatever checks you need to ensure the user hasn't entered
 356         // some totally ridiculous value somewhere.  Change activate to suit.
 357         // comments before each test describe what is _valid_
 358
 359         if (ob->form->fdui == colors_.dialog()) {
 360                 colors_.input(ob);
 361         } else if (ob->form->fdui == converters_.dialog()) {
 362                 valid = converters_.input(ob);
 363         } else if (ob->form->fdui == copiers_.dialog()) {
 364                 valid = copiers_.input(ob);
 365         } else if (ob->form->fdui == formats_.dialog()) {
 366                 valid = formats_.input(ob);
 367         } else if  (ob->form->fdui == interface_.dialog()) {
 368                 valid = interface_.input(ob);
 369         } else if  (ob->form->fdui == language_.dialog()) {
 370                 valid = language_.input(ob);
 371         } else if  (ob->form->fdui == paths_.dialog()) {
 372                 valid = paths_.input(ob);
 373         } else if  (ob->form->fdui == screen_fonts_.dialog()) {
 374                 valid = screen_fonts_.input();
 375         } else if  (ob->form->fdui == spelloptions_.dialog()) {
 376                 valid = spelloptions_.input(ob);
 377         }
 378
 379         return valid ? ButtonPolicy::SMI_VALID : ButtonPolicy::SMI_INVALID;
 380 }
 381
 382
 383 void FormPreferences::update()
 384 {
 385         if (!dialog_.get()) return;
 386
 387         LyXRC const & rc(controller().rc());
 388
 389         // read lyxrc entries
 390         colors_.update();
 391         formats_.update();   // Must be before converters_.update()
 392         converters_.update();
 393         copiers_.update();
 394         inputs_misc_.update(rc);
 395         interface_.update(rc);
 396         language_.update(rc);
 397         lnf_misc_.update(rc);
 398         identity_.update(rc);
 399         outputs_misc_.update(rc);
 400         paths_.update(rc);
 401         printer_.update(rc);
 402         screen_fonts_.update(rc);
 403         spelloptions_.update(rc);
 404 }
 405
 406
 407 FormPreferences::Colors::Colors(FormPreferences & p)
 408         : modifiedXformsPrefs(false), parent_(p)
 409 {}
 410
 411
 412 FD_preferences_colors const * FormPreferences::Colors::dialog()
 413 {
 414         return dialog_.get();
 415 }
 416
 417
 418 void FormPreferences::Colors::apply()
 419 {
 420         bool modifiedText = false;
 421         bool modifiedBackground = false;
 422
 423         for (vector<XformsColor>::const_iterator cit = xformsColorDB.begin();
 424              cit != xformsColorDB.end(); ++cit) {
 425                 RGBColor col;
 426                 fl_getmcolor(cit->colorID, &col.r, &col.g, &col.b);
 427                 if (col != cit->color()) {
 428                         modifiedXformsPrefs = true;
 429                         if (cit->colorID == FL_BLACK)
 430                                 modifiedText = true;
 431                         if (cit->colorID == FL_COL1)
 432                                 modifiedBackground = true;
 433                 }
 434         }
 435
 436         if (modifiedXformsPrefs) {
 437                 for (vector<XformsColor>::const_iterator cit =
 438                              xformsColorDB.begin();
 439                      cit != xformsColorDB.end(); ++cit) {
 440                         fl_mapcolor(cit->colorID, cit->r, cit->g, cit->b);
 441
 442                         if (modifiedText && cit->colorID == FL_BLACK) {
 443                                 AdjustVal(FL_INACTIVE, FL_BLACK, 0.5);
 444                         }
 445
 446                         if (modifiedBackground && cit->colorID == FL_COL1) {
 447                                 AdjustVal(FL_MCOL,      FL_COL1, 0.1);
 448                                 AdjustVal(FL_TOP_BCOL,  FL_COL1, 0.1);
 449                                 AdjustVal(FL_LEFT_BCOL, FL_COL1, 0.1);
 450
 451                                 AdjustVal(FL_RIGHT_BCOL,  FL_COL1, -0.5);
 452                                 AdjustVal(FL_BOTTOM_BCOL, FL_COL1, -0.5);
 453                         }
 454
 455                         if (cit->colorID == GUI_COLOR_CURSOR) {
 456                                 fl_mapcolor(GUI_COLOR_CURSOR,
 457                                             cit->r, cit->g, cit->b);
 458                                 setCursorColor(GUI_COLOR_CURSOR);
 459                         }
 460                 }
 461                 parent_.controller().redrawGUI();
 462         }
 463
 464         // Now do the same for the LyX LColors...
 465         for (vector<NamedColor>::const_iterator cit = lyxColorDB.begin();
 466              cit != lyxColorDB.end(); ++cit) {
 467                 LColor::color lc = lcolor.getFromLyXName(cit->lyxname);
 468                 if (lc == LColor::inherit) continue;
 469
 470                 // Create a valid X11 name of the form "#rrggbb"
 471                 string const hexname = X11hexname(cit->color());
 472
 473                 if (lcolor.getX11Name(lc) != hexname) {
 474                         lyxerr[Debug::GUI]
 475                                 << "FormPreferences::Colors::apply: "
 476                                 << "resetting LColor " << lcolor.getGUIName(lc)
 477                                 << " from \"" << lcolor.getX11Name(lc)
 478                                 << "\" to \"" << hexname << "\"."
 479                                 << endl;
 480
 481                         parent_.controller().setColor(lc, hexname);
 482                 }
 483         }
 484 }
 485
 486
 487 void FormPreferences::Colors::build()
 488 {
 489         picker_.reset(new FormColorpicker);
 490         dialog_.reset(build_preferences_colors(&parent_));
 491
 492         fl_set_object_color(dialog_->button_color,
 493                             GUI_COLOR_CHOICE, GUI_COLOR_CHOICE);
 494
 495         // set up the feedback mechanism
 496         setPrehandler(dialog_->browser_lyx_objs);
 497         setPrehandler(dialog_->button_color);
 498         setPrehandler(dialog_->button_modify);
 499 }
 500
 501
 502 string const
 503 FormPreferences::Colors::feedback(FL_OBJECT const * const ob) const
 504 {
 505         if (ob == dialog_->browser_lyx_objs)
 506                 return _("LyX objects that can be assigned a color.");
 507
 508         if (ob == dialog_->button_modify)
 509                 return _("Modify the LyX object's color. Note: you must then \"Apply\" the change.");
 510
 511         return string();
 512 }
 513
 514
 515 void FormPreferences::Colors::input(FL_OBJECT const * const ob)
 516 {
 517         if (ob == dialog_->browser_lyx_objs) {
 518                 InputBrowserLyX();
 519
 520         } else if (ob == dialog_->button_modify) {
 521                 Modify();
 522         }
 523 }
 524
 525
 526 void FormPreferences::Colors::AdjustVal(int colAdjust, int colParent,
 527                                         double addVal) const
 528 {
 529         RGBColor rgb;
 530         fl_getmcolor(colParent, &rgb.r, &rgb.g, &rgb.b);
 531
 532         HSVColor hsv(rgb);
 533         hsv.v += addVal;
 534         hsv.v = min(1.0, max(0.0, hsv.v));
 535
 536         rgb = RGBColor(hsv);
 537         fl_mapcolor(colAdjust, rgb.r, rgb.g, rgb.b);
 538 }
 539
 540
 541 void FormPreferences::Colors::InputBrowserLyX() const
 542 {
 543         vector<NamedColor>::size_type const selLyX =
 544                 fl_get_browser(dialog_->browser_lyx_objs);
 545         if (selLyX < 1) return;
 546
 547         // Is the choice an Xforms color...
 548         RGBColor col;
 549
 550         if (selLyX - 1 < xformsColorDB.size()) {
 551                 vector<XformsColor>::size_type const i = selLyX - 1;
 552                 col = xformsColorDB[i].color();
 553         }
 554         // or a LyX Logical color?
 555         else {
 556                 vector<NamedColor>::size_type const i = selLyX - 1 -
 557                         xformsColorDB.size();
 558                 col = lyxColorDB[i].color();
 559         }
 560
 561         fl_freeze_form(dialog_->form);
 562
 563         fl_mapcolor(GUI_COLOR_CHOICE, col.r, col.g, col.b);
 564         fl_redraw_object(dialog_->button_color);
 565
 566         fl_unfreeze_form(dialog_->form);
 567 }
 568
 569
 570 void FormPreferences::Colors::LoadBrowserLyX()
 571 {
 572         if (!dialog_->browser_lyx_objs->visible)
 573                 return;
 574
 575         // First, define the modifiable xforms colors
 576         xformsColorDB.clear();
 577         XformsColor xcol;
 578
 579         xcol.lyxname = "GUI background";
 580         xcol.guiname = _("GUI background");
 581         xcol.colorID = FL_COL1;
 582         fl_getmcolor(FL_COL1, &xcol.r, &xcol.g, &xcol.b);
 583
 584         xformsColorDB.push_back(xcol);
 585
 586         xcol.lyxname = "GUI text";
 587         xcol.guiname = _("GUI text");
 588         xcol.colorID = FL_BLACK;
 589         fl_getmcolor(FL_BLACK, &xcol.r, &xcol.g, &xcol.b);
 590
 591         xformsColorDB.push_back(xcol);
 592
 593         xcol.lyxname = "GUI selection";
 594         xcol.guiname = _("GUI selection");
 595         xcol.colorID = FL_YELLOW;
 596         fl_getmcolor(FL_YELLOW, &xcol.r, &xcol.g, &xcol.b);
 597
 598         xformsColorDB.push_back(xcol);
 599
 600         xcol.lyxname = "GUI pointer";
 601         xcol.guiname = _("GUI pointer");
 602         xcol.colorID = GUI_COLOR_CURSOR;
 603         fl_getmcolor(GUI_COLOR_CURSOR, &xcol.r, &xcol.g, &xcol.b);
 604
 605         xformsColorDB.push_back(xcol);
 606
 607         // Now create the the LyX LColors database
 608         lyxColorDB.clear();
 609         for (int i=0; i<LColor::ignore; ++i) {
 610                 LColor::color lc = static_cast<LColor::color>(i);
 611                 if (lc == LColor::none
 612                     || lc == LColor::black
 613                     || lc == LColor::white
 614                     || lc == LColor::red
 615                     || lc == LColor::green
 616                     || lc == LColor::blue
 617                     || lc == LColor::cyan
 618                     || lc == LColor::magenta
 619                     || lc == LColor::yellow
 620                     || lc == LColor::inherit
 621                     || lc == LColor::ignore) continue;
 622
 623                 RGBColor col;
 624                 bool const success = getRGBColor(lc, col.r, col.g, col.b);
 625                 if (!success) {
 626                         lyxerr << "FormPreferences::Colors::LoadBrowserLyX:\n"
 627                                << "LColor " << lcolor.getLyXName(lc)
 628                                << ": X can't find color \""
 629                                << lcolor.getX11Name(lc)
 630                                << "\". Set to \"black\"!" << endl;
 631
 632                         string const arg = lcolor.getLyXName(lc) + " black";
 633                         parent_.controller().setColor(lc, "black");
 634                         continue;
 635                 }
 636
 637                 // Create a valid X11 name of the form "#rrggbb" and change the
 638                 // LColor X11name to this. Don't want to trigger a redraw,
 639                 // as we're just changing the name not the RGB values.
 640                 // Also reset the system_lcolor names, so that we don't output
 641                 // unnecessary changes.
 642                 string const hexname = X11hexname(col);
 643
 644                 if (lcolor.getX11Name(lc) != hexname) {
 645                         lcolor.setColor(lc, hexname);
 646                         system_lcolor.setColor(lc, hexname);
 647                 }
 648
 649                 // Finally, push the color onto the database
 650                 NamedColor ncol(lcolor.getLyXName(lc), lcolor.getGUIName(lc), col);
 651                 lyxColorDB.push_back(ncol);
 652         }
 653
 654         // Now construct the browser
 655         FL_OBJECT * colbr = dialog_->browser_lyx_objs;
 656         fl_freeze_form(dialog_->form);
 657         fl_clear_browser(colbr);
 658         for (vector<XformsColor>::const_iterator cit = xformsColorDB.begin();
 659              cit != xformsColorDB.end(); ++cit) {
 660                 fl_addto_browser(colbr, cit->guiname.c_str());
 661         }
 662         for (vector<NamedColor>::const_iterator cit = lyxColorDB.begin();
 663              cit != lyxColorDB.end(); ++cit) {
 664                 fl_addto_browser(colbr, cit->guiname.c_str());
 665         }
 666
 667         // just to be safe...
 668         fl_set_browser_topline(dialog_->browser_lyx_objs, 1);
 669         fl_select_browser_line(dialog_->browser_lyx_objs, 1);
 670         fl_unfreeze_form(dialog_->form);
 671
 672         InputBrowserLyX();
 673 }
 674
 675
 676 void FormPreferences::Colors::Modify()
 677 {
 678         vector<NamedColor>::size_type const selLyX =
 679                 fl_get_browser(dialog_->browser_lyx_objs);
 680         if (selLyX < 1)
 681                 return;
 682
 683         RGBColor before;
 684         fl_getmcolor(GUI_COLOR_CHOICE, &before.r, &before.g, &before.b);
 685
 686         RGBColor col = picker_->requestColor(before);
 687         if (before == col)
 688                 return;
 689
 690         fl_mapcolor(GUI_COLOR_CHOICE, col.r, col.g, col.b);
 691         fl_redraw_object(dialog_->button_color);
 692
 693         // Is the choice an Xforms color...
 694         if (selLyX - 1 < xformsColorDB.size()) {
 695                 vector<XformsColor>::size_type const i = selLyX - 1;
 696                 xformsColorDB[i].r  = col.r;
 697                 xformsColorDB[i].g  = col.g;
 698                 xformsColorDB[i].b  = col.b;
 699         }
 700         // or a LyX Logical color?
 701         else {
 702                 vector<NamedColor>::size_type const i = selLyX - 1 -
 703                         xformsColorDB.size();
 704                 lyxColorDB[i].r  = col.r;
 705                 lyxColorDB[i].g  = col.g;
 706                 lyxColorDB[i].b  = col.b;
 707         }
 708 }
 709
 710
 711 FormPreferences::Converters::Converters(FormPreferences & p)
 712         : parent_(p)
 713 {}
 714
 715
 716 FD_preferences_converters const * FormPreferences::Converters::dialog()
 717 {
 718         return dialog_.get();
 719 }
 720
 721
 722 ::Converters & FormPreferences::Converters::converters()
 723 {
 724         return parent_.controller().converters();
 725 }
 726
 727
 728 ::Formats & FormPreferences::Converters::formats()
 729 {
 730         return parent_.controller().formats();
 731 }
 732
 733
 734 void FormPreferences::Converters::build()
 735 {
 736         dialog_.reset(build_preferences_converters(&parent_));
 737
 738         fl_set_input_return(dialog_->input_converter, FL_RETURN_CHANGED);
 739         fl_set_input_return(dialog_->input_flags, FL_RETURN_CHANGED);
 740
 741         // set up the feedback mechanism
 742         setPrehandler(dialog_->browser_all);
 743         setPrehandler(dialog_->button_delete);
 744         setPrehandler(dialog_->button_add);
 745         setPrehandler(dialog_->input_converter);
 746         setPrehandler(dialog_->choice_from);
 747         setPrehandler(dialog_->choice_to);
 748         setPrehandler(dialog_->input_flags);
 749 }
 750
 751
 752 string const
 753 FormPreferences::Converters::feedback(FL_OBJECT const * const ob) const
 754 {
 755         if (ob == dialog_->browser_all)
 756                 return _("All explicitly defined converters for LyX");
 757
 758         if (ob == dialog_->choice_from)
 759                 return _("Convert \"from\" this format");
 760
 761         if (ob == dialog_->choice_to)
 762                 return _("Convert \"to\" this format");
 763
 764         if (ob == dialog_->input_converter)
 765                 return _("The conversion command. $$i is the input file name, "
 766                          "$$b is the file name without its extension and $$o "
 767                          "is the name of the output file. $$s can be used "
 768                          "as the path to LyX's support directory.");
 769
 770         if (ob == dialog_->input_flags)
 771                 return _("Extra information for the Converter class, whether and "
 772                          "how to parse the result, and various other things.");
 773
 774         if (ob == dialog_->button_delete)
 775                 return _("Remove the current converter from the list of available "
 776                          "converters. Note: you must then \"Apply\" the change.");
 777
 778         if (ob == dialog_->button_add) {
 779                 if (string(ob->label) == _("Add"))
 780                         return _("Add the current converter to the list of available "
 781                                  "converters. Note: you must then \"Apply\" the change.");
 782                 else
 783                         return _("Modify the contents of the current converter. "
 784                                  "Note: you must then \"Apply\" the change.");
 785         }
 786
 787         return string();
 788 }
 789
 790
 791 bool FormPreferences::Converters::input(FL_OBJECT const * const ob)
 792 {
 793         if (ob == dialog_->browser_all)
 794                 return Browser();
 795
 796         if (ob == dialog_->choice_from
 797             || ob == dialog_->choice_to
 798             || ob == dialog_->input_converter
 799             || ob == dialog_->input_flags)
 800                 return Input();
 801
 802         if (ob == dialog_->button_add)
 803                 return Add();
 804
 805         if (ob == dialog_->button_delete)
 806                 return erase();
 807
 808         return true;
 809 }
 810
 811
 812 void FormPreferences::Converters::update()
 813 {
 814         UpdateBrowser();
 815 }
 816
 817
 818 void FormPreferences::Converters::UpdateBrowser()
 819 {
 820         converters().sort();
 821
 822         fl_freeze_form(dialog_->form);
 823         fl_clear_browser(dialog_->browser_all);
 824         for (::Converters::const_iterator cit = converters().begin();
 825              cit != converters().end(); ++cit) {
 826                 string const name = cit->From->prettyname() + " -> "
 827                         + cit->To->prettyname();
 828                 fl_addto_browser(dialog_->browser_all, name.c_str());
 829         }
 830         Input();
 831         fl_unfreeze_form(dialog_->form);
 832 }
 833
 834
 835 bool FormPreferences::Converters::Add()
 836 {
 837         string const from = GetFrom();
 838         string const to = GetTo();
 839         string const command = getString(dialog_->input_converter);
 840         string const flags = getString(dialog_->input_flags);
 841
 842         Converter const * old = converters().getConverter(from, to);
 843         converters().add(from, to, command, flags);
 844         if (!old) {
 845                 converters().updateLast(formats());
 846                 UpdateBrowser();
 847         }
 848         setEnabled(dialog_->button_add, false);
 849
 850         return true;
 851 }
 852
 853
 854 bool FormPreferences::Converters::Browser()
 855 {
 856         int const i = fl_get_browser(dialog_->browser_all);
 857         if (i <= 0) return false;
 858
 859         fl_freeze_form(dialog_->form);
 860
 861         Converter const & c = converters().get(i - 1);
 862         int j = formats().getNumber(c.from);
 863         if (j >= 0)
 864                 fl_set_choice(dialog_->choice_from, j + 1);
 865
 866         j = formats().getNumber(c.to);
 867         if (j >= 0)
 868                 fl_set_choice(dialog_->choice_to, j + 1);
 869
 870         fl_set_input(dialog_->input_converter, c.command.c_str());
 871         fl_set_input(dialog_->input_flags, c.flags.c_str());
 872
 873         fl_set_object_label(dialog_->button_add, idex(_("Modify|#M")).c_str());
 874         fl_set_button_shortcut(dialog_->button_add,
 875                                scex(_("Modify|#M")).c_str(), 1);
 876
 877         setEnabled(dialog_->button_add,    false);
 878         setEnabled(dialog_->button_delete, true);
 879
 880         fl_unfreeze_form(dialog_->form);
 881         return false;
 882 }
 883
 884
 885 bool FormPreferences::Converters::erase()
 886 {
 887         string const from = GetFrom();
 888         string const to = GetTo();
 889
 890         converters().erase(from, to);
 891         UpdateBrowser();
 892         return true;
 893 }
 894
 895
 896 bool FormPreferences::Converters::Input()
 897 {
 898         string const from = GetFrom();
 899         string const to = GetTo();
 900         int const sel = converters().getNumber(from, to);
 901
 902         fl_freeze_form(dialog_->form);
 903
 904         if (sel < 0) {
 905                 fl_set_object_label(dialog_->button_add,
 906                                     idex(_("Add|#A")).c_str());
 907                 fl_set_button_shortcut(dialog_->button_add,
 908                                        scex(_("Add|#A")).c_str(), 1);
 909
 910                 fl_deselect_browser(dialog_->browser_all);
 911                 setEnabled(dialog_->button_delete, false);
 912
 913         } else {
 914                 fl_set_object_label(dialog_->button_add,
 915                                     idex(_("Modify|#M")).c_str());
 916                 fl_set_button_shortcut(dialog_->button_add,
 917                                        scex(_("Modify|#M")).c_str(), 1);
 918
 919                 int top = max(sel-5, 0);
 920                 fl_set_browser_topline(dialog_->browser_all, top);
 921                 fl_select_browser_line(dialog_->browser_all, sel+1);
 922                 setEnabled(dialog_->button_delete, true);
 923         }
 924
 925         string const command = rtrim(getString(dialog_->input_converter));
 926         bool const enable = !(command.empty() || from == to);
 927         setEnabled(dialog_->button_add, enable);
 928
 929         fl_unfreeze_form(dialog_->form);
 930         return false;
 931 }
 932
 933
 934 string const FormPreferences::Converters::GetFrom()
 935 {
 936         ::Formats::FormatList::size_type const i =
 937                   fl_get_choice(dialog_->choice_from);
 938
 939         if (i > 0 && i <= formats().size())
 940                 return formats().get(i - 1).name();
 941
 942         lyxerr << "FormPreferences::Converters::GetFrom: No choice!" << endl;
 943         return "???";
 944 }
 945
 946
 947 string const FormPreferences::Converters::GetTo()
 948 {
 949         ::Formats::FormatList::size_type const i =
 950                   fl_get_choice(dialog_->choice_to);
 951
 952         if (i > 0 && i <= formats().size())
 953                 return formats().get(i - 1).name();
 954
 955         lyxerr << "FormPreferences::Converters::GetTo: No choice!" << endl;
 956         return "???";
 957 }
 958
 959
 960 void FormPreferences::Converters::UpdateChoices()
 961 {
 962         string choice;
 963         for (::Formats::const_iterator cit = formats().begin();
 964              cit != formats().end(); ++cit) {
 965                 if (!choice.empty())
 966                         choice += " | ";
 967                 else
 968                         choice += ' ';
 969                 choice += cit->prettyname();
 970         }
 971         choice += ' ';
 972
 973         fl_clear_choice(dialog_->choice_from);
 974         fl_addto_choice(dialog_->choice_from, choice.c_str());
 975
 976         fl_clear_choice(dialog_->choice_to);
 977         fl_addto_choice(dialog_->choice_to, choice.c_str());
 978 }
 979
 980
 981 FormPreferences::Copiers::Copiers(FormPreferences & p)
 982         : parent_(p)
 983 {}
 984
 985
 986 FD_preferences_copiers const * FormPreferences::Copiers::dialog()
 987 {
 988         return dialog_.get();
 989 }
 990
 991
 992 ::Movers & FormPreferences::Copiers::movers()
 993 {
 994         return parent_.controller().movers();
 995 }
 996
 997
 998 void FormPreferences::Copiers::build()
 999 {
1000         dialog_.reset(build_preferences_copiers(&parent_));
1001
1002         fl_set_input_return(dialog_->input_copier, FL_RETURN_CHANGED);
1003
1004         // set up the feedback mechanism
1005         setPrehandler(dialog_->browser_all);
1006         setPrehandler(dialog_->button_delete);
1007         setPrehandler(dialog_->button_add);
1008         setPrehandler(dialog_->choice_format);
1009         setPrehandler(dialog_->input_copier);
1010 }
1011
1012
1013 string const
1014 FormPreferences::Copiers::feedback(FL_OBJECT const * const ob) const
1015 {
1016         if (ob == dialog_->browser_all)
1017                 return _("All explicitly defined copiers for LyX");
1018
1019         if (ob == dialog_->choice_format)
1020                 return _("Copier for this format");
1021
1022         if (ob == dialog_->input_copier)
1023
1024                 return _("The command used to copy the file. "
1025                          "$$i is the \"from\" file name and "
1026                          "$$o is the \"to\" file name.\n"
1027                          "$$s can be used as the path to LyX's support "
1028                          "directory.");
1029
1030         if (ob == dialog_->button_delete)
1031                 return _("Remove the current copier from the list of available "
1032                          "copiers. Note: you must then \"Apply\" the change.");
1033
1034         if (ob == dialog_->button_add) {
1035                 if (string(ob->label) == _("Add"))
1036                         return _("Add the current copier to the list of available "
1037                                  "copiers. Note: you must then \"Apply\" the change.");
1038                 else
1039                         return _("Modify the contents of the current copier. "
1040                                  "Note: you must then \"Apply\" the change.");
1041         }
1042
1043         return string();
1044 }
1045
1046
1047 bool FormPreferences::Copiers::input(FL_OBJECT const * const ob)
1048 {
1049         if (ob == dialog_->browser_all)
1050                 return Browser();
1051
1052         if (ob == dialog_->choice_format
1053             || ob == dialog_->input_copier)
1054                 return Input();
1055
1056         if (ob == dialog_->button_add)
1057                 return Add();
1058
1059         if (ob == dialog_->button_delete)
1060                 return Erase();
1061
1062         return true;
1063 }
1064
1065
1066 void FormPreferences::Copiers::update()
1067 {
1068         // Build data for the browser widget
1069         Movers::iterator const begin = movers().begin();
1070         Movers::iterator const end = movers().end();
1071
1072         vector<string> fmts;
1073         fmts.reserve(std::distance(begin, end));
1074         for (Movers::iterator it = begin; it != end; ++it) {
1075                 std::string const & command = it->second.command();
1076                 if (command.empty())
1077                         continue;
1078                 std::string const & fmt = it->first;
1079                 fmts.push_back(::formats.prettyName(fmt));
1080         }
1081
1082         std::sort(fmts.begin(), fmts.end());
1083
1084         // Build data for the choice widget
1085         string choice;
1086         for (::Formats::const_iterator it = ::formats.begin();
1087              it != ::formats.end(); ++it) {
1088                 if (!choice.empty())
1089                         choice += " | ";
1090                 else
1091                         choice += ' ';
1092                 choice += it->prettyname();
1093         }
1094         choice += ' ';
1095
1096         // The input widget
1097         fl_freeze_form(dialog_->form);
1098         fl_set_input(dialog_->input_copier, "");
1099
1100         // The browser widget
1101         fl_clear_browser(dialog_->browser_all);
1102
1103         vector<string>::const_iterator it = fmts.begin();
1104         vector<string>::const_iterator const fmts_end = fmts.end();
1105         for (; it != fmts_end; ++it)
1106                 fl_addto_browser(dialog_->browser_all, it->c_str());
1107
1108         // The choice widget
1109         fl_clear_choice(dialog_->choice_format);
1110         fl_addto_choice(dialog_->choice_format, choice.c_str());
1111         fl_set_choice(dialog_->choice_format, 1);
1112
1113         Input();
1114         fl_unfreeze_form(dialog_->form);
1115 }
1116
1117
1118 namespace {
1119
1120 struct SamePrettyName {
1121         SamePrettyName(string const & n) : pretty_name_(n) {}
1122
1123         bool operator()(::Format const & fmt) const {
1124                 return fmt.prettyname() == pretty_name_;
1125         }
1126
1127 private:
1128         string const pretty_name_;
1129 };
1130
1131
1132 ::Format const * getFormat(std::string const & prettyname)
1133 {
1134         ::Formats::const_iterator it = ::formats.begin();
1135         ::Formats::const_iterator const end = ::formats.end();
1136         it = std::find_if(it, end, SamePrettyName(prettyname));
1137         return it == end ? 0 : &*it;
1138 }
1139
1140 } // namespace anon
1141
1142
1143 bool FormPreferences::Copiers::Add()
1144 {
1145         ::Format const * fmt = getFormat(getString(dialog_->choice_format));
1146         if (fmt == 0)
1147                 return false;
1148
1149         string const command = getString(dialog_->input_copier);
1150         if (command.empty())
1151                 return false;
1152
1153         fl_freeze_form(dialog_->form);
1154
1155         movers().set(fmt->name(), command);
1156         update();
1157         setEnabled(dialog_->button_add, false);
1158
1159         fl_unfreeze_form(dialog_->form);
1160         return true;
1161 }
1162
1163
1164 bool FormPreferences::Copiers::Browser()
1165 {
1166         int const i = fl_get_browser(dialog_->browser_all);
1167         if (i <= 0) return false;
1168
1169         ::Format const * fmt = getFormat(getString(dialog_->browser_all, i));
1170         if (fmt == 0)
1171                 return false;
1172
1173         string const & fmt_name = fmt->name();
1174         string const & gui_name = fmt->prettyname();
1175         string const & command = movers().command(fmt_name);
1176
1177         fl_freeze_form(dialog_->form);
1178
1179         int const choice_size = fl_get_choice_maxitems(dialog_->choice_format);
1180         for (int i = 1; i <= choice_size; ++i) {
1181                 char const * const c_str =
1182                         fl_get_choice_item_text(dialog_->choice_format, i);
1183                 string const line = c_str ? trim(c_str) : string();
1184                 if (line == gui_name) {
1185                         fl_set_choice(dialog_->choice_format, i);
1186                         break;
1187                 }
1188         }
1189
1190         fl_set_input(dialog_->input_copier, command.c_str());
1191
1192         fl_set_object_label(dialog_->button_add, idex(_("Modify|#M")).c_str());
1193         fl_set_button_shortcut(dialog_->button_add,
1194                                scex(_("Modify|#M")).c_str(), 1);
1195
1196         setEnabled(dialog_->button_add,    false);
1197         setEnabled(dialog_->button_delete, true);
1198
1199         fl_unfreeze_form(dialog_->form);
1200         return false;
1201 }
1202
1203
1204 bool FormPreferences::Copiers::Erase()
1205 {
1206         ::Format const * fmt = getFormat(getString(dialog_->choice_format));
1207         if (fmt == 0)
1208                 return false;
1209
1210         string const & fmt_name = fmt->name();
1211
1212         movers().set(fmt_name, string());
1213         update();
1214         return true;
1215 }
1216
1217
1218 bool FormPreferences::Copiers::Input()
1219 {
1220         ::Format const * fmt = getFormat(getString(dialog_->choice_format));
1221         if (fmt == 0)
1222                 return false;
1223
1224         string const & gui_name = fmt->prettyname();
1225         string const command = getString(dialog_->input_copier);
1226
1227         fl_freeze_form(dialog_->form);
1228         fl_deselect_browser(dialog_->browser_all);
1229         bool found_line = false;
1230         int const browser_size = fl_get_browser_maxline(dialog_->browser_all);
1231         for (int i = 1; i <= browser_size; ++i) {
1232                 char const * const c_str =
1233                         fl_get_browser_line(dialog_->browser_all, i);
1234                 string const line = c_str ? trim(c_str) : string();
1235                 if (line == gui_name) {
1236                         fl_select_browser_line(dialog_->browser_all, i);
1237                         int top = max(i-5, 1);
1238                         fl_set_browser_topline(dialog_->browser_all, top);
1239                         found_line = true;
1240                         break;
1241                 }
1242         }
1243
1244         if (!found_line) {
1245                 fl_set_object_label(dialog_->button_add,
1246                                     idex(_("Add|#A")).c_str());
1247                 fl_set_button_shortcut(dialog_->button_add,
1248                                        scex(_("Add|#A")).c_str(), 1);
1249
1250                 setEnabled(dialog_->button_delete, false);
1251         } else {
1252                 fl_set_object_label(dialog_->button_add,
1253                                     idex(_("Modify|#M")).c_str());
1254                 fl_set_button_shortcut(dialog_->button_add,
1255                                        scex(_("Modify|#M")).c_str(), 1);
1256
1257                 setEnabled(dialog_->button_delete, true);
1258         }
1259
1260         setEnabled(dialog_->button_add, !command.empty());
1261
1262         fl_unfreeze_form(dialog_->form);
1263         return false;
1264 }
1265
1266
1267 FormPreferences::Formats::Formats(FormPreferences &  p)
1268         : parent_(p)
1269 {}
1270
1271
1272 FD_preferences_formats const * FormPreferences::Formats::dialog()
1273 {
1274         return dialog_.get();
1275 }
1276
1277
1278 ::Converters & FormPreferences::Formats::converters()
1279 {
1280         return parent_.controller().converters();
1281 }
1282
1283
1284 ::Formats & FormPreferences::Formats::formats()
1285 {
1286         return parent_.controller().formats();
1287 }
1288
1289
1290 void FormPreferences::Formats::build()
1291 {
1292         dialog_.reset(build_preferences_formats(&parent_));
1293
1294         fl_set_input_return(dialog_->input_format, FL_RETURN_CHANGED);
1295         fl_set_input_return(dialog_->input_viewer, FL_RETURN_CHANGED);
1296         fl_set_input_return(dialog_->input_editor, FL_RETURN_CHANGED);
1297         fl_set_input_return(dialog_->input_shrtcut, FL_RETURN_CHANGED);
1298         fl_set_input_return(dialog_->input_gui_name, FL_RETURN_CHANGED);
1299         fl_set_input_return(dialog_->input_extension, FL_RETURN_CHANGED);
1300
1301         fl_set_input_filter(dialog_->input_format, fl_lowercase_filter);
1302
1303         // set up the feedback mechanism
1304         setPrehandler(dialog_->browser_all);
1305         setPrehandler(dialog_->input_format);
1306         setPrehandler(dialog_->input_gui_name);
1307         setPrehandler(dialog_->button_delete);
1308         setPrehandler(dialog_->button_add);
1309         setPrehandler(dialog_->input_extension);
1310         setPrehandler(dialog_->input_viewer);
1311         setPrehandler(dialog_->input_editor);
1312         setPrehandler(dialog_->input_shrtcut);
1313 }
1314
1315
1316 string const
1317 FormPreferences::Formats::feedback(FL_OBJECT const * const ob) const
1318 {
1319         if (ob == dialog_->browser_all)
1320                 return  _("All the currently defined formats known to LyX.");
1321
1322         if (ob == dialog_->input_format)
1323                 return  _("The format identifier.");
1324
1325         if (ob == dialog_->input_gui_name)
1326                 return  _("The format name as it will appear in the menus.");
1327
1328         if (ob == dialog_->input_shrtcut)
1329                 return  _("The keyboard accelerator. Use a letter in the GUI name. "
1330                           "Case sensitive.");
1331
1332         if (ob == dialog_->input_extension)
1333                 return  _("Used to recognize the file. E.g., ps, pdf, tex.");
1334
1335         if (ob == dialog_->input_viewer)
1336                 return  _("The command used to launch the viewer application.");
1337
1338         if (ob == dialog_->input_editor)
1339                 return  _("The command used to launch the editor application.");
1340
1341         if (ob == dialog_->button_delete)
1342                 return  _("Remove the current format from the list of available "
1343                           "formats. Note: you must then \"Apply\" the change.");
1344
1345         if (ob == dialog_->button_add) {
1346                 if (string(ob->label) == _("Add"))
1347                         return  _("Add the current format to the list of available "
1348                                   "formats. Note: you must then \"Apply\" the change.");
1349                 else
1350                         return  _("Modify the contents of the current format. Note: "
1351                                   "you must then \"Apply\" the change.");
1352         }
1353
1354         return string();
1355 }
1356
1357
1358 bool FormPreferences::Formats::input(FL_OBJECT const * const ob)
1359 {
1360         if (ob == dialog_->browser_all)
1361                 return Browser();
1362
1363         if (ob == dialog_->input_format
1364             || ob == dialog_->input_gui_name
1365             || ob == dialog_->input_shrtcut
1366             || ob == dialog_->input_extension
1367             || ob == dialog_->input_viewer
1368             || ob == dialog_->input_editor)
1369                 return Input();
1370
1371         if (ob == dialog_->button_add)
1372                 return Add();
1373
1374         if (ob == dialog_->button_delete)
1375                 return erase();
1376
1377         return false;
1378 }
1379
1380
1381 void FormPreferences::Formats::update()
1382 {
1383         UpdateBrowser();
1384 }
1385
1386
1387 void FormPreferences::Formats::UpdateBrowser()
1388 {
1389         formats().sort();
1390
1391         fl_freeze_form(dialog_->form);
1392         fl_deselect_browser(dialog_->browser_all);
1393         fl_clear_browser(dialog_->browser_all);
1394         for (::Formats::const_iterator cit = formats().begin();
1395              cit != formats().end(); ++cit)
1396                 fl_addto_browser(dialog_->browser_all,
1397                                  cit->prettyname().c_str());
1398
1399         Input();
1400         fl_unfreeze_form(dialog_->form);
1401
1402         // Mustn't forget to update the Formats available to the converters_
1403         parent_.converters_.UpdateChoices();
1404         converters().update(formats());
1405 }
1406
1407
1408 bool FormPreferences::Formats::Add()
1409 {
1410         string const name = getString(dialog_->input_format);
1411         string const prettyname = getString(dialog_->input_gui_name);
1412         string const extension = getString(dialog_->input_extension);
1413         string const shortcut =  getString(dialog_->input_shrtcut);
1414         string const viewer =  getString(dialog_->input_viewer);
1415         string const editor =  getString(dialog_->input_editor);
1416
1417         Format const * old = formats().getFormat(name);
1418         string const old_prettyname = old ? old->prettyname() : string();
1419         formats().add(name, extension, prettyname, shortcut, viewer, editor);
1420         if (!old || prettyname != old_prettyname) {
1421                 UpdateBrowser();
1422                 if (old)
1423                         parent_.converters_.UpdateBrowser();
1424         }
1425         setEnabled(dialog_->button_add, false);
1426
1427         return true;
1428 }
1429
1430
1431 bool FormPreferences::Formats::Browser()
1432 {
1433         int const i = fl_get_browser(dialog_->browser_all);
1434         if (i <= 0)
1435                 return false;
1436
1437         fl_freeze_form(dialog_->form);
1438
1439         Format const & f = formats().get(i - 1);
1440
1441         fl_set_input(dialog_->input_format, f.name().c_str());
1442         fl_set_input(dialog_->input_gui_name, f.prettyname().c_str());
1443         fl_set_input(dialog_->input_shrtcut, f.shortcut().c_str());
1444         fl_set_input(dialog_->input_extension, f.extension().c_str());
1445         fl_set_input(dialog_->input_viewer, f.viewer().c_str());
1446         fl_set_input(dialog_->input_editor, f.editor().c_str());
1447
1448         fl_set_object_label(dialog_->button_add,
1449                             idex(_("Modify|#M")).c_str());
1450         fl_set_button_shortcut(dialog_->button_add,
1451                                scex(_("Modify|#M")).c_str(), 1);
1452
1453         setEnabled(dialog_->button_add,    false);
1454         setEnabled(dialog_->button_delete, true);
1455
1456         fl_unfreeze_form(dialog_->form);
1457         return false;
1458 }
1459
1460
1461 bool FormPreferences::Formats::erase()
1462 {
1463         string const name = getString(dialog_->input_format);
1464
1465         if (converters().formatIsUsed(name)) {
1466                 parent_.postWarning(_("Cannot remove a Format used by a Converter. "
1467                                       "Remove the converter first."));
1468                 setEnabled(dialog_->button_delete, false);
1469                 return false;
1470         }
1471
1472         formats().erase(name);
1473         UpdateBrowser();
1474         return true;
1475 }
1476
1477
1478 bool FormPreferences::Formats::Input()
1479 {
1480         string const name = getString(dialog_->input_format);
1481         int const sel = formats().getNumber(name);
1482         fl_freeze_form(dialog_->form);
1483
1484         if (sel < 0) {
1485                 fl_set_object_label(dialog_->button_add,
1486                                     idex(_("Add|#A")).c_str());
1487                 fl_set_button_shortcut(dialog_->button_add,
1488                                        scex(_("Add|#A")).c_str(), 1);
1489
1490                 fl_deselect_browser(dialog_->browser_all);
1491                 setEnabled(dialog_->button_delete, false);
1492
1493         } else {
1494                 fl_set_object_label(dialog_->button_add,
1495                                     idex(_("Modify|#M")).c_str());
1496                 fl_set_button_shortcut(dialog_->button_add,
1497                                        scex(_("Modify|#M")).c_str(), 1);
1498
1499                 int const top = max(sel-5, 0);
1500                 fl_set_browser_topline(dialog_->browser_all, top);
1501                 fl_select_browser_line(dialog_->browser_all, sel+1);
1502
1503                 setEnabled(dialog_->button_add, true);
1504                 setEnabled(dialog_->button_delete, true);
1505         }
1506
1507         string const prettyname = getString(dialog_->input_gui_name);
1508         bool const enable = !(name.empty() || prettyname.empty());
1509         setEnabled(dialog_->button_add, enable);
1510
1511         fl_unfreeze_form(dialog_->form);
1512         return false;
1513 }
1514
1515
1516 FormPreferences::Identity::Identity(FormPreferences & p)
1517         : parent_(p)
1518 {}
1519
1520
1521 FD_preferences_identity const * FormPreferences::Identity::dialog()
1522 {
1523         return dialog_.get();
1524 }
1525
1526
1527 void FormPreferences::Identity::apply(LyXRC & rc) const
1528 {
1529         rc.user_name = getString(dialog_->input_user_name);
1530         rc.user_email = getString(dialog_->input_user_email);
1531 }
1532
1533
1534 void FormPreferences::Identity::build()
1535 {
1536         dialog_.reset(build_preferences_identity(&parent_));
1537         fl_set_input_return(dialog_->input_user_name, FL_RETURN_CHANGED);
1538         fl_set_input_return(dialog_->input_user_email, FL_RETURN_CHANGED);
1539 }
1540
1541
1542 void FormPreferences::Identity::update(LyXRC const & rc)
1543 {
1544         fl_set_input(dialog_->input_user_name, rc.user_name.c_str());
1545         fl_set_input(dialog_->input_user_email, rc.user_email.c_str());
1546 }
1547
1548
1549 FormPreferences::InputsMisc::InputsMisc(FormPreferences &  p)
1550         : parent_(p)
1551 {}
1552
1553
1554 FD_preferences_inputs_misc const * FormPreferences::InputsMisc::dialog()
1555 {
1556         return dialog_.get();
1557 }
1558
1559
1560 void FormPreferences::InputsMisc::apply(LyXRC & rc) const
1561 {
1562         rc.date_insert_format =
1563                 getString(dialog_->input_date_format);
1564 }
1565
1566
1567 void FormPreferences::InputsMisc::build()
1568 {
1569         dialog_.reset(build_preferences_inputs_misc(&parent_));
1570
1571         fl_set_input_return(dialog_->input_date_format, FL_RETURN_CHANGED);
1572
1573         // set up the feedback mechanism
1574         setPrehandler(dialog_->input_date_format);
1575 }
1576
1577
1578 string const
1579 FormPreferences::InputsMisc::feedback(FL_OBJECT const * const ob) const
1580 {
1581         if (ob == dialog_->input_date_format)
1582                 return LyXRC::getDescription(LyXRC::RC_DATE_INSERT_FORMAT);
1583         return string();
1584 }
1585
1586
1587 void FormPreferences::InputsMisc::update(LyXRC const & rc)
1588 {
1589         fl_set_input(dialog_->input_date_format,
1590                      rc.date_insert_format.c_str());
1591 }
1592
1593
1594 FormPreferences::Interface::Interface(FormPreferences &  p)
1595         : parent_(p)
1596 {}
1597
1598
1599 FD_preferences_interface const * FormPreferences::Interface::dialog()
1600 {
1601         return dialog_.get();
1602 }
1603
1604
1605 void FormPreferences::Interface::apply(LyXRC & rc) const
1606 {
1607         rc.popup_normal_font =
1608                 getString(dialog_->input_popup_normal_font);
1609         rc.popup_bold_font = getString(dialog_->input_popup_bold_font);
1610         rc.popup_font_encoding =
1611                 getString(dialog_->input_popup_font_encoding);
1612         rc.bind_file = getString(dialog_->input_bind_file);
1613         rc.ui_file = getString(dialog_->input_ui_file);
1614 }
1615
1616
1617 void FormPreferences::Interface::build()
1618 {
1619         dialog_.reset(build_preferences_interface(&parent_));
1620
1621         fl_set_input_return(dialog_->input_popup_normal_font, FL_RETURN_CHANGED);
1622         fl_set_input_return(dialog_->input_popup_bold_font, FL_RETURN_CHANGED);
1623         fl_set_input_return(dialog_->input_popup_font_encoding, FL_RETURN_CHANGED);
1624         fl_set_input_return(dialog_->input_bind_file, FL_RETURN_CHANGED);
1625         fl_set_input_return(dialog_->input_ui_file, FL_RETURN_CHANGED);
1626
1627         // set up the feedback mechanism
1628         setPrehandler(dialog_->input_popup_normal_font);
1629         setPrehandler(dialog_->input_popup_bold_font);
1630         setPrehandler(dialog_->input_popup_font_encoding);
1631         setPrehandler(dialog_->input_bind_file);
1632         setPrehandler(dialog_->button_bind_file_browse);
1633         setPrehandler(dialog_->input_ui_file);
1634         setPrehandler(dialog_->button_ui_file_browse);
1635 }
1636
1637
1638 string const
1639 FormPreferences::Interface::feedback(FL_OBJECT const * const ob) const
1640 {
1641         if (ob == dialog_->input_popup_normal_font)
1642                 return LyXRC::getDescription(LyXRC::RC_POPUP_NORMAL_FONT);
1643         if (ob == dialog_->input_popup_bold_font)
1644                 return LyXRC::getDescription(LyXRC::RC_POPUP_BOLD_FONT);
1645         if (ob == dialog_->input_popup_font_encoding)
1646                 return LyXRC::getDescription(LyXRC::RC_POPUP_FONT_ENCODING);
1647         if (ob == dialog_->input_bind_file)
1648                 return LyXRC::getDescription(LyXRC::RC_BINDFILE);
1649         if (ob == dialog_->input_ui_file)
1650                 return LyXRC::getDescription(LyXRC::RC_UIFILE);
1651         return string();
1652 }
1653
1654
1655 bool FormPreferences::Interface::input(FL_OBJECT const * const ob)
1656 {
1657         if (ob == dialog_->button_bind_file_browse) {
1658                 string f = parent_.controller().browsebind(
1659                         getString(dialog_->input_bind_file));
1660
1661                 fl_set_input(dialog_->input_bind_file, f.c_str());
1662         } else if (ob == dialog_->button_ui_file_browse) {
1663                 string f = parent_.controller().browseUI(
1664                         getString(dialog_->input_ui_file));
1665
1666                 fl_set_input(dialog_->input_ui_file, f.c_str());
1667         }
1668
1669         return true;
1670 }
1671
1672
1673 void FormPreferences::Interface::update(LyXRC const & rc)
1674 {
1675         fl_set_input(dialog_->input_popup_normal_font,
1676                      rc.popup_normal_font.c_str());
1677         fl_set_input(dialog_->input_popup_bold_font,
1678                      rc.popup_bold_font.c_str());
1679         fl_set_input(dialog_->input_popup_font_encoding,
1680                      rc.popup_font_encoding.c_str());
1681         fl_set_input(dialog_->input_bind_file,
1682                      rc.bind_file.c_str());
1683         fl_set_input(dialog_->input_ui_file,
1684                      rc.ui_file.c_str());
1685 }
1686
1687
1688 FormPreferences::Language::Language(FormPreferences &  p)
1689         : parent_(p)
1690 {}
1691
1692
1693 FD_preferences_language const * FormPreferences::Language::dialog()
1694 {
1695         return dialog_.get();
1696 }
1697
1698
1699 void FormPreferences::Language::apply(LyXRC & rc)
1700 {
1701         int const pos = fl_get_combox(dialog_->combox_default_lang);
1702         rc.default_language = lang_[pos-1];
1703
1704         int button = fl_get_button(dialog_->check_use_kbmap);
1705         string const name_1 = getString(dialog_->input_kbmap1);
1706         string const name_2 = getString(dialog_->input_kbmap2);
1707         if (button)
1708                 button = !(name_1.empty() && name_2.empty());
1709         rc.use_kbmap = static_cast<bool>(button);
1710
1711         if (rc.use_kbmap) {
1712                 rc.primary_kbmap = name_1;
1713                 rc.secondary_kbmap = name_2;
1714         }
1715
1716         button = fl_get_button(dialog_->check_rtl_support);
1717         rc.rtl_support = static_cast<bool>(button);
1718
1719         button = fl_get_button(dialog_->check_mark_foreign);
1720         rc.mark_foreign_language = static_cast<bool>(button);
1721
1722         button = fl_get_button(dialog_->check_auto_begin);
1723         rc.language_auto_begin = static_cast<bool>(button);
1724
1725         button = fl_get_button(dialog_->check_auto_end);
1726         rc.language_auto_end = static_cast<bool>(button);
1727
1728         button = fl_get_button(dialog_->check_use_babel);
1729         rc.language_use_babel = static_cast<bool>(button);
1730
1731         button = fl_get_button(dialog_->check_global_options);
1732         rc.language_global_options = static_cast<bool>(button);
1733
1734         rc.language_package = getString(dialog_->input_package);
1735         rc.language_command_begin = getString(dialog_->input_command_begin);
1736         rc.language_command_end = getString(dialog_->input_command_end);
1737
1738         // Ensure that all is self-consistent.
1739         update(rc);
1740 }
1741
1742
1743 void FormPreferences::Language::build()
1744 {
1745         dialog_.reset(build_preferences_language(&parent_));
1746
1747         fl_set_input_return(dialog_->input_package, FL_RETURN_CHANGED);
1748         fl_set_input_return(dialog_->input_command_begin, FL_RETURN_CHANGED);
1749         fl_set_input_return(dialog_->input_command_end, FL_RETURN_CHANGED);
1750
1751         // Store the lang identifiers for later
1752         vector<LanguagePair> const langs = getLanguageData(false);
1753         lang_ = getSecond(langs);
1754
1755         FL_OBJECT * obj = dialog_->combox_default_lang;
1756         vector<LanguagePair>::const_iterator lit  = langs.begin();
1757         vector<LanguagePair>::const_iterator lend = langs.end();
1758         for (; lit != lend; ++lit) {
1759                 fl_addto_combox(obj, lit->first.c_str());
1760         }
1761         fl_set_combox_browser_height(obj, 400);
1762
1763         // set up the feedback mechanism
1764         setPrehandler(dialog_->input_package);
1765         setPrehandler(dialog_->check_use_kbmap);
1766         setPrehandler(dialog_->combox_default_lang);
1767         setPrehandler(dialog_->input_kbmap1);
1768         setPrehandler(dialog_->input_kbmap2);
1769         setPrehandler(dialog_->check_rtl_support);
1770         setPrehandler(dialog_->check_mark_foreign);
1771         setPrehandler(dialog_->check_auto_begin);
1772         setPrehandler(dialog_->check_auto_end);
1773         setPrehandler(dialog_->check_use_babel);
1774         setPrehandler(dialog_->check_global_options);
1775         setPrehandler(dialog_->input_command_begin);
1776         setPrehandler(dialog_->input_command_end);
1777
1778         // Activate/Deactivate the input fields dependent on the state of the
1779         // buttons.
1780         input(0);
1781 }
1782
1783
1784 string const
1785 FormPreferences::Language::feedback(FL_OBJECT const * const ob) const
1786 {
1787         if (ob == dialog_->combox_default_lang)
1788                 return LyXRC::getDescription(LyXRC::RC_DEFAULT_LANGUAGE);
1789         if (ob == dialog_->check_use_kbmap)
1790                 return LyXRC::getDescription(LyXRC::RC_KBMAP);
1791         if (ob == dialog_->input_kbmap1)
1792                 return LyXRC::getDescription(LyXRC::RC_KBMAP_PRIMARY);
1793         if (ob == dialog_->input_kbmap2)
1794                 return LyXRC::getDescription(LyXRC::RC_KBMAP_SECONDARY);
1795         if (ob == dialog_->check_rtl_support)
1796                 return LyXRC::getDescription(LyXRC::RC_RTL_SUPPORT);
1797         if (ob == dialog_->check_mark_foreign)
1798                 return LyXRC::getDescription(LyXRC::RC_MARK_FOREIGN_LANGUAGE);
1799         if (ob == dialog_->check_auto_begin)
1800                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_AUTO_BEGIN);
1801         if (ob == dialog_->check_auto_end)
1802                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_AUTO_END);
1803         if (ob == dialog_->check_use_babel)
1804                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_USE_BABEL);
1805         if (ob == dialog_->check_global_options)
1806                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS);
1807         if (ob == dialog_->input_package)
1808                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_PACKAGE);
1809         if (ob == dialog_->input_command_begin)
1810                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_COMMAND_BEGIN);
1811         if (ob == dialog_->input_command_end)
1812                 return LyXRC::getDescription(LyXRC::RC_LANGUAGE_COMMAND_END);
1813         return string();
1814 }
1815
1816
1817 bool FormPreferences::Language::input(FL_OBJECT const * const ob)
1818 {
1819         bool activate = true;
1820
1821         // !ob if function is called from Language::build() to de/activate
1822         // objects,
1823         // otherwise the function is called by an xforms CB via input().
1824         if (!ob || ob == dialog_->check_use_kbmap) {
1825                 bool const enable = fl_get_button(dialog_->check_use_kbmap);
1826                 setEnabled(dialog_->button_kbmap1_browse, enable);
1827                 setEnabled(dialog_->button_kbmap2_browse, enable);
1828                 setEnabled(dialog_->input_kbmap1, enable);
1829                 setEnabled(dialog_->input_kbmap2, enable);
1830         }
1831
1832         if (ob == dialog_->button_kbmap1_browse) {
1833                 string f = parent_.controller().browsekbmap(
1834                         getString(dialog_->input_kbmap1));
1835
1836                 fl_set_input(dialog_->input_kbmap1, f.c_str());
1837         } else if (ob == dialog_->button_kbmap2_browse) {
1838                 string f = parent_.controller().browsekbmap(
1839                         getString(dialog_->input_kbmap2));
1840
1841                 fl_set_input(dialog_->input_kbmap2, f.c_str());
1842         }
1843
1844         return activate;
1845 }
1846
1847
1848 void FormPreferences::Language::update(LyXRC const & rc)
1849 {
1850         fl_set_button(dialog_->check_use_kbmap,
1851                       rc.use_kbmap);
1852
1853         int const pos = int(findPos(lang_, rc.default_language));
1854         fl_set_combox(dialog_->combox_default_lang, pos + 1);
1855
1856         if (rc.use_kbmap) {
1857                 fl_set_input(dialog_->input_kbmap1,
1858                              rc.primary_kbmap.c_str());
1859                 fl_set_input(dialog_->input_kbmap2,
1860                              rc.secondary_kbmap.c_str());
1861         } else {
1862                 fl_set_input(dialog_->input_kbmap1, "");
1863                 fl_set_input(dialog_->input_kbmap2, "");
1864         }
1865
1866         fl_set_button(dialog_->check_rtl_support, rc.rtl_support);
1867         fl_set_button(dialog_->check_mark_foreign,
1868                       rc.mark_foreign_language);
1869         fl_set_button(dialog_->check_auto_begin, rc.language_auto_begin);
1870         fl_set_button(dialog_->check_auto_end, rc.language_auto_end);
1871         fl_set_button(dialog_->check_use_babel, rc.language_use_babel);
1872         fl_set_button(dialog_->check_global_options,
1873                       rc.language_global_options);
1874
1875         fl_set_input(dialog_->input_package,
1876                      rc.language_package.c_str());
1877         fl_set_input(dialog_->input_command_begin,
1878                      rc.language_command_begin.c_str());
1879         fl_set_input(dialog_->input_command_end,
1880                      rc.language_command_end.c_str());
1881
1882         // Activate/Deactivate the input fields dependent on the state of the
1883         // buttons.
1884         input(0);
1885 }
1886
1887
1888 FormPreferences::LnFmisc::LnFmisc(FormPreferences &  p)
1889         : parent_(p)
1890 {}
1891
1892
1893 FD_preferences_lnf_misc const * FormPreferences::LnFmisc::dialog()
1894 {
1895         return dialog_.get();
1896 }
1897
1898
1899 void FormPreferences::LnFmisc::apply(LyXRC & rc) const
1900 {
1901         rc.auto_region_delete =
1902                 fl_get_button(dialog_->check_auto_region_delete);
1903         rc.cursor_follows_scrollbar =
1904                 fl_get_button(dialog_->check_cursor_follows_scrollbar);
1905         rc.dialogs_iconify_with_main =
1906                 fl_get_button(dialog_->check_dialogs_iconify_with_main);
1907
1908         switch (fl_get_choice(dialog_->choice_instant_preview)) {
1909         case 1:
1910                 rc.preview = LyXRC::PREVIEW_OFF;
1911                 break;
1912         case 2:
1913                 rc.preview = LyXRC::PREVIEW_NO_MATH;
1914                 break;
1915         case 3:
1916                 rc.preview = LyXRC::PREVIEW_ON;
1917                 break;
1918         }
1919
1920         rc.autosave = static_cast<unsigned int>
1921                 (fl_get_counter_value(dialog_->counter_autosave));
1922         rc.wheel_jump = static_cast<unsigned int>
1923                 (fl_get_counter_value(dialog_->counter_wm_jump));
1924
1925         // See FIXME below
1926         // graphics::DisplayType old_value = rc.display_graphics;
1927         switch (fl_get_choice(dialog_->choice_graphics_display)) {
1928         case 4:
1929                 rc.display_graphics = graphics::NoDisplay;
1930                 break;
1931         case 3:
1932                 rc.display_graphics = graphics::ColorDisplay;
1933                 break;
1934         case 2:
1935                 rc.display_graphics = graphics::GrayscaleDisplay;
1936                 break;
1937         case 1:
1938                 rc.display_graphics = graphics::MonochromeDisplay;
1939                 break;
1940         default:
1941                 rc.display_graphics = graphics::ColorDisplay;
1942                 break;
1943         }
1944
1945 #ifdef WITH_WARNINGS
1946 #warning FIXME!! The graphics cache no longer has a changeDisplay method.
1947 #endif
1948 #if 0
1949         if (old_value != rc.display_graphics) {
1950                 graphics::GCache & gc = graphics::GCache::get();
1951                 gc.changeDisplay();
1952         }
1953 #endif
1954 }
1955
1956
1957 void FormPreferences::LnFmisc::build()
1958 {
1959         dialog_.reset(build_preferences_lnf_misc(&parent_));
1960
1961         fl_set_counter_step(dialog_->counter_autosave, 1, 10);
1962         fl_set_counter_step(dialog_->counter_wm_jump, 1, 10);
1963
1964         fl_set_counter_return(dialog_->counter_autosave, FL_RETURN_CHANGED);
1965         fl_set_counter_return(dialog_->counter_wm_jump, FL_RETURN_CHANGED);
1966
1967         // set up the feedback mechanism
1968         setPrehandler(dialog_->check_auto_region_delete);
1969         setPrehandler(dialog_->counter_autosave);
1970         setPrehandler(dialog_->check_cursor_follows_scrollbar);
1971         setPrehandler(dialog_->check_dialogs_iconify_with_main);
1972         setPrehandler(dialog_->choice_instant_preview);
1973         setPrehandler(dialog_->counter_wm_jump);
1974
1975         fl_addto_choice(dialog_->choice_graphics_display,
1976                         _("Monochrome|Grayscale|Color|Do not display").c_str());
1977
1978         fl_addto_choice(dialog_->choice_instant_preview,
1979                         _("Off|No math|On").c_str());
1980 }
1981
1982
1983 string const
1984 FormPreferences::LnFmisc::feedback(FL_OBJECT const * const ob) const
1985 {
1986         if (ob == dialog_->check_auto_region_delete)
1987                 return LyXRC::getDescription(LyXRC::RC_AUTOREGIONDELETE);
1988         if (ob == dialog_->check_cursor_follows_scrollbar)
1989                 return LyXRC::getDescription(LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR);
1990         if (ob == dialog_->check_dialogs_iconify_with_main)
1991                 return LyXRC::getDescription(LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN);
1992         if (ob == dialog_->choice_instant_preview)
1993                 return LyXRC::getDescription(LyXRC::RC_PREVIEW);
1994         if (ob == dialog_->counter_autosave)
1995                 return LyXRC::getDescription(LyXRC::RC_AUTOSAVE);
1996         if (ob == dialog_->counter_wm_jump)
1997                 return LyXRC::getDescription(LyXRC::RC_WHEEL_JUMP);
1998         if (ob == dialog_->choice_graphics_display)
1999                 return LyXRC::getDescription(LyXRC::RC_DISPLAY_GRAPHICS);
2000         return string();
2001 }
2002
2003
2004 void FormPreferences::LnFmisc::update(LyXRC const & rc)
2005 {
2006         fl_set_button(dialog_->check_auto_region_delete,
2007                       rc.auto_region_delete);
2008         fl_set_button(dialog_->check_cursor_follows_scrollbar,
2009                       rc.cursor_follows_scrollbar);
2010         fl_set_button(dialog_->check_dialogs_iconify_with_main,
2011                       rc.dialogs_iconify_with_main);
2012
2013         switch (rc.preview) {
2014         case LyXRC::PREVIEW_OFF:
2015                 fl_set_choice(dialog_->choice_instant_preview, 1);
2016                 break;
2017         case LyXRC::PREVIEW_NO_MATH:
2018                 fl_set_choice(dialog_->choice_instant_preview, 2);
2019                 break;
2020         case LyXRC::PREVIEW_ON:
2021                 fl_set_choice(dialog_->choice_instant_preview, 3);
2022                 break;
2023         }
2024
2025         fl_set_counter_value(dialog_->counter_autosave, rc.autosave);
2026         fl_set_counter_value(dialog_->counter_wm_jump, rc.wheel_jump);
2027
2028         switch (rc.display_graphics) {
2029         case graphics::NoDisplay:
2030                 fl_set_choice(dialog_->choice_graphics_display, 4);
2031                 break;
2032         case graphics::ColorDisplay:
2033                 fl_set_choice(dialog_->choice_graphics_display, 3);
2034                 break;
2035         case graphics::GrayscaleDisplay:
2036                 fl_set_choice(dialog_->choice_graphics_display, 2);
2037                 break;
2038         case graphics::MonochromeDisplay:
2039                 fl_set_choice(dialog_->choice_graphics_display, 1);
2040                 break;
2041         default:
2042                 fl_set_choice(dialog_->choice_graphics_display, 3);
2043                 break;
2044         }
2045 }
2046
2047
2048 FormPreferences::OutputsMisc::OutputsMisc(FormPreferences &  p)
2049         : parent_(p)
2050 {}
2051
2052
2053 FD_preferences_outputs_misc const * FormPreferences::OutputsMisc::dialog()
2054 {
2055         return dialog_.get();
2056 }
2057
2058
2059 void FormPreferences::OutputsMisc::apply(LyXRC & rc) const
2060 {
2061         rc.ascii_linelen = static_cast<unsigned int>
2062                 (fl_get_counter_value(dialog_->counter_line_len));
2063         rc.fontenc = getString(dialog_->input_tex_encoding);
2064
2065         int const choice =
2066                 fl_get_choice(dialog_->choice_default_papersize) - 1;
2067         rc.default_papersize = static_cast<PAPER_SIZE>(choice);
2068
2069         rc.ascii_roff_command = getString(dialog_->input_ascii_roff);
2070         rc.chktex_command = getString(dialog_->input_checktex);
2071         rc.bibtex_command = getString(dialog_->input_bibtex);
2072         rc.index_command = getString(dialog_->input_index);
2073         rc.view_dvi_paper_option = getString(dialog_->input_paperoption);
2074         rc.auto_reset_options = fl_get_button(dialog_->check_autoreset_classopt);
2075
2076 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
2077         rc.cygwin_path_fix = fl_get_button(dialog_->check_cygwin_path);
2078 #endif
2079 }
2080
2081
2082 void FormPreferences::OutputsMisc::build()
2083 {
2084         dialog_.reset(build_preferences_outputs_misc(&parent_));
2085
2086         fl_set_counter_step(dialog_->counter_line_len, 1, 10);
2087
2088         fl_set_counter_return(dialog_->counter_line_len, FL_RETURN_CHANGED);
2089         fl_set_input_return(dialog_->input_tex_encoding, FL_RETURN_CHANGED);
2090         fl_set_input_return(dialog_->input_ascii_roff,   FL_RETURN_CHANGED);
2091         fl_set_input_return(dialog_->input_bibtex,       FL_RETURN_CHANGED);
2092         fl_set_input_return(dialog_->input_checktex,     FL_RETURN_CHANGED);
2093         fl_set_input_return(dialog_->input_index,        FL_RETURN_CHANGED);
2094         fl_set_input_return(dialog_->input_paperoption,  FL_RETURN_CHANGED);
2095
2096 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
2097 #else
2098         setEnabled(dialog_->check_cygwin_path, false);
2099 #endif
2100
2101         fl_addto_choice(dialog_->choice_default_papersize,
2102                         _(" default | US letter | US legal "
2103                           "| US executive | A3 | A4 | A5 | B5 ").c_str());
2104
2105         // set up the feedback mechanism
2106         setPrehandler(dialog_->counter_line_len);
2107         setPrehandler(dialog_->input_tex_encoding);
2108         setPrehandler(dialog_->choice_default_papersize);
2109         setPrehandler(dialog_->input_ascii_roff);
2110         setPrehandler(dialog_->input_bibtex);
2111         setPrehandler(dialog_->input_checktex);
2112         setPrehandler(dialog_->input_index);
2113         setPrehandler(dialog_->input_paperoption);
2114         setPrehandler(dialog_->check_autoreset_classopt);
2115 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
2116         setPrehandler(dialog_->check_cygwin_path);
2117 #endif
2118 }
2119
2120
2121 string const
2122 FormPreferences::OutputsMisc::feedback(FL_OBJECT const * const ob) const
2123 {
2124         if (ob == dialog_->counter_line_len)
2125                 return LyXRC::getDescription(LyXRC::RC_ASCII_LINELEN);
2126         if (ob == dialog_->input_tex_encoding)
2127                 return LyXRC::getDescription(LyXRC::RC_FONT_ENCODING);
2128         if (ob == dialog_->input_ascii_roff)
2129                 return LyXRC::getDescription(LyXRC::RC_ASCIIROFF_COMMAND);
2130         if (ob == dialog_->input_bibtex)
2131                 return LyXRC::getDescription(LyXRC::RC_BIBTEX_COMMAND);
2132         if (ob == dialog_->input_checktex)
2133                 return LyXRC::getDescription(LyXRC::RC_CHKTEX_COMMAND);
2134         if (ob == dialog_->input_index)
2135                 return LyXRC::getDescription(LyXRC::RC_INDEX_COMMAND);
2136         if (ob == dialog_->choice_default_papersize)
2137                 return LyXRC::getDescription(LyXRC::RC_DEFAULT_PAPERSIZE);
2138         if (ob == dialog_->input_paperoption)
2139                 return LyXRC::getDescription(LyXRC::RC_VIEWDVI_PAPEROPTION);
2140         if (ob == dialog_->check_autoreset_classopt)
2141                 return LyXRC::getDescription(LyXRC::RC_AUTORESET_OPTIONS);
2142 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
2143         if (ob == dialog_->check_cygwin_path)
2144                 return _("Select if LyX should output Cygwin-style paths "
2145                          "rather than Windows-style paths. Useful if you're "
2146                          "using the Cygwin teTeX rather than a native Windows "
2147                          "MikTeX. Note, however, that you'll need to write "
2148                          "shell script wrappers for all your converters.");
2149 #endif
2150         return string();
2151 }
2152
2153
2154 void FormPreferences::OutputsMisc::update(LyXRC const & rc)
2155 {
2156         fl_set_counter_value(dialog_->counter_line_len,
2157                              rc.ascii_linelen);
2158         fl_set_input(dialog_->input_tex_encoding,
2159                      rc.fontenc.c_str());
2160         fl_set_choice(dialog_->choice_default_papersize,
2161                       rc.default_papersize + 1);
2162         fl_set_input(dialog_->input_ascii_roff,
2163                      rc.ascii_roff_command.c_str());
2164         fl_set_input(dialog_->input_checktex,
2165                      rc.chktex_command.c_str());
2166         fl_set_input(dialog_->input_bibtex,
2167                      rc.bibtex_command.c_str());
2168         fl_set_input(dialog_->input_index,
2169                      rc.index_command.c_str());
2170         fl_set_input(dialog_->input_paperoption,
2171                      rc.view_dvi_paper_option.c_str());
2172         fl_set_button(dialog_->check_autoreset_classopt,
2173                       rc.auto_reset_options);
2174 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
2175         fl_set_button(dialog_->check_cygwin_path, rc.cygwin_path_fix);
2176 #endif
2177 }
2178
2179
2180 FormPreferences::Paths::Paths(FormPreferences &  p)
2181         : parent_(p)
2182 {}
2183
2184
2185 FD_preferences_paths const * FormPreferences::Paths::dialog()
2186 {
2187         return dialog_.get();
2188 }
2189
2190
2191 void FormPreferences::Paths::apply(LyXRC & rc)
2192 {
2193         rc.document_path = getString(dialog_->input_default_path);
2194         rc.template_path = getString(dialog_->input_template_path);
2195         rc.tempdir_path  = getString(dialog_->input_temp_dir);
2196         rc.path_prefix  = getString(dialog_->input_path_prefix);
2197
2198         int button = fl_get_button(dialog_->check_last_files);
2199         string str = getString(dialog_->input_lastfiles);
2200         if (!button) str.erase();
2201
2202         rc.check_lastfiles = button;
2203         rc.lastfiles = str;
2204         rc.num_lastfiles = static_cast<unsigned int>
2205                 (fl_get_counter_value(dialog_->counter_lastfiles));
2206
2207         button = fl_get_button(dialog_->check_make_backups);
2208         str = getString(dialog_->input_backup_path);
2209         if (!button)
2210                 str.erase();
2211
2212         rc.make_backup = button;
2213         rc.backupdir_path = str;
2214
2215         rc.lyxpipes = getString(dialog_->input_serverpipe);
2216
2217         // update view
2218         update(rc);
2219 }
2220
2221
2222 void FormPreferences::Paths::build()
2223 {
2224         dialog_.reset(build_preferences_paths(&parent_));
2225
2226         fl_set_input_return(dialog_->input_default_path, FL_RETURN_CHANGED);
2227         fl_set_input_return(dialog_->input_template_path, FL_RETURN_CHANGED);
2228         fl_set_input_return(dialog_->input_temp_dir, FL_RETURN_CHANGED);
2229         fl_set_input_return(dialog_->input_path_prefix, FL_RETURN_CHANGED);
2230         fl_set_input_return(dialog_->input_lastfiles, FL_RETURN_CHANGED);
2231         fl_set_input_return(dialog_->input_backup_path, FL_RETURN_CHANGED);
2232         fl_set_counter_bounds(dialog_->counter_lastfiles, 0, maxlastfiles);
2233         fl_set_counter_return(dialog_->counter_lastfiles, FL_RETURN_CHANGED);
2234         fl_set_input_return(dialog_->input_serverpipe, FL_RETURN_CHANGED);
2235
2236         // set up the feedback mechanism
2237         setPrehandler(dialog_->input_default_path);
2238         setPrehandler(dialog_->counter_lastfiles);
2239         setPrehandler(dialog_->input_template_path);
2240         setPrehandler(dialog_->input_path_prefix);
2241         setPrehandler(dialog_->check_last_files);
2242         setPrehandler(dialog_->input_lastfiles);
2243         setPrehandler(dialog_->check_make_backups);
2244         setPrehandler(dialog_->input_backup_path);
2245         setPrehandler(dialog_->input_serverpipe);
2246         setPrehandler(dialog_->input_temp_dir);
2247 }
2248
2249
2250 string const
2251 FormPreferences::Paths::feedback(FL_OBJECT const * const ob) const
2252 {
2253         if (ob == dialog_->input_default_path)
2254                 return LyXRC::getDescription(LyXRC::RC_DOCUMENTPATH);
2255         if (ob == dialog_->input_template_path)
2256                 return LyXRC::getDescription(LyXRC::RC_TEMPLATEPATH);
2257         if (ob == dialog_->input_temp_dir)
2258                 return LyXRC::getDescription(LyXRC::RC_TEMPDIRPATH);
2259         if (ob == dialog_->check_last_files)
2260                 return LyXRC::getDescription(LyXRC::RC_CHECKLASTFILES);
2261         if (ob == dialog_->input_lastfiles)
2262                 return LyXRC::getDescription(LyXRC::RC_LASTFILES);
2263         if (ob == dialog_->counter_lastfiles)
2264                 return LyXRC::getDescription(LyXRC::RC_NUMLASTFILES);
2265         if (ob == dialog_->check_make_backups)
2266                 return LyXRC::getDescription(LyXRC::RC_MAKE_BACKUP);
2267         if (ob == dialog_->input_backup_path)
2268                 return LyXRC::getDescription(LyXRC::RC_BACKUPDIR_PATH);
2269         if (ob == dialog_->input_serverpipe)
2270                 return LyXRC::getDescription(LyXRC::RC_SERVERPIPE);
2271         if (ob == dialog_->input_path_prefix)
2272                 return _("Specify those directories which should be"
2273                          "prepended to the PATH environment variable. "
2274                          "Use the OS native format.");
2275         return string();
2276 }
2277
2278
2279 bool FormPreferences::Paths::input(FL_OBJECT const * const ob)
2280 {
2281         bool activate = true;
2282
2283         // !ob if function is called from Paths::update() to de/activate
2284         // objects,
2285         // otherwise the function is called by an xforms CB via input().
2286         if (!ob || ob == dialog_->check_last_files) {
2287                 bool const enable = fl_get_button(dialog_->check_last_files);
2288                 setEnabled(dialog_->input_lastfiles, enable);
2289         }
2290
2291         if (!ob || ob == dialog_->check_make_backups) {
2292                 bool const enable = fl_get_button(dialog_->check_make_backups);
2293                 setEnabled(dialog_->input_backup_path, enable);
2294         }
2295
2296         if (!ob || ob == dialog_->input_default_path) {
2297                 string const name = getString(dialog_->input_default_path);
2298                 if (!name.empty() && !RWInfo::WriteableDir(name)) {
2299                         parent_.postWarning(RWInfo::ErrorMessage());
2300                         return false;
2301                 }
2302         }
2303
2304         if (!ob || ob == dialog_->input_template_path) {
2305                 string const name = getString(dialog_->input_template_path);
2306                 if (!name.empty() && !RWInfo::ReadableDir(name)) {
2307                         parent_.postWarning(RWInfo::ErrorMessage());
2308                         return false;
2309                 }
2310         }
2311
2312         if (!ob || ob == dialog_->input_temp_dir) {
2313                 string const name = getString(dialog_->input_temp_dir);
2314                 if (fl_get_button(dialog_->check_make_backups)
2315                     && !name.empty()
2316                     && !RWInfo::WriteableDir(name)) {
2317                         parent_.postWarning(RWInfo::ErrorMessage());
2318                         return false;
2319                 }
2320         }
2321
2322         if (!ob || ob == dialog_->input_backup_path) {
2323                 string const name = getString(dialog_->input_backup_path);
2324                 if (fl_get_button(dialog_->check_make_backups)
2325                     && !name.empty()
2326                     && !RWInfo::WriteableDir(name)) {
2327                         parent_.postWarning(RWInfo::ErrorMessage());
2328                         return false;
2329                 }
2330         }
2331
2332         if (!ob || ob == dialog_->input_lastfiles) {
2333                 string const name = getString(dialog_->input_lastfiles);
2334                 if (fl_get_button(dialog_->check_last_files)
2335                     && !name.empty()
2336                     && !RWInfo::WriteableFile(name)) {
2337                         parent_.postWarning(RWInfo::ErrorMessage());
2338                         return false;
2339                 }
2340         }
2341
2342         if (!ob || ob == dialog_->input_serverpipe) {
2343                 string const name = getString(dialog_->input_serverpipe);
2344                 if (!name.empty()) {
2345                         // strip off the extension
2346                         string const str = ChangeExtension(name, "");
2347                         if (!RWInfo::WriteableFile(str + ".in")) {
2348                                 parent_.postWarning(RWInfo::ErrorMessage());
2349                                 return false;
2350                         }
2351                         if (!RWInfo::WriteableFile(str + ".out")) {
2352                                 parent_.postWarning(RWInfo::ErrorMessage());
2353                                 return false;
2354                         }
2355                 }
2356         }
2357
2358         if (ob == dialog_->button_default_path_browse) {
2359                 string f = parent_.controller().browsedir(
2360                         getString(dialog_->input_default_path), _("Default path"));
2361                 if (!f.empty())
2362                         fl_set_input(dialog_->input_default_path, f.c_str());
2363         } else if (ob == dialog_->button_template_path_browse) {
2364                 string f = parent_.controller().browsedir(
2365                         getString(dialog_->input_template_path), _("Template path"));
2366                 if (!f.empty())
2367                         fl_set_input(dialog_->input_template_path, f.c_str());
2368         } else if (ob == dialog_->button_temp_dir_browse) {
2369                 string f = parent_.controller().browsedir(
2370                         getString(dialog_->input_temp_dir), _("Temporary dir"));
2371                 if (!f.empty())
2372                         fl_set_input(dialog_->input_temp_dir, f.c_str());
2373         } else if (ob == dialog_->button_lastfiles_browse) {
2374                 string f = parent_.controller().browse(
2375                         getString(dialog_->input_lastfiles), _("Last files"));
2376                 if (!f.empty())
2377                         fl_set_input(dialog_->input_lastfiles, f.c_str());
2378         } else if (ob == dialog_->button_backup_path_browse) {
2379                 string f = parent_.controller().browsedir(
2380                         getString(dialog_->input_backup_path), _("Backup path"));
2381                 if (!f.empty())
2382                         fl_set_input(dialog_->input_backup_path, f.c_str());
2383         } else if (ob == dialog_->button_serverpipe_browse) {
2384                 string f = parent_.controller().browse(
2385                         getString(dialog_->input_serverpipe), _("LyX server pipes"));
2386                 if (!f.empty())
2387                         fl_set_input(dialog_->input_serverpipe, f.c_str());
2388         }
2389
2390         return activate;
2391 }
2392
2393
2394 void FormPreferences::Paths::update(LyXRC const & rc)
2395 {
2396         fl_set_input(dialog_->input_default_path,
2397                      rc.document_path.c_str());
2398         fl_set_input(dialog_->input_template_path,
2399                      rc.template_path.c_str());
2400
2401         string str;
2402         if (rc.make_backup)
2403                 str = rc.backupdir_path;
2404
2405         fl_set_button(dialog_->check_make_backups,
2406                       rc.make_backup);
2407         fl_set_input(dialog_->input_backup_path, str.c_str());
2408
2409         fl_set_input(dialog_->input_temp_dir, rc.tempdir_path.c_str());
2410         fl_set_input(dialog_->input_path_prefix, rc.path_prefix.c_str());
2411
2412         str.erase();
2413         if (rc.check_lastfiles)
2414                 str = rc.lastfiles;
2415
2416         fl_set_button(dialog_->check_last_files,
2417                       rc.check_lastfiles);
2418         fl_set_input(dialog_->input_lastfiles, str.c_str());
2419         fl_set_counter_value(dialog_->counter_lastfiles,
2420                              rc.num_lastfiles);
2421
2422         fl_set_input(dialog_->input_serverpipe, rc.lyxpipes.c_str());
2423
2424         // Activate/Deactivate the input fields dependent on the state of the
2425         // buttons.
2426         input(0);
2427 }
2428
2429
2430 FormPreferences::Printer::Printer(FormPreferences &  p)
2431         : parent_(p)
2432 {}
2433
2434
2435 FD_preferences_printer const * FormPreferences::Printer::dialog()
2436 {
2437         return dialog_.get();
2438 }
2439
2440
2441 void FormPreferences::Printer::apply(LyXRC & rc) const
2442 {
2443         rc.print_adapt_output = fl_get_button(dialog_->check_adapt_output);
2444         rc.print_command = getString(dialog_->input_command);
2445         rc.print_pagerange_flag = getString(dialog_->input_page_range);
2446         rc.print_copies_flag = getString(dialog_->input_copies);
2447         rc.print_reverse_flag = getString(dialog_->input_reverse);
2448         rc.print_to_printer = getString(dialog_->input_to_printer);
2449         rc.print_file_extension =
2450                 getString(dialog_->input_file_extension);
2451         rc.print_spool_command =
2452                 getString(dialog_->input_spool_command);
2453         rc.print_paper_flag = getString(dialog_->input_paper_type);
2454         rc.print_evenpage_flag = getString(dialog_->input_even_pages);
2455         rc.print_oddpage_flag = getString(dialog_->input_odd_pages);
2456         rc.print_collcopies_flag = getString(dialog_->input_collated);
2457         rc.print_landscape_flag = getString(dialog_->input_landscape);
2458         rc.print_to_file = getString(dialog_->input_to_file);
2459         rc.print_extra_options =
2460                 getString(dialog_->input_extra_options);
2461         rc.print_spool_printerprefix =
2462                 getString(dialog_->input_spool_prefix);
2463         rc.print_paper_dimension_flag =
2464                 getString(dialog_->input_paper_size);
2465         rc.printer = getString(dialog_->input_name);
2466 }
2467
2468
2469 string const
2470 FormPreferences::Printer::feedback(FL_OBJECT const * const ob) const
2471 {
2472         if (ob == dialog_->input_command)
2473                 return LyXRC::getDescription(LyXRC::RC_PRINT_COMMAND);
2474         if (ob == dialog_->check_adapt_output)
2475                 return LyXRC::getDescription(LyXRC::RC_PRINT_ADAPTOUTPUT);
2476         if (ob == dialog_->input_to_printer)
2477                 return LyXRC::getDescription(LyXRC::RC_PRINTTOPRINTER);
2478         if (ob == dialog_->input_to_file)
2479                 return LyXRC::getDescription(LyXRC::RC_PRINTTOFILE);
2480         if (ob == dialog_->input_file_extension)
2481                 return LyXRC::getDescription(LyXRC::RC_PRINTFILEEXTENSION);
2482         if (ob == dialog_->input_extra_options)
2483                 return LyXRC::getDescription(LyXRC::RC_PRINTEXSTRAOPTIONS);
2484         if (ob == dialog_->input_spool_command)
2485                 return LyXRC::getDescription(LyXRC::RC_PRINTSPOOL_COMMAND);
2486         if (ob == dialog_->input_spool_prefix)
2487                 return LyXRC::getDescription(LyXRC::RC_PRINTSPOOL_PRINTERPREFIX);
2488         if (ob == dialog_->input_name)
2489                 return LyXRC::getDescription(LyXRC::RC_PRINTER);
2490         if (ob == dialog_->input_even_pages)
2491                 return LyXRC::getDescription(LyXRC::RC_PRINTEVENPAGEFLAG);
2492         if (ob == dialog_->input_odd_pages)
2493                 return LyXRC::getDescription(LyXRC::RC_PRINTODDPAGEFLAG);
2494         if (ob == dialog_->input_page_range)
2495                 return LyXRC::getDescription(LyXRC::RC_PRINTPAGERANGEFLAG);
2496         if (ob == dialog_->input_reverse)
2497                 return LyXRC::getDescription(LyXRC::RC_PRINTREVERSEFLAG);
2498         if (ob == dialog_->input_landscape)
2499                 return LyXRC::getDescription(LyXRC::RC_PRINTLANDSCAPEFLAG);
2500         if (ob == dialog_->input_copies)
2501                 return LyXRC::getDescription(LyXRC::RC_PRINTCOPIESFLAG);
2502         if (ob == dialog_->input_collated)
2503                 return LyXRC::getDescription(LyXRC::RC_PRINTCOLLCOPIESFLAG);
2504         if (ob == dialog_->input_paper_type)
2505                 return LyXRC::getDescription(LyXRC::RC_PRINTPAPERFLAG);
2506         if (ob == dialog_->input_paper_size)
2507                 return LyXRC::getDescription(LyXRC::RC_PRINTPAPERDIMENSIONFLAG);
2508         return string();
2509 }
2510
2511
2512 void FormPreferences::Printer::build()
2513 {
2514         dialog_.reset(build_preferences_printer(&parent_));
2515
2516         fl_set_input_return(dialog_->input_command, FL_RETURN_CHANGED);
2517         fl_set_input_return(dialog_->input_page_range, FL_RETURN_CHANGED);
2518         fl_set_input_return(dialog_->input_copies, FL_RETURN_CHANGED);
2519         fl_set_input_return(dialog_->input_reverse, FL_RETURN_CHANGED);
2520         fl_set_input_return(dialog_->input_to_printer, FL_RETURN_CHANGED);
2521         fl_set_input_return(dialog_->input_file_extension, FL_RETURN_CHANGED);
2522         fl_set_input_return(dialog_->input_spool_command, FL_RETURN_CHANGED);
2523         fl_set_input_return(dialog_->input_paper_type, FL_RETURN_CHANGED);
2524         fl_set_input_return(dialog_->input_even_pages, FL_RETURN_CHANGED);
2525         fl_set_input_return(dialog_->input_odd_pages, FL_RETURN_CHANGED);
2526         fl_set_input_return(dialog_->input_collated, FL_RETURN_CHANGED);
2527         fl_set_input_return(dialog_->input_landscape, FL_RETURN_CHANGED);
2528         fl_set_input_return(dialog_->input_to_file, FL_RETURN_CHANGED);
2529         fl_set_input_return(dialog_->input_extra_options, FL_RETURN_CHANGED);
2530         fl_set_input_return(dialog_->input_spool_prefix, FL_RETURN_CHANGED);
2531         fl_set_input_return(dialog_->input_paper_size, FL_RETURN_CHANGED);
2532         fl_set_input_return(dialog_->input_name, FL_RETURN_CHANGED);
2533
2534         // set up the feedback mechanism
2535         setPrehandler(dialog_->input_command);
2536         setPrehandler(dialog_->input_page_range);
2537         setPrehandler(dialog_->input_copies);
2538         setPrehandler(dialog_->input_reverse);
2539         setPrehandler(dialog_->input_to_printer);
2540         setPrehandler(dialog_->input_file_extension);
2541         setPrehandler(dialog_->input_spool_command);
2542         setPrehandler(dialog_->input_paper_type);
2543         setPrehandler(dialog_->input_even_pages);
2544         setPrehandler(dialog_->input_odd_pages);
2545         setPrehandler(dialog_->input_collated);
2546         setPrehandler(dialog_->input_landscape);
2547         setPrehandler(dialog_->input_to_file);
2548         setPrehandler(dialog_->input_extra_options);
2549         setPrehandler(dialog_->input_spool_prefix);
2550         setPrehandler(dialog_->input_paper_size);
2551         setPrehandler(dialog_->input_name);
2552         setPrehandler(dialog_->check_adapt_output);
2553 }
2554
2555
2556 void FormPreferences::Printer::update(LyXRC const & rc)
2557 {
2558         fl_set_button(dialog_->check_adapt_output,
2559                       rc.print_adapt_output);
2560         fl_set_input(dialog_->input_command,
2561                      rc.print_command.c_str());
2562         fl_set_input(dialog_->input_page_range,
2563                      rc.print_pagerange_flag.c_str());
2564         fl_set_input(dialog_->input_copies,
2565                      rc.print_copies_flag.c_str());
2566         fl_set_input(dialog_->input_reverse,
2567                      rc.print_reverse_flag.c_str());
2568         fl_set_input(dialog_->input_to_printer,
2569                      rc.print_to_printer.c_str());
2570         fl_set_input(dialog_->input_file_extension,
2571                      rc.print_file_extension.c_str());
2572         fl_set_input(dialog_->input_spool_command,
2573                      rc.print_spool_command.c_str());
2574         fl_set_input(dialog_->input_paper_type,
2575                      rc.print_paper_flag.c_str());
2576         fl_set_input(dialog_->input_even_pages,
2577                      rc.print_evenpage_flag.c_str());
2578         fl_set_input(dialog_->input_odd_pages,
2579                      rc.print_oddpage_flag.c_str());
2580         fl_set_input(dialog_->input_collated,
2581                      rc.print_collcopies_flag.c_str());
2582         fl_set_input(dialog_->input_landscape,
2583                      rc.print_landscape_flag.c_str());
2584         fl_set_input(dialog_->input_to_file,
2585                      rc.print_to_file.c_str());
2586         fl_set_input(dialog_->input_extra_options,
2587                      rc.print_extra_options.c_str());
2588         fl_set_input(dialog_->input_spool_prefix,
2589                      rc.print_spool_printerprefix.c_str());
2590         fl_set_input(dialog_->input_paper_size,
2591                      rc.print_paper_dimension_flag.c_str());
2592         fl_set_input(dialog_->input_name,
2593                      rc.printer.c_str());
2594 }
2595
2596
2597 FormPreferences::ScreenFonts::ScreenFonts(FormPreferences &  p)
2598         : parent_(p)
2599 {}
2600
2601
2602 FD_preferences_screen_fonts const * FormPreferences::ScreenFonts::dialog()
2603 {
2604         return dialog_.get();
2605 }
2606
2607
2608 void FormPreferences::ScreenFonts::apply(LyXRC & rc) const
2609 {
2610         bool changed = false;
2611
2612         pair<string, string> tmp =
2613                 parseFontName(getString(dialog_->input_roman));
2614         if (rc.roman_font_name != tmp.first ||
2615             rc.roman_font_foundry != tmp.second) {
2616                 changed = true;
2617                 rc.roman_font_name = tmp.first;
2618                 rc.roman_font_foundry = tmp.second;
2619         }
2620
2621         tmp = parseFontName(getString(dialog_->input_sans));
2622         if (rc.sans_font_name != tmp.first ||
2623             rc.sans_font_foundry != tmp.second) {
2624                 changed = true;
2625                 rc.sans_font_name = tmp.first;
2626                 rc.sans_font_foundry = tmp.second;
2627         }
2628
2629         tmp = parseFontName(getString(dialog_->input_typewriter));
2630         if (rc.typewriter_font_name != tmp.first ||
2631             rc.typewriter_font_foundry != tmp.second) {
2632                 changed = true;
2633                 rc.typewriter_font_name = tmp.first;
2634                 rc.typewriter_font_foundry = tmp.second;
2635         }
2636
2637         string str = getString(dialog_->input_screen_encoding);
2638         if (rc.font_norm != str) {
2639                 changed = true;
2640                 rc.font_norm = str;
2641                 rc.set_font_norm_type();
2642         }
2643
2644         bool button = fl_get_button(dialog_->check_scalable);
2645         if (rc.use_scalable_fonts != button) {
2646                 changed = true;
2647                 rc.use_scalable_fonts = button;
2648         }
2649
2650         unsigned int ivalue = static_cast<unsigned int>
2651                 (fl_get_counter_value(dialog_->counter_zoom));
2652         if (rc.zoom != ivalue) {
2653                 changed = true;
2654                 rc.zoom = ivalue;
2655         }
2656
2657         ivalue = static_cast<unsigned int>
2658                 (fl_get_counter_value(dialog_->counter_dpi));
2659         if (rc.dpi != ivalue) {
2660                 changed = true;
2661                 rc.dpi = ivalue;
2662         }
2663
2664         string dvalue = getString(dialog_->input_tiny);
2665         if (rc.font_sizes[LyXFont::SIZE_TINY] != dvalue) {
2666                 changed = true;
2667                 rc.font_sizes[LyXFont::SIZE_TINY] = dvalue;
2668         }
2669
2670         dvalue = getString(dialog_->input_script);
2671         if (rc.font_sizes[LyXFont::SIZE_SCRIPT] != dvalue) {
2672                 changed = true;
2673                 rc.font_sizes[LyXFont::SIZE_SCRIPT] = dvalue;
2674         }
2675
2676         dvalue = getString(dialog_->input_footnote);
2677         if (rc.font_sizes[LyXFont::SIZE_FOOTNOTE] != dvalue) {
2678                 changed = true;
2679                 rc.font_sizes[LyXFont::SIZE_FOOTNOTE] = dvalue;
2680         }
2681
2682         dvalue = getString(dialog_->input_small);
2683         if (rc.font_sizes[LyXFont::SIZE_SMALL] != dvalue) {
2684                 changed = true;
2685                 rc.font_sizes[LyXFont::SIZE_SMALL] = dvalue;
2686         }
2687
2688         dvalue = getString(dialog_->input_normal);
2689         if (rc.font_sizes[LyXFont::SIZE_NORMAL] != dvalue) {
2690                 changed = true;
2691                 rc.font_sizes[LyXFont::SIZE_NORMAL] = dvalue;
2692         }
2693
2694         dvalue = getString(dialog_->input_large);
2695         if (rc.font_sizes[LyXFont::SIZE_LARGE] != dvalue) {
2696                 changed = true;
2697                 rc.font_sizes[LyXFont::SIZE_LARGE] = dvalue;
2698         }
2699
2700         dvalue = getString(dialog_->input_larger);
2701         if (rc.font_sizes[LyXFont::SIZE_LARGER] != dvalue) {
2702                 changed = true;
2703                 rc.font_sizes[LyXFont::SIZE_LARGER] = dvalue;
2704         }
2705
2706         dvalue = getString(dialog_->input_largest);
2707         if (rc.font_sizes[LyXFont::SIZE_LARGEST] != dvalue) {
2708                 changed = true;
2709                 rc.font_sizes[LyXFont::SIZE_LARGEST] = dvalue;
2710         }
2711
2712         dvalue = getString(dialog_->input_huge);
2713         if (rc.font_sizes[LyXFont::SIZE_HUGE] != dvalue) {
2714                 changed = true;
2715                 rc.font_sizes[LyXFont::SIZE_HUGE] = dvalue;
2716         }
2717
2718         dvalue = getString(dialog_->input_huger);
2719         if (rc.font_sizes[LyXFont::SIZE_HUGER] != dvalue) {
2720                 changed = true;
2721                 rc.font_sizes[LyXFont::SIZE_HUGER] = dvalue;
2722         }
2723
2724         if (changed) {
2725                 // Now update the buffers
2726                 // Can anything below here affect the redraw process?
2727                 parent_.controller().updateScreenFonts();
2728         }
2729 }
2730
2731
2732 void FormPreferences::ScreenFonts::build()
2733 {
2734         dialog_.reset(build_preferences_screen_fonts(&parent_));
2735
2736         fl_set_counter_step(dialog_->counter_zoom, 1, 10);
2737         fl_set_counter_step(dialog_->counter_dpi,  1, 10);
2738
2739         fl_set_input_return(dialog_->input_roman,           FL_RETURN_CHANGED);
2740         fl_set_input_return(dialog_->input_sans,            FL_RETURN_CHANGED);
2741         fl_set_input_return(dialog_->input_typewriter,      FL_RETURN_CHANGED);
2742         fl_set_input_return(dialog_->input_screen_encoding, FL_RETURN_CHANGED);
2743         fl_set_counter_return(dialog_->counter_zoom,        FL_RETURN_CHANGED);
2744         fl_set_counter_return(dialog_->counter_dpi,         FL_RETURN_CHANGED);
2745         fl_set_input_return(dialog_->input_tiny,            FL_RETURN_CHANGED);
2746         fl_set_input_return(dialog_->input_script,          FL_RETURN_CHANGED);
2747         fl_set_input_return(dialog_->input_footnote,        FL_RETURN_CHANGED);
2748         fl_set_input_return(dialog_->input_small,           FL_RETURN_CHANGED);
2749         fl_set_input_return(dialog_->input_normal,          FL_RETURN_CHANGED);
2750         fl_set_input_return(dialog_->input_large,           FL_RETURN_CHANGED);
2751         fl_set_input_return(dialog_->input_larger,          FL_RETURN_CHANGED);
2752         fl_set_input_return(dialog_->input_largest,         FL_RETURN_CHANGED);
2753         fl_set_input_return(dialog_->input_huge,            FL_RETURN_CHANGED);
2754         fl_set_input_return(dialog_->input_huger,           FL_RETURN_CHANGED);
2755
2756         fl_set_input_filter(dialog_->input_tiny,     fl_unsigned_float_filter);
2757         fl_set_input_filter(dialog_->input_script,   fl_unsigned_float_filter);
2758         fl_set_input_filter(dialog_->input_footnote, fl_unsigned_float_filter);
2759         fl_set_input_filter(dialog_->input_small,    fl_unsigned_float_filter);
2760         fl_set_input_filter(dialog_->input_normal,   fl_unsigned_float_filter);
2761         fl_set_input_filter(dialog_->input_large,    fl_unsigned_float_filter);
2762         fl_set_input_filter(dialog_->input_larger,   fl_unsigned_float_filter);
2763         fl_set_input_filter(dialog_->input_largest,  fl_unsigned_float_filter);
2764         fl_set_input_filter(dialog_->input_huge,     fl_unsigned_float_filter);
2765         fl_set_input_filter(dialog_->input_huger,    fl_unsigned_float_filter);
2766
2767         // set up the feedback mechanism
2768         setPrehandler(dialog_->input_roman);
2769         setPrehandler(dialog_->input_sans);
2770         setPrehandler(dialog_->input_typewriter);
2771         setPrehandler(dialog_->counter_zoom);
2772         setPrehandler(dialog_->counter_dpi);
2773         setPrehandler(dialog_->check_scalable);
2774         setPrehandler(dialog_->input_screen_encoding);
2775         setPrehandler(dialog_->input_tiny);
2776         setPrehandler(dialog_->input_script);
2777         setPrehandler(dialog_->input_footnote);
2778         setPrehandler(dialog_->input_small);
2779         setPrehandler(dialog_->input_large);
2780         setPrehandler(dialog_->input_larger);
2781         setPrehandler(dialog_->input_largest);
2782         setPrehandler(dialog_->input_normal);
2783         setPrehandler(dialog_->input_huge);
2784         setPrehandler(dialog_->input_huger);
2785 }
2786
2787
2788 string const
2789 FormPreferences::ScreenFonts::feedback(FL_OBJECT const * const ob) const
2790 {
2791         if (ob == dialog_->input_roman)
2792                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_ROMAN);
2793         if (ob == dialog_->input_sans)
2794                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_SANS);
2795         if (ob == dialog_->input_typewriter)
2796                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_TYPEWRITER);
2797         if (ob == dialog_->check_scalable)
2798                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_SCALABLE);
2799         if (ob == dialog_->input_screen_encoding)
2800                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_ENCODING);
2801         if (ob == dialog_->counter_zoom)
2802                 return LyXRC::getDescription(LyXRC::RC_SCREEN_ZOOM);
2803         if (ob == dialog_->counter_dpi)
2804                 return LyXRC::getDescription(LyXRC::RC_SCREEN_DPI);
2805         if (ob == dialog_->input_tiny
2806             || ob == dialog_->input_script
2807             || ob == dialog_->input_footnote
2808             || ob == dialog_->input_small
2809             || ob == dialog_->input_large
2810             || ob == dialog_->input_larger
2811             || ob == dialog_->input_larger
2812             || ob == dialog_->input_largest
2813             || ob == dialog_->input_normal
2814             || ob == dialog_->input_huge
2815             || ob == dialog_->input_huger)
2816                 return LyXRC::getDescription(LyXRC::RC_SCREEN_FONT_SIZES);
2817         return string();
2818 }
2819
2820
2821 bool FormPreferences::ScreenFonts::input()
2822 {
2823         bool activate = true;
2824         string str;
2825
2826         // Make sure that all fonts all have positive entries
2827         // Also note that an empty entry is returned as 0.0 by strToDbl
2828         if (0.0 >= convert<double>(fl_get_input(dialog_->input_tiny))
2829             || 0.0 >= convert<double>(fl_get_input(dialog_->input_script))
2830             || 0.0 >= convert<double>(fl_get_input(dialog_->input_footnote))
2831             || 0.0 >= convert<double>(fl_get_input(dialog_->input_small))
2832             || 0.0 >= convert<double>(fl_get_input(dialog_->input_normal))
2833             || 0.0 >= convert<double>(fl_get_input(dialog_->input_large))
2834             || 0.0 >= convert<double>(fl_get_input(dialog_->input_larger))
2835             || 0.0 >= convert<double>(fl_get_input(dialog_->input_largest))
2836             || 0.0 >= convert<double>(fl_get_input(dialog_->input_huge))
2837             || 0.0 >= convert<double>(fl_get_input(dialog_->input_huger))) {
2838                 activate = false;
2839                 str = _("Fonts must be positive!");
2840         } else if (convert<double>(fl_get_input(dialog_->input_tiny)) >
2841                    // Fontsizes -- tiny < script < footnote etc.
2842                    convert<double>(fl_get_input(dialog_->input_script)) ||
2843                    convert<double>(fl_get_input(dialog_->input_script)) >
2844                    convert<double>(fl_get_input(dialog_->input_footnote)) ||
2845                    convert<double>(fl_get_input(dialog_->input_footnote)) >
2846                    convert<double>(fl_get_input(dialog_->input_small)) ||
2847                    convert<double>(fl_get_input(dialog_->input_small)) >
2848                    convert<double>(fl_get_input(dialog_->input_normal)) ||
2849                    convert<double>(fl_get_input(dialog_->input_normal)) >
2850                    convert<double>(fl_get_input(dialog_->input_large)) ||
2851                    convert<double>(fl_get_input(dialog_->input_large)) >
2852                    convert<double>(fl_get_input(dialog_->input_larger)) ||
2853                    convert<double>(fl_get_input(dialog_->input_larger)) >
2854                    convert<double>(fl_get_input(dialog_->input_largest)) ||
2855                    convert<double>(fl_get_input(dialog_->input_largest)) >
2856                    convert<double>(fl_get_input(dialog_->input_huge)) ||
2857                    convert<double>(fl_get_input(dialog_->input_huge)) >
2858                    convert<double>(fl_get_input(dialog_->input_huger))) {
2859                 activate = false;
2860
2861                 str = _("Fonts must be input in the order Tiny > Smallest > Smaller > Small > Normal > Large > Larger > Largest > Huge > Huger.");
2862         }
2863
2864         if (!activate)
2865                 parent_.postWarning(str);
2866
2867         return activate;
2868 }
2869
2870
2871 void FormPreferences::ScreenFonts::update(LyXRC const & rc)
2872 {
2873         fl_set_input(dialog_->input_roman,
2874                      makeFontName(rc.roman_font_name,
2875                                   rc.roman_font_foundry).c_str());
2876         fl_set_input(dialog_->input_sans,
2877                      makeFontName(rc.sans_font_name,
2878                                   rc.sans_font_foundry).c_str());
2879         fl_set_input(dialog_->input_typewriter,
2880                      makeFontName(rc.typewriter_font_name,
2881                                   rc.typewriter_font_foundry).c_str());
2882         fl_set_input(dialog_->input_screen_encoding,
2883                      rc.font_norm.c_str());
2884         fl_set_button(dialog_->check_scalable,
2885                       rc.use_scalable_fonts);
2886         fl_set_counter_value(dialog_->counter_zoom, rc.zoom);
2887         fl_set_counter_value(dialog_->counter_dpi,  rc.dpi);
2888         fl_set_input(dialog_->input_tiny,
2889                      rc.font_sizes[LyXFont::SIZE_TINY].c_str());
2890         fl_set_input(dialog_->input_script,
2891                      rc.font_sizes[LyXFont::SIZE_SCRIPT].c_str());
2892         fl_set_input(dialog_->input_footnote,
2893                      rc.font_sizes[LyXFont::SIZE_FOOTNOTE].c_str());
2894         fl_set_input(dialog_->input_small,
2895                      rc.font_sizes[LyXFont::SIZE_SMALL].c_str());
2896         fl_set_input(dialog_->input_normal,
2897                      rc.font_sizes[LyXFont::SIZE_NORMAL].c_str());
2898         fl_set_input(dialog_->input_large,
2899                      rc.font_sizes[LyXFont::SIZE_LARGE].c_str());
2900         fl_set_input(dialog_->input_larger,
2901                      rc.font_sizes[LyXFont::SIZE_LARGER].c_str());
2902         fl_set_input(dialog_->input_largest,
2903                      rc.font_sizes[LyXFont::SIZE_LARGEST].c_str());
2904         fl_set_input(dialog_->input_huge,
2905                      rc.font_sizes[LyXFont::SIZE_HUGE].c_str());
2906         fl_set_input(dialog_->input_huger,
2907                      rc.font_sizes[LyXFont::SIZE_HUGER].c_str());
2908 }
2909
2910
2911
2912 FormPreferences::SpellOptions::SpellOptions(FormPreferences &  p)
2913         : parent_(p)
2914 {}
2915
2916
2917 FD_preferences_spelloptions const * FormPreferences::SpellOptions::dialog()
2918 {
2919         return dialog_.get();
2920 }
2921
2922
2923 void FormPreferences::SpellOptions::apply(LyXRC & rc)
2924 {
2925         string choice = fl_get_choice_text(dialog_->choice_spell_command);
2926         choice = trim(choice);
2927
2928         rc.isp_command = choice;
2929
2930 #if 0
2931         // If spell checker == "none", all other input set to off.
2932         if (fl_get_choice(dialog_->choice_spell_command) == 1) {
2933                 rc.isp_use_alt_lang = false;
2934                 rc.isp_alt_lang.erase();
2935
2936                 rc.isp_use_esc_chars = false;
2937                 rc.isp_esc_chars.erase();
2938
2939                 rc.isp_use_pers_dict = false;
2940                 rc.isp_pers_dict.erase();
2941
2942                 rc.isp_accept_compound = false;
2943                 rc.isp_use_input_encoding = false;
2944         } else {
2945 #else
2946                 int button = fl_get_button(dialog_->check_alt_lang);
2947                 choice = getString(dialog_->input_alt_lang);
2948                 if (button && choice.empty()) button = 0;
2949                 if (!button) choice.erase();
2950
2951                 rc.isp_use_alt_lang = static_cast<bool>(button);
2952                 rc.isp_alt_lang = choice;
2953
2954                 button = fl_get_button(dialog_->check_escape_chars);
2955                 choice = getString(dialog_->input_escape_chars);
2956                 if (button && choice.empty()) button = 0;
2957                 if (!button) choice.erase();
2958
2959                 rc.isp_use_esc_chars = static_cast<bool>(button);
2960                 rc.isp_esc_chars = choice;
2961
2962                 button = fl_get_button(dialog_->check_personal_dict);
2963                 choice = getString(dialog_->input_personal_dict);
2964                 if (button && choice.empty()) button = 0;
2965                 if (!button) choice.erase();
2966
2967                 rc.isp_use_pers_dict = static_cast<bool>(button);
2968                 rc.isp_pers_dict = choice;
2969
2970                 button = fl_get_button(dialog_->check_compound_words);
2971                 rc.isp_accept_compound = static_cast<bool>(button);
2972
2973                 button = fl_get_button(dialog_->check_input_enc);
2974                 rc.isp_use_input_encoding = static_cast<bool>(button);
2975 #endif
2976 #if 0
2977         }
2978 #endif
2979
2980         // Reset view
2981         update(rc);
2982 }
2983
2984
2985 void FormPreferences::SpellOptions::build()
2986 {
2987         dialog_.reset(build_preferences_spelloptions(&parent_));
2988
2989         fl_addto_choice(dialog_->choice_spell_command,
2990                         _(" ispell | aspell ").c_str());
2991         fl_set_input_return(dialog_->input_alt_lang,      FL_RETURN_CHANGED);
2992         fl_set_input_return(dialog_->input_escape_chars,  FL_RETURN_CHANGED);
2993         fl_set_input_return(dialog_->input_personal_dict, FL_RETURN_CHANGED);
2994
2995         // set up the feedback mechanism
2996         setPrehandler(dialog_->choice_spell_command);
2997         setPrehandler(dialog_->check_alt_lang);
2998         setPrehandler(dialog_->input_alt_lang);
2999         setPrehandler(dialog_->check_escape_chars);
3000         setPrehandler(dialog_->input_escape_chars);
3001         setPrehandler(dialog_->check_personal_dict);
3002         setPrehandler(dialog_->input_personal_dict);
3003         setPrehandler(dialog_->button_personal_dict);
3004         setPrehandler(dialog_->check_compound_words);
3005         setPrehandler(dialog_->check_input_enc);
3006 }
3007
3008
3009 string const
3010 FormPreferences::SpellOptions::feedback(FL_OBJECT const * const ob) const
3011 {
3012         if (ob == dialog_->choice_spell_command)
3013                 return LyXRC::getDescription(LyXRC::RC_SPELL_COMMAND);
3014         if (ob == dialog_->check_alt_lang)
3015                 return LyXRC::getDescription(LyXRC::RC_USE_ALT_LANG);
3016         if (ob == dialog_->input_alt_lang)
3017                 return LyXRC::getDescription(LyXRC::RC_ALT_LANG);
3018         if (ob == dialog_->check_escape_chars)
3019                 return LyXRC::getDescription(LyXRC::RC_USE_ESC_CHARS);
3020         if (ob == dialog_->input_escape_chars)
3021                 return LyXRC::getDescription(LyXRC::RC_ESC_CHARS);
3022         if (ob == dialog_->check_personal_dict)
3023                 return LyXRC::getDescription(LyXRC::RC_USE_PERS_DICT);
3024         if (ob == dialog_->input_personal_dict)
3025                 return LyXRC::getDescription(LyXRC::RC_PERS_DICT);
3026         if (ob == dialog_->check_compound_words)
3027                 return LyXRC::getDescription(LyXRC::RC_ACCEPT_COMPOUND);
3028         if (ob == dialog_->check_input_enc)
3029                 return LyXRC::getDescription(LyXRC::RC_USE_INP_ENC);
3030         return string();
3031 }
3032
3033
3034 bool FormPreferences::SpellOptions::input(FL_OBJECT const * const ob)
3035 {
3036         // !ob if function is called from updateSpellOptions() to de/activate
3037         // objects,
3038         // otherwise the function is called by an xforms CB via input().
3039
3040 #if 0
3041         // If spell checker == "none", disable all input.
3042         if (!ob || ob == dialog_->choice_spell_command) {
3043                 if (fl_get_choice(dialog_->choice_spell_command) == 1) {
3044                         fl_deactivate_object(dialog_->check_alt_lang);
3045                         fl_deactivate_object(dialog_->input_alt_lang);
3046                         fl_deactivate_object(dialog_->check_escape_chars);
3047                         fl_deactivate_object(dialog_->input_escape_chars);
3048                         fl_deactivate_object(dialog_->check_personal_dict);
3049                         fl_deactivate_object(dialog_->input_personal_dict);
3050                         fl_deactivate_object(dialog_->check_compound_words);
3051                         fl_deactivate_object(dialog_->check_input_enc);
3052                         return true;
3053                 } else {
3054                         fl_activate_object(dialog_->check_alt_lang);
3055                         fl_activate_object(dialog_->check_escape_chars);
3056                         fl_activate_object(dialog_->check_personal_dict);
3057                         fl_activate_object(dialog_->check_compound_words);
3058                         fl_activate_object(dialog_->check_input_enc);
3059                 }
3060         }
3061 #endif
3062
3063         if (!ob || ob == dialog_->check_alt_lang) {
3064                 bool const enable = fl_get_button(dialog_->check_alt_lang);
3065                 setEnabled(dialog_->input_alt_lang, enable);
3066         }
3067
3068         if (!ob || ob == dialog_->check_escape_chars) {
3069                 bool const enable = fl_get_button(dialog_->check_escape_chars);
3070                 setEnabled(dialog_->input_escape_chars, enable);
3071         }
3072
3073         if (!ob || ob == dialog_->check_personal_dict) {
3074                 bool const enable = fl_get_button(dialog_->check_personal_dict);
3075                 setEnabled(dialog_->input_personal_dict, enable);
3076         }
3077
3078         if (ob == dialog_->button_personal_dict) {
3079                 string f = parent_.controller().browsedict(
3080                         getString(dialog_->input_personal_dict));
3081                 fl_set_input(dialog_->input_personal_dict, f.c_str());
3082         }
3083
3084         return true; // All input is valid!
3085 }
3086
3087
3088 void FormPreferences::SpellOptions::update(LyXRC const & rc)
3089 {
3090         int choice = 1;
3091 #if 0
3092         if (rc.isp_command == "none")
3093                 choice = 1;
3094         else if (rc.isp_command == "ispell")
3095                 choice = 2;
3096         else if (rc.isp_command == "aspell")
3097                 choice = 3;
3098 #else
3099         if (rc.isp_command == "ispell")
3100                 choice = 1;
3101         else if (rc.isp_command == "aspell")
3102                 choice = 2;
3103 #endif
3104         fl_set_choice(dialog_->choice_spell_command, choice);
3105
3106         string str;
3107         if (rc.isp_use_alt_lang)
3108                 str = rc.isp_alt_lang;
3109
3110         fl_set_button(dialog_->check_alt_lang,
3111                       rc.isp_use_alt_lang);
3112         fl_set_input(dialog_->input_alt_lang, str.c_str());
3113
3114         str.erase();
3115         if (rc.isp_use_esc_chars)
3116                 str = rc.isp_esc_chars;
3117
3118         fl_set_button(dialog_->check_escape_chars,
3119                       rc.isp_use_esc_chars);
3120         fl_set_input(dialog_->input_escape_chars, str.c_str());
3121
3122         str.erase();
3123         if (rc.isp_use_pers_dict)
3124                 str = rc.isp_pers_dict;
3125
3126         fl_set_button(dialog_->check_personal_dict,
3127                       rc.isp_use_pers_dict);
3128         fl_set_input(dialog_->input_personal_dict, str.c_str());
3129
3130         fl_set_button(dialog_->check_compound_words,
3131                       rc.isp_accept_compound);
3132         fl_set_button(dialog_->check_input_enc,
3133                       rc.isp_use_input_encoding);
3134
3135         // Activate/Deactivate the input fields dependent on the state of the
3136         // buttons.
3137         input(0);
3138 }
3139
3140 } // namespace frontend
3141 } // namespace lyx