src/frontends/qt4/GuiDocument.cpp

   1 /**
   2  * \file GuiDocument.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Edwin Leuven
   7  * \author Richard Heck (modules)
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "GuiDocument.h"
  15
  16 #include "GuiApplication.h"
  17 #include "GuiBranches.h"
  18 #include "GuiIndices.h"
  19 #include "GuiSelectionManager.h"
  20 #include "LaTeXHighlighter.h"
  21 #include "LengthCombo.h"
  22 #include "PanelStack.h"
  23 #include "Validator.h"
  24
  25 #include "LayoutFile.h"
  26 #include "BranchList.h"
  27 #include "buffer_funcs.h"
  28 #include "Buffer.h"
  29 #include "BufferParams.h"
  30 #include "BufferView.h"
  31 #include "Color.h"
  32 #include "ColorCache.h"
  33 #include "Encoding.h"
  34 #include "FloatPlacement.h"
  35 #include "Format.h"
  36 #include "FuncRequest.h"
  37 #include "HSpace.h"
  38 #include "IndicesList.h"
  39 #include "Language.h"
  40 #include "LaTeXFeatures.h"
  41 #include "Layout.h"
  42 #include "LayoutModuleList.h"
  43 #include "LyXRC.h"
  44 #include "ModuleList.h"
  45 #include "OutputParams.h"
  46 #include "PDFOptions.h"
  47 #include "qt_helpers.h"
  48 #include "Spacing.h"
  49 #include "TextClass.h"
  50
  51 #include "insets/InsetListingsParams.h"
  52
  53 #include "support/debug.h"
  54 #include "support/FileName.h"
  55 #include "support/filetools.h"
  56 #include "support/gettext.h"
  57 #include "support/lstrings.h"
  58
  59 #include "frontends/alert.h"
  60
  61 #include <QAbstractItemModel>
  62 #include <QHeaderView>
  63 #include <QColor>
  64 #include <QColorDialog>
  65 #include <QCloseEvent>
  66 #include <QFontDatabase>
  67 #include <QScrollBar>
  68 #include <QTextCursor>
  69
  70 #include <sstream>
  71 #include <vector>
  72
  73 #ifdef IN
  74 #undef IN
  75 #endif
  76
  77
  78 // a style sheet for buttons
  79 // this is for example used for the background color setting button
  80 static inline QString colorButtonStyleSheet(QColor const & bgColor)
  81 {
  82         if (bgColor.isValid()) {
  83                 QString rc = QLatin1String("background-color:");
  84                 rc += bgColor.name();
  85                 return rc;
  86         }
  87         return QString();
  88 }
  89
  90
  91 using namespace std;
  92 using namespace lyx::support;
  93
  94
  95 namespace {
  96
  97 char const * const tex_graphics[] =
  98 {
  99         "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
 100         "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
 101         "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
 102         "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
 103         "xetex", "none", ""
 104 };
 105
 106
 107 char const * const tex_graphics_gui[] =
 108 {
 109         N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
 110         "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
 111         "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
 112         "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
 113         "XeTeX", N_("None"), ""
 114 };
 115
 116
 117 char const * const tex_fonts_roman[] =
 118 {
 119         "default", "cmr", "lmodern", "ae", "times", "palatino",
 120         "charter", "newcent", "bookman", "utopia", "beraserif",
 121         "ccfonts", "chancery", ""
 122 };
 123
 124
 125 char const * tex_fonts_roman_gui[] =
 126 {
 127         N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
 128         N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
 129         N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
 130         N_("Utopia"),  N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
 131         ""
 132 };
 133
 134
 135 char const * const tex_fonts_sans[] =
 136 {
 137         "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
 138 };
 139
 140
 141 char const * tex_fonts_sans_gui[] =
 142 {
 143         N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
 144         N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
 145 };
 146
 147
 148 char const * const tex_fonts_monospaced[] =
 149 {
 150         "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
 151 };
 152
 153
 154 char const * tex_fonts_monospaced_gui[] =
 155 {
 156         N_("Default"), N_("Computer Modern Typewriter"),
 157         N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
 158         N_("LuxiMono"), N_("CM Typewriter Light"), ""
 159 };
 160
 161
 162 char const * backref_opts[] =
 163 {
 164         "false", "section", "slide", "page", ""
 165 };
 166
 167
 168 char const * backref_opts_gui[] =
 169 {
 170         N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
 171 };
 172
 173
 174 vector<pair<string, QString> > pagestyles;
 175
 176
 177 } // anonymous namespace
 178
 179 namespace lyx {
 180
 181 RGBColor set_backgroundcolor;
 182 bool is_backgroundcolor;
 183 RGBColor set_fontcolor;
 184 bool is_fontcolor;
 185 RGBColor set_notefontcolor;
 186 RGBColor set_boxbgcolor;
 187
 188 namespace {
 189 // used when sorting the textclass list.
 190 class less_textclass_avail_desc
 191         : public binary_function<string, string, int>
 192 {
 193 public:
 194         bool operator()(string const & lhs, string const & rhs) const
 195         {
 196                 // Ordering criteria:
 197                 //   1. Availability of text class
 198                 //   2. Description (lexicographic)
 199                 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
 200                 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
 201                 int const order = compare_no_case(
 202                         translateIfPossible(from_utf8(tc1.description())),
 203                         translateIfPossible(from_utf8(tc2.description())));
 204                 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
 205                         (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
 206         }
 207 };
 208
 209 }
 210
 211 namespace frontend {
 212 namespace {
 213
 214 vector<string> getRequiredList(string const & modName)
 215 {
 216         LyXModule const * const mod = theModuleList[modName];
 217         if (!mod)
 218                 return vector<string>(); //empty such thing
 219         return mod->getRequiredModules();
 220 }
 221
 222
 223 vector<string> getExcludedList(string const & modName)
 224 {
 225         LyXModule const * const mod = theModuleList[modName];
 226         if (!mod)
 227                 return vector<string>(); //empty such thing
 228         return mod->getExcludedModules();
 229 }
 230
 231
 232 docstring getModuleDescription(string const & modName)
 233 {
 234         LyXModule const * const mod = theModuleList[modName];
 235         if (!mod)
 236                 return _("Module not found!");
 237         // FIXME Unicode
 238         return translateIfPossible(from_utf8(mod->getDescription()));
 239 }
 240
 241
 242 vector<string> getPackageList(string const & modName)
 243 {
 244         LyXModule const * const mod = theModuleList[modName];
 245         if (!mod)
 246                 return vector<string>(); //empty such thing
 247         return mod->getPackageList();
 248 }
 249
 250
 251 bool isModuleAvailable(string const & modName)
 252 {
 253         LyXModule const * const mod = theModuleList[modName];
 254         if (!mod)
 255                 return false;
 256         return mod->isAvailable();
 257 }
 258
 259 } // anonymous namespace
 260
 261
 262 /////////////////////////////////////////////////////////////////////
 263 //
 264 // ModuleSelectionManager
 265 //
 266 /////////////////////////////////////////////////////////////////////
 267
 268 /// SelectionManager for use with modules
 269 class ModuleSelectionManager : public GuiSelectionManager
 270 {
 271 public:
 272         ///
 273         ModuleSelectionManager(
 274                 QTreeView * availableLV,
 275                 QListView * selectedLV,
 276                 QPushButton * addPB,
 277                 QPushButton * delPB,
 278                 QPushButton * upPB,
 279                 QPushButton * downPB,
 280                 GuiIdListModel * availableModel,
 281                 GuiIdListModel * selectedModel,
 282                 GuiDocument const * container)
 283         : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
 284                                 upPB, downPB, availableModel, selectedModel), container_(container)
 285                 {}
 286         ///
 287         void updateProvidedModules(LayoutModuleList const & pm)
 288                         { provided_modules_ = pm.list(); }
 289         ///
 290         void updateExcludedModules(LayoutModuleList const & em)
 291                         { excluded_modules_ = em.list(); }
 292 private:
 293         ///
 294         virtual void updateAddPB();
 295         ///
 296         virtual void updateUpPB();
 297         ///
 298         virtual void updateDownPB();
 299         ///
 300         virtual void updateDelPB();
 301         /// returns availableModel as a GuiIdListModel
 302         GuiIdListModel * getAvailableModel()
 303         {
 304                 return dynamic_cast<GuiIdListModel *>(availableModel);
 305         }
 306         /// returns selectedModel as a GuiIdListModel
 307         GuiIdListModel * getSelectedModel()
 308         {
 309                 return dynamic_cast<GuiIdListModel *>(selectedModel);
 310         }
 311         /// keeps a list of the modules the text class provides
 312         list<string> provided_modules_;
 313         /// similarly...
 314         list<string> excluded_modules_;
 315         ///
 316         GuiDocument const * container_;
 317 };
 318
 319 void ModuleSelectionManager::updateAddPB()
 320 {
 321         int const arows = availableModel->rowCount();
 322         QModelIndexList const avail_sels =
 323                         availableLV->selectionModel()->selectedIndexes();
 324
 325         // disable if there aren't any modules (?), if none of them is chosen
 326         // in the dialog, or if the chosen one is already selected for use.
 327         if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
 328                 addPB->setEnabled(false);
 329                 return;
 330         }
 331
 332         QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
 333         string const modname = getAvailableModel()->getIDString(idx.row());
 334
 335         bool const enable =
 336                 container_->params().moduleCanBeAdded(modname);
 337         addPB->setEnabled(enable);
 338 }
 339
 340
 341 void ModuleSelectionManager::updateDownPB()
 342 {
 343         int const srows = selectedModel->rowCount();
 344         if (srows == 0) {
 345                 downPB->setEnabled(false);
 346                 return;
 347         }
 348         QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
 349         int const curRow = curidx.row();
 350         if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
 351                 downPB->setEnabled(false);
 352                 return;
 353         }
 354
 355         // determine whether immediately succeding element requires this one
 356         string const curmodname = getSelectedModel()->getIDString(curRow);
 357         string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
 358
 359         vector<string> reqs = getRequiredList(nextmodname);
 360
 361         // if it doesn't require anything....
 362         if (reqs.empty()) {
 363                 downPB->setEnabled(true);
 364                 return;
 365         }
 366
 367         // Enable it if this module isn't required.
 368         // FIXME This should perhaps be more flexible and check whether, even
 369         // if the next one is required, there is also an earlier one that will do.
 370         downPB->setEnabled(
 371                         find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
 372 }
 373
 374 void ModuleSelectionManager::updateUpPB()
 375 {
 376         int const srows = selectedModel->rowCount();
 377         if (srows == 0) {
 378                 upPB->setEnabled(false);
 379                 return;
 380         }
 381
 382         QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
 383         int curRow = curIdx.row();
 384         if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
 385                 upPB->setEnabled(false);
 386                 return;
 387         }
 388         string const curmodname = getSelectedModel()->getIDString(curRow);
 389
 390         // determine whether immediately preceding element is required by this one
 391         vector<string> reqs = getRequiredList(curmodname);
 392
 393         // if this one doesn't require anything....
 394         if (reqs.empty()) {
 395                 upPB->setEnabled(true);
 396                 return;
 397         }
 398
 399
 400         // Enable it if the preceding module isn't required.
 401         // NOTE This is less flexible than it might be. We could check whether, even
 402         // if the previous one is required, there is an earlier one that would do.
 403         string const premod = getSelectedModel()->getIDString(curRow - 1);
 404         upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
 405 }
 406
 407 void ModuleSelectionManager::updateDelPB()
 408 {
 409         int const srows = selectedModel->rowCount();
 410         if (srows == 0) {
 411                 deletePB->setEnabled(false);
 412                 return;
 413         }
 414
 415         QModelIndex const & curidx =
 416                 selectedLV->selectionModel()->currentIndex();
 417         int const curRow = curidx.row();
 418         if (curRow < 0 || curRow >= srows) { // invalid index?
 419                 deletePB->setEnabled(false);
 420                 return;
 421         }
 422
 423         string const curmodname = getSelectedModel()->getIDString(curRow);
 424
 425         // We're looking here for a reason NOT to enable the button. If we
 426         // find one, we disable it and return. If we don't, we'll end up at
 427         // the end of the function, and then we enable it.
 428         for (int i = curRow + 1; i < srows; ++i) {
 429                 string const thisMod = getSelectedModel()->getIDString(i);
 430                 vector<string> reqs = getRequiredList(thisMod);
 431                 //does this one require us?
 432                 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
 433                         //no...
 434                         continue;
 435
 436                 // OK, so this module requires us
 437                 // is there an EARLIER module that also satisfies the require?
 438                 // NOTE We demand that it be earlier to keep the list of modules
 439                 // consistent with the rule that a module must be proceeded by a
 440                 // required module. There would be more flexible ways to proceed,
 441                 // but that would be a lot more complicated, and the logic here is
 442                 // already complicated. (That's why I've left the debugging code.)
 443                 // lyxerr << "Testing " << thisMod << endl;
 444                 bool foundone = false;
 445                 for (int j = 0; j < curRow; ++j) {
 446                         string const mod = getSelectedModel()->getIDString(j);
 447                         // lyxerr << "In loop: Testing " << mod << endl;
 448                         // do we satisfy the require?
 449                         if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
 450                                 // lyxerr << mod << " does the trick." << endl;
 451                                 foundone = true;
 452                                 break;
 453                         }
 454                 }
 455                 // did we find a module to satisfy the require?
 456                 if (!foundone) {
 457                         // lyxerr << "No matching module found." << endl;
 458                         deletePB->setEnabled(false);
 459                         return;
 460                 }
 461         }
 462         // lyxerr << "All's well that ends well." << endl;
 463         deletePB->setEnabled(true);
 464 }
 465
 466
 467 /////////////////////////////////////////////////////////////////////
 468 //
 469 // PreambleModule
 470 //
 471 /////////////////////////////////////////////////////////////////////
 472
 473 PreambleModule::PreambleModule() : current_id_(0)
 474 {
 475         // This is not a memory leak. The object will be destroyed
 476         // with this.
 477         (void) new LaTeXHighlighter(preambleTE->document());
 478         setFocusProxy(preambleTE);
 479         connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
 480 }
 481
 482
 483 void PreambleModule::update(BufferParams const & params, BufferId id)
 484 {
 485         QString preamble = toqstr(params.preamble);
 486         // Nothing to do if the params and preamble are unchanged.
 487         if (id == current_id_
 488                 && preamble == preambleTE->document()->toPlainText())
 489                 return;
 490
 491         QTextCursor cur = preambleTE->textCursor();
 492         // Save the coords before switching to the new one.
 493         preamble_coords_[current_id_] =
 494                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 495
 496         // Save the params address for further use.
 497         current_id_ = id;
 498         preambleTE->document()->setPlainText(preamble);
 499         Coords::const_iterator it = preamble_coords_.find(current_id_);
 500         if (it == preamble_coords_.end())
 501                 // First time we open this one.
 502                 preamble_coords_[current_id_] = make_pair(0, 0);
 503         else {
 504                 // Restore saved coords.
 505                 QTextCursor cur = preambleTE->textCursor();
 506                 cur.setPosition(it->second.first);
 507                 preambleTE->setTextCursor(cur);
 508                 preambleTE->verticalScrollBar()->setValue(it->second.second);
 509         }
 510 }
 511
 512
 513 void PreambleModule::apply(BufferParams & params)
 514 {
 515         params.preamble = fromqstr(preambleTE->document()->toPlainText());
 516 }
 517
 518
 519 void PreambleModule::closeEvent(QCloseEvent * e)
 520 {
 521         // Save the coords before closing.
 522         QTextCursor cur = preambleTE->textCursor();
 523         preamble_coords_[current_id_] =
 524                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 525         e->accept();
 526 }
 527
 528
 529 /////////////////////////////////////////////////////////////////////
 530 //
 531 // LocalLayout
 532 //
 533 /////////////////////////////////////////////////////////////////////
 534
 535
 536 LocalLayout::LocalLayout() : current_id_(0), is_valid_(false)
 537 {
 538         connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
 539         connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
 540         connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
 541 }
 542
 543
 544 void LocalLayout::update(BufferParams const & params, BufferId id)
 545 {
 546         QString layout = toqstr(params.local_layout);
 547         // Nothing to do if the params and preamble are unchanged.
 548         if (id == current_id_
 549                 && layout == locallayoutTE->document()->toPlainText())
 550                 return;
 551
 552         // Save the params address for further use.
 553         current_id_ = id;
 554         locallayoutTE->document()->setPlainText(layout);
 555         validate();
 556 }
 557
 558
 559 void LocalLayout::apply(BufferParams & params)
 560 {
 561         string const layout = fromqstr(locallayoutTE->document()->toPlainText());
 562         params.local_layout = layout;
 563 }
 564
 565
 566 void LocalLayout::textChanged()
 567 {
 568         static const QString unknown = qt_("Press button to check validity...");
 569
 570         is_valid_ = false;
 571         validLB->setText(unknown);
 572         validatePB->setEnabled(true);
 573         convertPB->setEnabled(false);
 574         changed();
 575 }
 576
 577
 578 void LocalLayout::convert() {
 579         string const layout =
 580                 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
 581         string const newlayout = TextClass::convert(layout);
 582         LYXERR0(newlayout);
 583         if (newlayout.empty()) {
 584                 Alert::error(_("Conversion Failed!"),
 585                       _("Failed to convert local layout to current format."));
 586         } else {
 587                 locallayoutTE->setPlainText(toqstr(newlayout));
 588         }
 589         validate();
 590 }
 591
 592
 593 void LocalLayout::convertPressed() {
 594         convert();
 595         changed();
 596 }
 597
 598
 599 void LocalLayout::validate() {
 600         static const QString valid = qt_("Layout is valid!");
 601         static const QString vtext =
 602                 toqstr("<p style=\"font-weight: bold; \">")
 603                   + valid + toqstr("</p>");
 604         static const QString invalid = qt_("Layout is invalid!");
 605         static const QString ivtext =
 606                 toqstr("<p style=\"color: #c00000; font-weight: bold; \">")
 607                   + invalid + toqstr("</p>");
 608
 609         string const layout =
 610                 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
 611         if (layout.empty()) {
 612                 is_valid_ = true;
 613                 validatePB->setEnabled(false);
 614                 validLB->setText("");
 615                 convertPB->hide();
 616                 convertLB->hide();
 617         } else {
 618                 TextClass::ReturnValues const ret = TextClass::validate(layout);
 619                 is_valid_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
 620                 validatePB->setEnabled(false);
 621                 validLB->setText(is_valid_ ? vtext : ivtext);
 622                 if (ret == TextClass::OK_OLDFORMAT) {
 623                         convertPB->show();
 624                         convertPB->setEnabled(true);
 625                         convertLB->setText(qt_("Convert to current format"));
 626                         convertLB->show();
 627                 } else {
 628                         convertPB->hide();
 629                         convertLB->hide();
 630                 }
 631         }
 632 }
 633
 634
 635 void LocalLayout::validatePressed() {
 636         validate();
 637         changed();
 638 }
 639
 640
 641 /////////////////////////////////////////////////////////////////////
 642 //
 643 // DocumentDialog
 644 //
 645 /////////////////////////////////////////////////////////////////////
 646
 647
 648 GuiDocument::GuiDocument(GuiView & lv)
 649         : GuiDialog(lv, "document", qt_("Document Settings"))
 650 {
 651         setupUi(this);
 652
 653         connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
 654         connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
 655         connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
 656         connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
 657
 658         connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
 659         connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
 660
 661         // Manage the restore, ok, apply, restore and cancel/close buttons
 662         bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
 663         bc().setOK(okPB);
 664         bc().setApply(applyPB);
 665         bc().setCancel(closePB);
 666         bc().setRestore(restorePB);
 667
 668
 669         // text layout
 670         textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
 671         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 672                 this, SLOT(change_adaptor()));
 673         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 674                 this, SLOT(setLSpacing(int)));
 675         connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
 676                 this, SLOT(change_adaptor()));
 677
 678         connect(textLayoutModule->indentRB, SIGNAL(clicked()),
 679                 this, SLOT(change_adaptor()));
 680         connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
 681                 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
 682         connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
 683                 this, SLOT(change_adaptor()));
 684         connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
 685                 this, SLOT(setIndent(int)));
 686         connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
 687                 this, SLOT(change_adaptor()));
 688         connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
 689                 this, SLOT(change_adaptor()));
 690
 691         connect(textLayoutModule->skipRB, SIGNAL(clicked()),
 692                 this, SLOT(change_adaptor()));
 693         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 694                 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
 695         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 696                 this, SLOT(change_adaptor()));
 697         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 698                 this, SLOT(setSkip(int)));
 699         connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
 700                 this, SLOT(change_adaptor()));
 701         connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
 702                 this, SLOT(change_adaptor()));
 703
 704         connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
 705                 this, SLOT(enableIndent(bool)));
 706         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 707                 this, SLOT(enableSkip(bool)));
 708
 709         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 710                 this, SLOT(change_adaptor()));
 711         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 712                 this, SLOT(setColSep()));
 713
 714         textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
 715                 textLayoutModule->lspacingLE));
 716         textLayoutModule->indentLE->setValidator(unsignedLengthValidator(
 717                 textLayoutModule->indentLE));
 718         textLayoutModule->skipLE->setValidator(unsignedGlueLengthValidator(
 719                 textLayoutModule->skipLE));
 720
 721         textLayoutModule->indentCO->addItem(qt_("Default"));
 722         textLayoutModule->indentCO->addItem(qt_("Custom"));
 723         textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
 724         textLayoutModule->skipCO->addItem(qt_("MedSkip"));
 725         textLayoutModule->skipCO->addItem(qt_("BigSkip"));
 726         textLayoutModule->skipCO->addItem(qt_("Custom"));
 727         textLayoutModule->lspacingCO->insertItem(
 728                 Spacing::Single, qt_("Single"));
 729         textLayoutModule->lspacingCO->insertItem(
 730                 Spacing::Onehalf, qt_("OneHalf"));
 731         textLayoutModule->lspacingCO->insertItem(
 732                 Spacing::Double, qt_("Double"));
 733         textLayoutModule->lspacingCO->insertItem(
 734                 Spacing::Other, qt_("Custom"));
 735         // initialize the length validator
 736         bc().addCheckedLineEdit(textLayoutModule->indentLE);
 737         bc().addCheckedLineEdit(textLayoutModule->skipLE);
 738
 739
 740         // master/child handling
 741         masterChildModule = new UiWidget<Ui::MasterChildUi>;
 742
 743         connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
 744                 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
 745         connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
 746                 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
 747         connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
 748                 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
 749         connect(masterChildModule->includeallRB, SIGNAL(clicked()),
 750                 this, SLOT(change_adaptor()));
 751         connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
 752                 this, SLOT(change_adaptor()));
 753         connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
 754                 this, SLOT(change_adaptor()));
 755         masterChildModule->childrenTW->setColumnCount(2);
 756         masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
 757         masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
 758         masterChildModule->childrenTW->resizeColumnToContents(1);
 759         masterChildModule->childrenTW->resizeColumnToContents(2);
 760
 761
 762         // output
 763         outputModule = new UiWidget<Ui::OutputUi>;
 764
 765         connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
 766                 this, SLOT(change_adaptor()));
 767         connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
 768                 this, SLOT(change_adaptor()));
 769         connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
 770                 this, SLOT(change_adaptor()));
 771         connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
 772                 this, SLOT(change_adaptor()));
 773
 774         connect(outputModule->outputsyncCB, SIGNAL(clicked()),
 775                 this, SLOT(change_adaptor()));
 776         connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
 777                 this, SLOT(change_adaptor()));
 778         outputModule->synccustomCB->addItem("");
 779         outputModule->synccustomCB->addItem("\\synctex=1");
 780         outputModule->synccustomCB->addItem("\\synctex=-1");
 781         outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
 782
 783         outputModule->synccustomCB->setValidator(new NoNewLineValidator(
 784                 outputModule->synccustomCB));
 785
 786         // fonts
 787         fontModule = new UiWidget<Ui::FontUi>;
 788         connect(fontModule->osFontsCB, SIGNAL(clicked()),
 789                 this, SLOT(change_adaptor()));
 790         connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
 791                 this, SLOT(osFontsChanged(bool)));
 792         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 793                 this, SLOT(change_adaptor()));
 794         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 795                 this, SLOT(romanChanged(int)));
 796         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 797                 this, SLOT(change_adaptor()));
 798         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 799                 this, SLOT(sansChanged(int)));
 800         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 801                 this, SLOT(change_adaptor()));
 802         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 803                 this, SLOT(ttChanged(int)));
 804         connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
 805                 this, SLOT(change_adaptor()));
 806         connect(fontModule->fontencCO, SIGNAL(activated(int)),
 807                 this, SLOT(change_adaptor()));
 808         connect(fontModule->fontencCO, SIGNAL(activated(int)),
 809                 this, SLOT(fontencChanged(int)));
 810         connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
 811                 this, SLOT(change_adaptor()));
 812         connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
 813                 this, SLOT(change_adaptor()));
 814         connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
 815                 this, SLOT(change_adaptor()));
 816         connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
 817                 this, SLOT(change_adaptor()));
 818         connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
 819                 this, SLOT(change_adaptor()));
 820         connect(fontModule->fontScCB, SIGNAL(clicked()),
 821                 this, SLOT(change_adaptor()));
 822         connect(fontModule->fontOsfCB, SIGNAL(clicked()),
 823                 this, SLOT(change_adaptor()));
 824
 825         fontModule->fontencLE->setValidator(new NoNewLineValidator(
 826                 fontModule->fontencLE));
 827         fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
 828                 fontModule->cjkFontLE));
 829
 830         updateFontlist();
 831
 832         fontModule->fontsizeCO->addItem(qt_("Default"));
 833         fontModule->fontsizeCO->addItem(qt_("10"));
 834         fontModule->fontsizeCO->addItem(qt_("11"));
 835         fontModule->fontsizeCO->addItem(qt_("12"));
 836
 837         fontModule->fontencCO->addItem(qt_("Default"));
 838         fontModule->fontencCO->addItem(qt_("Custom"));
 839         fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
 840
 841         for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
 842                 fontModule->fontsDefaultCO->addItem(
 843                         qt_(GuiDocument::fontfamilies_gui[n]));
 844
 845         if (!LaTeXFeatures::isAvailable("fontspec"))
 846                 fontModule->osFontsCB->setToolTip(
 847                         qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
 848                             "You need to install the package \"fontspec\" to use this feature"));
 849
 850
 851         // page layout
 852         pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
 853         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 854                 this, SLOT(papersizeChanged(int)));
 855         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 856                 this, SLOT(papersizeChanged(int)));
 857         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 858                 this, SLOT(change_adaptor()));
 859         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 860                 this, SLOT(change_adaptor()));
 861         connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
 862                 this, SLOT(change_adaptor()));
 863         connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
 864                 this, SLOT(change_adaptor()));
 865         connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
 866                 this, SLOT(change_adaptor()));
 867         connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
 868                 this, SLOT(change_adaptor()));
 869         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 870                 this, SLOT(change_adaptor()));
 871         connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
 872                 this, SLOT(change_adaptor()));
 873         connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
 874                 this, SLOT(change_adaptor()));
 875         connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
 876                 this, SLOT(change_adaptor()));
 877
 878         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
 879         pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
 880         pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
 881         pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
 882         pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
 883         bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
 884                 pageLayoutModule->paperheightL);
 885         bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
 886                 pageLayoutModule->paperwidthL);
 887
 888         QComboBox * cb = pageLayoutModule->papersizeCO;
 889         cb->addItem(qt_("Default"));
 890         cb->addItem(qt_("Custom"));
 891         cb->addItem(qt_("US letter"));
 892         cb->addItem(qt_("US legal"));
 893         cb->addItem(qt_("US executive"));
 894         cb->addItem(qt_("A0"));
 895         cb->addItem(qt_("A1"));
 896         cb->addItem(qt_("A2"));
 897         cb->addItem(qt_("A3"));
 898         cb->addItem(qt_("A4"));
 899         cb->addItem(qt_("A5"));
 900         cb->addItem(qt_("A6"));
 901         cb->addItem(qt_("B0"));
 902         cb->addItem(qt_("B1"));
 903         cb->addItem(qt_("B2"));
 904         cb->addItem(qt_("B3"));
 905         cb->addItem(qt_("B4"));
 906         cb->addItem(qt_("B5"));
 907         cb->addItem(qt_("B6"));
 908         cb->addItem(qt_("C0"));
 909         cb->addItem(qt_("C1"));
 910         cb->addItem(qt_("C2"));
 911         cb->addItem(qt_("C3"));
 912         cb->addItem(qt_("C4"));
 913         cb->addItem(qt_("C5"));
 914         cb->addItem(qt_("C6"));
 915         cb->addItem(qt_("JIS B0"));
 916         cb->addItem(qt_("JIS B1"));
 917         cb->addItem(qt_("JIS B2"));
 918         cb->addItem(qt_("JIS B3"));
 919         cb->addItem(qt_("JIS B4"));
 920         cb->addItem(qt_("JIS B5"));
 921         cb->addItem(qt_("JIS B6"));
 922         // remove the %-items from the unit choice
 923         pageLayoutModule->paperwidthUnitCO->noPercents();
 924         pageLayoutModule->paperheightUnitCO->noPercents();
 925         pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
 926                 pageLayoutModule->paperheightLE));
 927         pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
 928                 pageLayoutModule->paperwidthLE));
 929
 930
 931         // margins
 932         marginsModule = new UiWidget<Ui::MarginsUi>;
 933         connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
 934                 this, SLOT(setCustomMargins(bool)));
 935         connect(marginsModule->marginCB, SIGNAL(clicked()),
 936                 this, SLOT(change_adaptor()));
 937         connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
 938                 this, SLOT(change_adaptor()));
 939         connect(marginsModule->topUnit, SIGNAL(activated(int)),
 940                 this, SLOT(change_adaptor()));
 941         connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
 942                 this, SLOT(change_adaptor()));
 943         connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
 944                 this, SLOT(change_adaptor()));
 945         connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
 946                 this, SLOT(change_adaptor()));
 947         connect(marginsModule->innerUnit, SIGNAL(activated(int)),
 948                 this, SLOT(change_adaptor()));
 949         connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
 950                 this, SLOT(change_adaptor()));
 951         connect(marginsModule->outerUnit, SIGNAL(activated(int)),
 952                 this, SLOT(change_adaptor()));
 953         connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
 954                 this, SLOT(change_adaptor()));
 955         connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
 956                 this, SLOT(change_adaptor()));
 957         connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
 958                 this, SLOT(change_adaptor()));
 959         connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
 960                 this, SLOT(change_adaptor()));
 961         connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
 962                 this, SLOT(change_adaptor()));
 963         connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
 964                 this, SLOT(change_adaptor()));
 965         connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
 966                 this, SLOT(change_adaptor()));
 967         connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
 968                 this, SLOT(change_adaptor()));
 969         marginsModule->topLE->setValidator(unsignedLengthValidator(
 970                 marginsModule->topLE));
 971         marginsModule->bottomLE->setValidator(unsignedLengthValidator(
 972                 marginsModule->bottomLE));
 973         marginsModule->innerLE->setValidator(unsignedLengthValidator(
 974                 marginsModule->innerLE));
 975         marginsModule->outerLE->setValidator(unsignedLengthValidator(
 976                 marginsModule->outerLE));
 977         marginsModule->headsepLE->setValidator(unsignedLengthValidator(
 978                 marginsModule->headsepLE));
 979         marginsModule->headheightLE->setValidator(unsignedLengthValidator(
 980                 marginsModule->headheightLE));
 981         marginsModule->footskipLE->setValidator(unsignedLengthValidator(
 982                 marginsModule->footskipLE));
 983         marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
 984                 marginsModule->columnsepLE));
 985
 986         bc().addCheckedLineEdit(marginsModule->topLE,
 987                 marginsModule->topL);
 988         bc().addCheckedLineEdit(marginsModule->bottomLE,
 989                 marginsModule->bottomL);
 990         bc().addCheckedLineEdit(marginsModule->innerLE,
 991                 marginsModule->innerL);
 992         bc().addCheckedLineEdit(marginsModule->outerLE,
 993                 marginsModule->outerL);
 994         bc().addCheckedLineEdit(marginsModule->headsepLE,
 995                 marginsModule->headsepL);
 996         bc().addCheckedLineEdit(marginsModule->headheightLE,
 997                 marginsModule->headheightL);
 998         bc().addCheckedLineEdit(marginsModule->footskipLE,
 999                 marginsModule->footskipL);
1000         bc().addCheckedLineEdit(marginsModule->columnsepLE,
1001                 marginsModule->columnsepL);
1002
1003
1004         // language & quote
1005         langModule = new UiWidget<Ui::LanguageUi>;
1006         connect(langModule->languageCO, SIGNAL(activated(int)),
1007                 this, SLOT(change_adaptor()));
1008         connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1009                 this, SLOT(change_adaptor()));
1010         connect(langModule->otherencodingRB, SIGNAL(clicked()),
1011                 this, SLOT(change_adaptor()));
1012         connect(langModule->encodingCO, SIGNAL(activated(int)),
1013                 this, SLOT(change_adaptor()));
1014         connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1015                 this, SLOT(change_adaptor()));
1016         connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1017                 this, SLOT(change_adaptor()));
1018         connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1019                 this, SLOT(change_adaptor()));
1020         connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1021                 this, SLOT(languagePackageChanged(int)));
1022
1023         langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1024                 langModule->languagePackageLE));
1025
1026         QAbstractItemModel * language_model = guiApp->languageModel();
1027         // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1028         language_model->sort(0);
1029         langModule->languageCO->setModel(language_model);
1030         langModule->languageCO->setModelColumn(0);
1031
1032         // Always put the default encoding in the first position.
1033         langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1034         QStringList encodinglist;
1035         Encodings::const_iterator it = encodings.begin();
1036         Encodings::const_iterator const end = encodings.end();
1037         for (; it != end; ++it)
1038                 encodinglist.append(qt_(it->guiName()));
1039         encodinglist.sort();
1040         langModule->encodingCO->addItems(encodinglist);
1041
1042         langModule->quoteStyleCO->addItem(qt_("``text''"));
1043         langModule->quoteStyleCO->addItem(qt_("''text''"));
1044         langModule->quoteStyleCO->addItem(qt_(",,text``"));
1045         langModule->quoteStyleCO->addItem(qt_(",,text''"));
1046         langModule->quoteStyleCO->addItem(qt_("<<text>>"));
1047         langModule->quoteStyleCO->addItem(qt_(">>text<<"));
1048
1049         langModule->languagePackageCO->addItem(
1050                 qt_("Default"), toqstr("default"));
1051         langModule->languagePackageCO->addItem(
1052                 qt_("Automatic"), toqstr("auto"));
1053         langModule->languagePackageCO->addItem(
1054                 qt_("Always Babel"), toqstr("babel"));
1055         langModule->languagePackageCO->addItem(
1056                 qt_("Custom"), toqstr("custom"));
1057         langModule->languagePackageCO->addItem(
1058                 qt_("None[[language package]]"), toqstr("none"));
1059
1060
1061         // color
1062         colorModule = new UiWidget<Ui::ColorUi>;
1063         connect(colorModule->fontColorPB, SIGNAL(clicked()),
1064                 this, SLOT(changeFontColor()));
1065         connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1066                 this, SLOT(deleteFontColor()));
1067         connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1068                 this, SLOT(changeNoteFontColor()));
1069         connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1070                 this, SLOT(deleteNoteFontColor()));
1071         connect(colorModule->backgroundPB, SIGNAL(clicked()),
1072                 this, SLOT(changeBackgroundColor()));
1073         connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1074                 this, SLOT(deleteBackgroundColor()));
1075         connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1076                 this, SLOT(changeBoxBackgroundColor()));
1077         connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1078                 this, SLOT(deleteBoxBackgroundColor()));
1079
1080
1081         // numbering
1082         numberingModule = new UiWidget<Ui::NumberingUi>;
1083         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1084                 this, SLOT(change_adaptor()));
1085         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1086                 this, SLOT(change_adaptor()));
1087         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1088                 this, SLOT(updateNumbering()));
1089         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1090                 this, SLOT(updateNumbering()));
1091         numberingModule->tocTW->setColumnCount(3);
1092         numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1093         numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1094         numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1095         numberingModule->tocTW->header()->setResizeMode(QHeaderView::ResizeToContents);
1096
1097
1098         // biblio
1099         biblioModule = new UiWidget<Ui::BiblioUi>;
1100         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1101                 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1102         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1103                 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1104         connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1105                 this, SLOT(change_adaptor()));
1106         connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1107                 this, SLOT(change_adaptor()));
1108         connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1109                 this, SLOT(change_adaptor()));
1110         connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1111                 this, SLOT(change_adaptor()));
1112         connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1113                 this, SLOT(change_adaptor()));
1114         connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1115                 this, SLOT(bibtexChanged(int)));
1116         connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1117                 this, SLOT(change_adaptor()));
1118
1119         biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1120                 biblioModule->bibtexOptionsLE));
1121
1122         biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1123         biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1124         biblioModule->citeStyleCO->setCurrentIndex(0);
1125
1126         // NOTE: we do not provide "custom" here for security reasons!
1127         biblioModule->bibtexCO->clear();
1128         biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1129         for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1130                              it != lyxrc.bibtex_alternatives.end(); ++it) {
1131                 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1132                 biblioModule->bibtexCO->addItem(command, command);
1133         }
1134
1135
1136         // indices
1137         indicesModule = new GuiIndices;
1138         connect(indicesModule, SIGNAL(changed()),
1139                 this, SLOT(change_adaptor()));
1140
1141
1142         // maths
1143         mathsModule = new UiWidget<Ui::MathsUi>;
1144         connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
1145                 mathsModule->amsCB, SLOT(setDisabled(bool)));
1146         connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
1147                 mathsModule->esintCB, SLOT(setDisabled(bool)));
1148         connect(mathsModule->mhchemautoCB, SIGNAL(toggled(bool)),
1149                 mathsModule->mhchemCB, SLOT(setDisabled(bool)));
1150         connect(mathsModule->mathdotsautoCB, SIGNAL(toggled(bool)),
1151                 mathsModule->mathdotsCB, SLOT(setDisabled(bool)));
1152         connect(mathsModule->undertildeautoCB, SIGNAL(toggled(bool)),
1153                 mathsModule->undertildeCB, SLOT(setDisabled(bool)));
1154
1155         connect(mathsModule->amsCB, SIGNAL(clicked()),
1156                 this, SLOT(change_adaptor()));
1157         connect(mathsModule->amsautoCB, SIGNAL(clicked()),
1158                 this, SLOT(change_adaptor()));
1159         connect(mathsModule->esintCB, SIGNAL(clicked()),
1160                 this, SLOT(change_adaptor()));
1161         connect(mathsModule->esintautoCB, SIGNAL(clicked()),
1162                 this, SLOT(change_adaptor()));
1163         connect(mathsModule->mhchemCB, SIGNAL(clicked()),
1164                 this, SLOT(change_adaptor()));
1165         connect(mathsModule->mhchemautoCB, SIGNAL(clicked()),
1166                 this, SLOT(change_adaptor()));
1167         connect(mathsModule->mathdotsCB, SIGNAL(clicked()),
1168                 this, SLOT(change_adaptor()));
1169         connect(mathsModule->mathdotsautoCB, SIGNAL(clicked()),
1170                 this, SLOT(change_adaptor()));
1171         connect(mathsModule->undertildeCB, SIGNAL(clicked()),
1172                 this, SLOT(change_adaptor()));
1173         connect(mathsModule->undertildeautoCB, SIGNAL(clicked()),
1174                 this, SLOT(change_adaptor()));
1175
1176
1177         // latex class
1178         latexModule = new UiWidget<Ui::LaTeXUi>;
1179         connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1180                 this, SLOT(change_adaptor()));
1181         connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1182                 this, SLOT(change_adaptor()));
1183         connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1184                 this, SLOT(change_adaptor()));
1185         connect(latexModule->classCO, SIGNAL(activated(int)),
1186                 this, SLOT(classChanged()));
1187         connect(latexModule->classCO, SIGNAL(activated(int)),
1188                 this, SLOT(change_adaptor()));
1189         connect(latexModule->layoutPB, SIGNAL(clicked()),
1190                 this, SLOT(browseLayout()));
1191         connect(latexModule->layoutPB, SIGNAL(clicked()),
1192                 this, SLOT(change_adaptor()));
1193         connect(latexModule->childDocGB, SIGNAL(clicked()),
1194                 this, SLOT(change_adaptor()));
1195         connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1196                 this, SLOT(change_adaptor()));
1197         connect(latexModule->childDocPB, SIGNAL(clicked()),
1198                 this, SLOT(browseMaster()));
1199         connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1200                 this, SLOT(change_adaptor()));
1201         connect(latexModule->refstyleCB, SIGNAL(clicked()),
1202                 this, SLOT(change_adaptor()));
1203
1204         latexModule->optionsLE->setValidator(new NoNewLineValidator(
1205                 latexModule->optionsLE));
1206         latexModule->childDocLE->setValidator(new NoNewLineValidator(
1207                 latexModule->childDocLE));
1208
1209         // postscript drivers
1210         for (int n = 0; tex_graphics[n][0]; ++n) {
1211                 QString enc = qt_(tex_graphics_gui[n]);
1212                 latexModule->psdriverCO->addItem(enc);
1213         }
1214         // latex classes
1215         latexModule->classCO->setModel(&classes_model_);
1216         LayoutFileList const & bcl = LayoutFileList::get();
1217         vector<LayoutFileIndex> classList = bcl.classList();
1218         sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1219
1220         vector<LayoutFileIndex>::const_iterator cit  = classList.begin();
1221         vector<LayoutFileIndex>::const_iterator cen = classList.end();
1222         for (int i = 0; cit != cen; ++cit, ++i) {
1223                 LayoutFile const & tc = bcl[*cit];
1224                 docstring item = (tc.isTeXClassAvailable()) ?
1225                         from_utf8(tc.description()) :
1226                         bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
1227                 classes_model_.insertRow(i, toqstr(item), *cit);
1228         }
1229
1230
1231         // branches
1232         branchesModule = new GuiBranches;
1233         connect(branchesModule, SIGNAL(changed()),
1234                 this, SLOT(change_adaptor()));
1235         connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1236                 this, SLOT(branchesRename(docstring const &, docstring const &)));
1237         updateUnknownBranches();
1238
1239
1240         // preamble
1241         preambleModule = new PreambleModule;
1242         connect(preambleModule, SIGNAL(changed()),
1243                 this, SLOT(change_adaptor()));
1244
1245         localLayout = new LocalLayout;
1246         connect(localLayout, SIGNAL(changed()),
1247                 this, SLOT(change_adaptor()));
1248
1249
1250         // bullets
1251         bulletsModule = new BulletsModule;
1252         connect(bulletsModule, SIGNAL(changed()),
1253                 this, SLOT(change_adaptor()));
1254
1255
1256         // Modules
1257         modulesModule = new UiWidget<Ui::ModulesUi>;
1258         modulesModule->availableLV->header()->setVisible(false);
1259         modulesModule->availableLV->header()->setResizeMode(QHeaderView::ResizeToContents);
1260         modulesModule->availableLV->header()->setStretchLastSection(false);
1261         selectionManager =
1262                 new ModuleSelectionManager(modulesModule->availableLV,
1263                         modulesModule->selectedLV,
1264                         modulesModule->addPB, modulesModule->deletePB,
1265                         modulesModule->upPB, modulesModule->downPB,
1266                         availableModel(), selectedModel(), this);
1267         connect(selectionManager, SIGNAL(updateHook()),
1268                 this, SLOT(updateModuleInfo()));
1269         connect(selectionManager, SIGNAL(updateHook()),
1270                 this, SLOT(change_adaptor()));
1271         connect(selectionManager, SIGNAL(selectionChanged()),
1272                 this, SLOT(modulesChanged()));
1273
1274
1275         // PDF support
1276         pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1277         connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1278                 this, SLOT(change_adaptor()));
1279         connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1280                 this, SLOT(change_adaptor()));
1281         connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1282                 this, SLOT(change_adaptor()));
1283         connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1284                 this, SLOT(change_adaptor()));
1285         connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1286                 this, SLOT(change_adaptor()));
1287         connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1288                 this, SLOT(change_adaptor()));
1289         connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1290                 this, SLOT(change_adaptor()));
1291         connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1292                 this, SLOT(change_adaptor()));
1293         connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1294                 this, SLOT(change_adaptor()));
1295         connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1296                 this, SLOT(change_adaptor()));
1297         connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1298                 this, SLOT(change_adaptor()));
1299         connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1300                 this, SLOT(change_adaptor()));
1301         connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1302                 this, SLOT(change_adaptor()));
1303         connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1304                 this, SLOT(change_adaptor()));
1305         connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1306                 this, SLOT(change_adaptor()));
1307         connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1308                 this, SLOT(change_adaptor()));
1309
1310         pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1311                 pdfSupportModule->titleLE));
1312         pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1313                 pdfSupportModule->authorLE));
1314         pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1315                 pdfSupportModule->subjectLE));
1316         pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1317                 pdfSupportModule->keywordsLE));
1318         pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1319                 pdfSupportModule->optionsLE));
1320
1321         for (int i = 0; backref_opts[i][0]; ++i)
1322                 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1323
1324
1325         // float
1326         floatModule = new FloatPlacement;
1327         connect(floatModule, SIGNAL(changed()),
1328                 this, SLOT(change_adaptor()));
1329
1330
1331         // listings
1332         listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1333         connect(listingsModule->listingsED, SIGNAL(textChanged()),
1334                 this, SLOT(change_adaptor()));
1335         connect(listingsModule->bypassCB, SIGNAL(clicked()),
1336                 this, SLOT(change_adaptor()));
1337         connect(listingsModule->bypassCB, SIGNAL(clicked()),
1338                 this, SLOT(setListingsMessage()));
1339         connect(listingsModule->listingsED, SIGNAL(textChanged()),
1340                 this, SLOT(setListingsMessage()));
1341         listingsModule->listingsTB->setPlainText(
1342                 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1343
1344
1345         // add the panels
1346         docPS->addPanel(latexModule, qt_("Document Class"));
1347         docPS->addPanel(masterChildModule, qt_("Child Documents"));
1348         docPS->addPanel(modulesModule, qt_("Modules"));
1349         docPS->addPanel(localLayout, qt_("Local Layout"));
1350         docPS->addPanel(fontModule, qt_("Fonts"));
1351         docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1352         docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1353         docPS->addPanel(marginsModule, qt_("Page Margins"));
1354         docPS->addPanel(langModule, qt_("Language"));
1355         docPS->addPanel(colorModule, qt_("Colors"));
1356         docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1357         docPS->addPanel(biblioModule, qt_("Bibliography"));
1358         docPS->addPanel(indicesModule, qt_("Indexes"));
1359         docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1360         docPS->addPanel(mathsModule, qt_("Math Options"));
1361         docPS->addPanel(floatModule, qt_("Float Placement"));
1362         docPS->addPanel(listingsModule, qt_("Listings"));
1363         docPS->addPanel(bulletsModule, qt_("Bullets"));
1364         docPS->addPanel(branchesModule, qt_("Branches"));
1365         docPS->addPanel(outputModule, qt_("Output"));
1366         docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1367         docPS->setCurrentPanel(qt_("Document Class"));
1368 // FIXME: hack to work around resizing bug in Qt >= 4.2
1369 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1370 #if QT_VERSION >= 0x040200
1371         docPS->updateGeometry();
1372 #endif
1373 }
1374
1375
1376 void GuiDocument::saveDefaultClicked()
1377 {
1378         saveDocDefault();
1379 }
1380
1381
1382 void GuiDocument::useDefaultsClicked()
1383 {
1384         useClassDefaults();
1385 }
1386
1387
1388 void GuiDocument::change_adaptor()
1389 {
1390         changed();
1391 }
1392
1393
1394 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1395 {
1396         if (item == 0)
1397                 return;
1398
1399         string child = fromqstr(item->text(0));
1400         if (child.empty())
1401                 return;
1402
1403         if (std::find(includeonlys_.begin(),
1404                       includeonlys_.end(), child) != includeonlys_.end())
1405                 includeonlys_.remove(child);
1406         else
1407                 includeonlys_.push_back(child);
1408
1409         updateIncludeonlys();
1410         changed();
1411 }
1412
1413
1414 QString GuiDocument::validateListingsParameters()
1415 {
1416         // use a cache here to avoid repeated validation
1417         // of the same parameters
1418         static string param_cache;
1419         static QString msg_cache;
1420
1421         if (listingsModule->bypassCB->isChecked())
1422                 return QString();
1423
1424         string params = fromqstr(listingsModule->listingsED->toPlainText());
1425         if (params != param_cache) {
1426                 param_cache = params;
1427                 msg_cache = toqstr(InsetListingsParams(params).validate());
1428         }
1429         return msg_cache;
1430 }
1431
1432
1433 void GuiDocument::setListingsMessage()
1434 {
1435         static bool isOK = true;
1436         QString msg = validateListingsParameters();
1437         if (msg.isEmpty()) {
1438                 if (isOK)
1439                         return;
1440                 isOK = true;
1441                 // listingsTB->setTextColor("black");
1442                 listingsModule->listingsTB->setPlainText(
1443                         qt_("Input listings parameters below. "
1444                 "Enter ? for a list of parameters."));
1445         } else {
1446                 isOK = false;
1447                 // listingsTB->setTextColor("red");
1448                 listingsModule->listingsTB->setPlainText(msg);
1449         }
1450 }
1451
1452
1453 void GuiDocument::setLSpacing(int item)
1454 {
1455         textLayoutModule->lspacingLE->setEnabled(item == 3);
1456 }
1457
1458
1459 void GuiDocument::setIndent(int item)
1460 {
1461         bool const enable = (item == 1);
1462         textLayoutModule->indentLE->setEnabled(enable);
1463         textLayoutModule->indentLengthCO->setEnabled(enable);
1464         textLayoutModule->skipLE->setEnabled(false);
1465         textLayoutModule->skipLengthCO->setEnabled(false);
1466         isValid();
1467 }
1468
1469
1470 void GuiDocument::enableIndent(bool indent)
1471 {
1472         textLayoutModule->skipLE->setEnabled(!indent);
1473         textLayoutModule->skipLengthCO->setEnabled(!indent);
1474         if (indent)
1475                 setIndent(textLayoutModule->indentCO->currentIndex());
1476 }
1477
1478
1479 void GuiDocument::setSkip(int item)
1480 {
1481         bool const enable = (item == 3);
1482         textLayoutModule->skipLE->setEnabled(enable);
1483         textLayoutModule->skipLengthCO->setEnabled(enable);
1484         isValid();
1485 }
1486
1487
1488 void GuiDocument::enableSkip(bool skip)
1489 {
1490         textLayoutModule->indentLE->setEnabled(!skip);
1491         textLayoutModule->indentLengthCO->setEnabled(!skip);
1492         if (skip)
1493                 setSkip(textLayoutModule->skipCO->currentIndex());
1494 }
1495
1496
1497 void GuiDocument::setMargins()
1498 {
1499         bool const extern_geometry =
1500                 documentClass().provides("geometry");
1501         marginsModule->marginCB->setEnabled(!extern_geometry);
1502         if (extern_geometry) {
1503                 marginsModule->marginCB->setChecked(false);
1504                 setCustomMargins(true);
1505         } else {
1506                 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1507                 setCustomMargins(!bp_.use_geometry);
1508         }
1509 }
1510
1511
1512 void GuiDocument::papersizeChanged(int paper_size)
1513 {
1514         setCustomPapersize(paper_size == 1);
1515 }
1516
1517
1518 void GuiDocument::setCustomPapersize(bool custom)
1519 {
1520         pageLayoutModule->paperwidthL->setEnabled(custom);
1521         pageLayoutModule->paperwidthLE->setEnabled(custom);
1522         pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1523         pageLayoutModule->paperheightL->setEnabled(custom);
1524         pageLayoutModule->paperheightLE->setEnabled(custom);
1525         pageLayoutModule->paperheightLE->setFocus();
1526         pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1527 }
1528
1529
1530 void GuiDocument::setColSep()
1531 {
1532         setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1533 }
1534
1535
1536 void GuiDocument::setCustomMargins(bool custom)
1537 {
1538         marginsModule->topL->setEnabled(!custom);
1539         marginsModule->topLE->setEnabled(!custom);
1540         marginsModule->topUnit->setEnabled(!custom);
1541
1542         marginsModule->bottomL->setEnabled(!custom);
1543         marginsModule->bottomLE->setEnabled(!custom);
1544         marginsModule->bottomUnit->setEnabled(!custom);
1545
1546         marginsModule->innerL->setEnabled(!custom);
1547         marginsModule->innerLE->setEnabled(!custom);
1548         marginsModule->innerUnit->setEnabled(!custom);
1549
1550         marginsModule->outerL->setEnabled(!custom);
1551         marginsModule->outerLE->setEnabled(!custom);
1552         marginsModule->outerUnit->setEnabled(!custom);
1553
1554         marginsModule->headheightL->setEnabled(!custom);
1555         marginsModule->headheightLE->setEnabled(!custom);
1556         marginsModule->headheightUnit->setEnabled(!custom);
1557
1558         marginsModule->headsepL->setEnabled(!custom);
1559         marginsModule->headsepLE->setEnabled(!custom);
1560         marginsModule->headsepUnit->setEnabled(!custom);
1561
1562         marginsModule->footskipL->setEnabled(!custom);
1563         marginsModule->footskipLE->setEnabled(!custom);
1564         marginsModule->footskipUnit->setEnabled(!custom);
1565
1566         bool const enableColSep = !custom &&
1567                         textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1568         marginsModule->columnsepL->setEnabled(enableColSep);
1569         marginsModule->columnsepLE->setEnabled(enableColSep);
1570         marginsModule->columnsepUnit->setEnabled(enableColSep);
1571 }
1572
1573
1574 void GuiDocument::changeBackgroundColor()
1575 {
1576         QColor const & newColor = QColorDialog::getColor(
1577                 rgb2qcolor(set_backgroundcolor), asQWidget());
1578         if (!newColor.isValid())
1579                 return;
1580         // set the button color and text
1581         colorModule->backgroundPB->setStyleSheet(
1582                 colorButtonStyleSheet(newColor));
1583         colorModule->backgroundPB->setText(qt_("&Change..."));
1584         // save color
1585         set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1586         is_backgroundcolor = true;
1587         changed();
1588 }
1589
1590
1591 void GuiDocument::deleteBackgroundColor()
1592 {
1593         // set the button color back to default by setting an empty StyleSheet
1594         colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1595         // change button text
1596         colorModule->backgroundPB->setText(qt_("&Default..."));
1597         // save default color (white)
1598         set_backgroundcolor = rgbFromHexName("#ffffff");
1599         is_backgroundcolor = false;
1600         changed();
1601 }
1602
1603
1604 void GuiDocument::changeFontColor()
1605 {
1606         QColor const & newColor = QColorDialog::getColor(
1607                 rgb2qcolor(set_fontcolor), asQWidget());
1608         if (!newColor.isValid())
1609                 return;
1610         // set the button color and text
1611         colorModule->fontColorPB->setStyleSheet(
1612                 colorButtonStyleSheet(newColor));
1613         colorModule->fontColorPB->setText(qt_("&Change..."));
1614         // save color
1615         set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1616         is_fontcolor = true;
1617         changed();
1618 }
1619
1620
1621 void GuiDocument::deleteFontColor()
1622 {
1623         // set the button color back to default by setting an empty StyleSheet
1624         colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1625         // change button text
1626         colorModule->fontColorPB->setText(qt_("&Default..."));
1627         // save default color (black)
1628         set_fontcolor = rgbFromHexName("#000000");
1629         is_fontcolor = false;
1630         changed();
1631 }
1632
1633
1634 void GuiDocument::changeNoteFontColor()
1635 {
1636         QColor const & newColor = QColorDialog::getColor(
1637                 rgb2qcolor(set_notefontcolor), asQWidget());
1638         if (!newColor.isValid())
1639                 return;
1640         // set the button color
1641         colorModule->noteFontColorPB->setStyleSheet(
1642                 colorButtonStyleSheet(newColor));
1643         // save color
1644         set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1645         changed();
1646 }
1647
1648
1649 void GuiDocument::deleteNoteFontColor()
1650 {
1651         // set the button color back to pref
1652         theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1653         colorModule->noteFontColorPB->setStyleSheet(
1654                 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1655         changed();
1656 }
1657
1658
1659 void GuiDocument::changeBoxBackgroundColor()
1660 {
1661         QColor const & newColor = QColorDialog::getColor(
1662                 rgb2qcolor(set_boxbgcolor), asQWidget());
1663         if (!newColor.isValid())
1664                 return;
1665         // set the button color
1666         colorModule->boxBackgroundPB->setStyleSheet(
1667                 colorButtonStyleSheet(newColor));
1668         // save color
1669         set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1670         changed();
1671 }
1672
1673
1674 void GuiDocument::deleteBoxBackgroundColor()
1675 {
1676         // set the button color back to pref
1677         theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1678         colorModule->boxBackgroundPB->setStyleSheet(
1679                 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1680         changed();
1681 }
1682
1683
1684 void GuiDocument::osFontsChanged(bool nontexfonts)
1685 {
1686         bool const tex_fonts = !nontexfonts;
1687         updateFontlist();
1688         updateDefaultFormat();
1689         langModule->encodingCO->setEnabled(tex_fonts &&
1690                 !langModule->defaultencodingRB->isChecked());
1691         langModule->defaultencodingRB->setEnabled(tex_fonts);
1692         langModule->otherencodingRB->setEnabled(tex_fonts);
1693
1694         fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1695         fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1696         fontModule->cjkFontLE->setEnabled(tex_fonts);
1697         fontModule->cjkFontLA->setEnabled(tex_fonts);
1698         string font;
1699         if (tex_fonts)
1700                 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1701         bool scaleable = providesScale(font);
1702         fontModule->scaleSansSB->setEnabled(scaleable);
1703         fontModule->scaleSansLA->setEnabled(scaleable);
1704         if (tex_fonts)
1705                 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1706         scaleable = providesScale(font);
1707         fontModule->scaleTypewriterSB->setEnabled(scaleable);
1708         fontModule->scaleTypewriterLA->setEnabled(scaleable);
1709         if (tex_fonts)
1710                 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1711         fontModule->fontScCB->setEnabled(providesSC(font));
1712         fontModule->fontOsfCB->setEnabled(providesOSF(font));
1713
1714         fontModule->fontencLA->setEnabled(tex_fonts);
1715         fontModule->fontencCO->setEnabled(tex_fonts);
1716         if (!tex_fonts)
1717                 fontModule->fontencLE->setEnabled(false);
1718         else
1719                 fontencChanged(fontModule->fontencCO->currentIndex());
1720 }
1721
1722
1723 void GuiDocument::updateFontsize(string const & items, string const & sel)
1724 {
1725         fontModule->fontsizeCO->clear();
1726         fontModule->fontsizeCO->addItem(qt_("Default"));
1727
1728         for (int n = 0; !token(items,'|',n).empty(); ++n)
1729                 fontModule->fontsizeCO->
1730                         addItem(toqstr(token(items,'|',n)));
1731
1732         for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1733                 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1734                         fontModule->fontsizeCO->setCurrentIndex(n);
1735                         break;
1736                 }
1737         }
1738 }
1739
1740
1741 void GuiDocument::updateFontlist()
1742 {
1743         fontModule->fontsRomanCO->clear();
1744         fontModule->fontsSansCO->clear();
1745         fontModule->fontsTypewriterCO->clear();
1746
1747         // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1748         if (fontModule->osFontsCB->isChecked()) {
1749                 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1750                 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1751                 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1752
1753                 QFontDatabase fontdb;
1754                 QStringList families(fontdb.families());
1755                 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1756                         fontModule->fontsRomanCO->addItem(*it, *it);
1757                         fontModule->fontsSansCO->addItem(*it, *it);
1758                         fontModule->fontsTypewriterCO->addItem(*it, *it);
1759                 }
1760                 return;
1761         }
1762
1763         for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1764                 QString font = qt_(tex_fonts_roman_gui[n]);
1765                 if (!isFontAvailable(tex_fonts_roman[n]))
1766                         font += qt_(" (not installed)");
1767                 fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
1768         }
1769         for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1770                 QString font = qt_(tex_fonts_sans_gui[n]);
1771                 if (!isFontAvailable(tex_fonts_sans[n]))
1772                         font += qt_(" (not installed)");
1773                 fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
1774         }
1775         for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1776                 QString font = qt_(tex_fonts_monospaced_gui[n]);
1777                 if (!isFontAvailable(tex_fonts_monospaced[n]))
1778                         font += qt_(" (not installed)");
1779                 fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
1780         }
1781 }
1782
1783
1784 void GuiDocument::fontencChanged(int item)
1785 {
1786         fontModule->fontencLE->setEnabled(item == 1);
1787 }
1788
1789
1790 void GuiDocument::romanChanged(int item)
1791 {
1792         if (fontModule->osFontsCB->isChecked())
1793                 return;
1794         string const font = tex_fonts_roman[item];
1795         fontModule->fontScCB->setEnabled(providesSC(font));
1796         fontModule->fontOsfCB->setEnabled(providesOSF(font));
1797 }
1798
1799
1800 void GuiDocument::sansChanged(int item)
1801 {
1802         if (fontModule->osFontsCB->isChecked())
1803                 return;
1804         string const font = tex_fonts_sans[item];
1805         bool scaleable = providesScale(font);
1806         fontModule->scaleSansSB->setEnabled(scaleable);
1807         fontModule->scaleSansLA->setEnabled(scaleable);
1808 }
1809
1810
1811 void GuiDocument::ttChanged(int item)
1812 {
1813         if (fontModule->osFontsCB->isChecked())
1814                 return;
1815         string const font = tex_fonts_monospaced[item];
1816         bool scaleable = providesScale(font);
1817         fontModule->scaleTypewriterSB->setEnabled(scaleable);
1818         fontModule->scaleTypewriterLA->setEnabled(scaleable);
1819 }
1820
1821
1822 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1823 {
1824         pagestyles.clear();
1825         pageLayoutModule->pagestyleCO->clear();
1826         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1827
1828         for (int n = 0; !token(items, '|', n).empty(); ++n) {
1829                 string style = token(items, '|', n);
1830                 QString style_gui = qt_(style);
1831                 pagestyles.push_back(pair<string, QString>(style, style_gui));
1832                 pageLayoutModule->pagestyleCO->addItem(style_gui);
1833         }
1834
1835         if (sel == "default") {
1836                 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1837                 return;
1838         }
1839
1840         int nn = 0;
1841
1842         for (size_t i = 0; i < pagestyles.size(); ++i)
1843                 if (pagestyles[i].first == sel)
1844                         nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1845
1846         if (nn > 0)
1847                 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1848 }
1849
1850
1851 void GuiDocument::browseLayout()
1852 {
1853         QString const label1 = qt_("Layouts|#o#O");
1854         QString const dir1 = toqstr(lyxrc.document_path);
1855         QStringList const filter(qt_("LyX Layout (*.layout)"));
1856         QString file = browseRelToParent(QString(), bufferFilePath(),
1857                 qt_("Local layout file"), filter, false,
1858                 label1, dir1);
1859
1860         if (!file.endsWith(".layout"))
1861                 return;
1862
1863         FileName layoutFile = support::makeAbsPath(fromqstr(file),
1864                 fromqstr(bufferFilePath()));
1865
1866         int const ret = Alert::prompt(_("Local layout file"),
1867                 _("The layout file you have selected is a local layout\n"
1868                   "file, not one in the system or user directory. Your\n"
1869                   "document may not work with this layout if you do not\n"
1870                   "keep the layout file in the document directory."),
1871                   1, 1, _("&Set Layout"), _("&Cancel"));
1872         if (ret == 1)
1873                 return;
1874
1875         // load the layout file
1876         LayoutFileList & bcl = LayoutFileList::get();
1877         string classname = layoutFile.onlyFileName();
1878         // this will update an existing layout if that layout has been loaded before.
1879         LayoutFileIndex name = bcl.addLocalLayout(
1880                 classname.substr(0, classname.size() - 7),
1881                 layoutFile.onlyPath().absFileName());
1882
1883         if (name.empty()) {
1884                 Alert::error(_("Error"),
1885                         _("Unable to read local layout file."));
1886                 return;
1887         }
1888
1889         // do not trigger classChanged if there is no change.
1890         if (latexModule->classCO->currentText() == toqstr(name))
1891                 return;
1892
1893         // add to combo box
1894         int idx = latexModule->classCO->findText(toqstr(name));
1895         if (idx == -1) {
1896                 classes_model_.insertRow(0, toqstr(name), name);
1897                 latexModule->classCO->setCurrentIndex(0);
1898         } else
1899                 latexModule->classCO->setCurrentIndex(idx);
1900
1901         classChanged();
1902 }
1903
1904
1905 void GuiDocument::browseMaster()
1906 {
1907         QString const title = qt_("Select master document");
1908         QString const dir1 = toqstr(lyxrc.document_path);
1909         QString const old = latexModule->childDocLE->text();
1910         QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1911         QStringList const filter(qt_("LyX Files (*.lyx)"));
1912         QString file = browseRelToSub(old, docpath, title, filter, false,
1913                 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1914
1915         if (!file.isEmpty())
1916                 latexModule->childDocLE->setText(file);
1917 }
1918
1919
1920 void GuiDocument::classChanged()
1921 {
1922         int idx = latexModule->classCO->currentIndex();
1923         if (idx < 0)
1924                 return;
1925         string const classname = classes_model_.getIDString(idx);
1926
1927         // check whether the selected modules have changed.
1928         bool modules_changed = false;
1929         unsigned int const srows = selectedModel()->rowCount();
1930         if (srows != bp_.getModules().size())
1931                 modules_changed = true;
1932         else {
1933                 list<string>::const_iterator mit = bp_.getModules().begin();
1934                 list<string>::const_iterator men = bp_.getModules().end();
1935                 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1936                         if (selectedModel()->getIDString(i) != *mit) {
1937                                 modules_changed = true;
1938                                 break;
1939                         }
1940         }
1941
1942         if (modules_changed || lyxrc.auto_reset_options) {
1943                 if (applyPB->isEnabled()) {
1944                         int const ret = Alert::prompt(_("Unapplied changes"),
1945                                         _("Some changes in the dialog were not yet applied.\n"
1946                                         "If you do not apply now, they will be lost after this action."),
1947                                         1, 1, _("&Apply"), _("&Dismiss"));
1948                         if (ret == 0)
1949                                 applyView();
1950                 }
1951         }
1952
1953         // We load the TextClass as soon as it is selected. This is
1954         // necessary so that other options in the dialog can be updated
1955         // according to the new class. Note, however, that, if you use
1956         // the scroll wheel when sitting on the combo box, we'll load a
1957         // lot of TextClass objects very quickly....
1958         if (!bp_.setBaseClass(classname)) {
1959                 Alert::error(_("Error"), _("Unable to set document class."));
1960                 return;
1961         }
1962         if (lyxrc.auto_reset_options)
1963                 bp_.useClassDefaults();
1964
1965         // With the introduction of modules came a distinction between the base
1966         // class and the document class. The former corresponds to the main layout
1967         // file; the latter is that plus the modules (or the document-specific layout,
1968         // or  whatever else there could be). Our parameters come from the document
1969         // class. So when we set the base class, we also need to recreate the document
1970         // class. Otherwise, we still have the old one.
1971         bp_.makeDocumentClass();
1972         paramsToDialog();
1973 }
1974
1975
1976 void GuiDocument::languagePackageChanged(int i)
1977 {
1978          langModule->languagePackageLE->setEnabled(
1979                 langModule->languagePackageCO->itemData(i).toString() == "custom");
1980 }
1981
1982
1983 void GuiDocument::bibtexChanged(int n)
1984 {
1985         biblioModule->bibtexOptionsLE->setEnabled(
1986                 biblioModule->bibtexCO->itemData(n).toString() != "default");
1987         changed();
1988 }
1989
1990
1991 namespace {
1992         // FIXME unicode
1993         // both of these should take a vector<docstring>
1994
1995         // This is an insanely complicated attempt to make this sort of thing
1996         // work with RTL languages.
1997         docstring formatStrVec(vector<string> const & v, docstring const & s)
1998         {
1999                 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2000                 if (v.size() == 0)
2001                         return docstring();
2002                 if (v.size() == 1)
2003                         return translateIfPossible(from_utf8(v[0]));
2004                 if (v.size() == 2) {
2005                         docstring retval = _("%1$s and %2$s");
2006                         retval = subst(retval, _("and"), s);
2007                         return bformat(retval, translateIfPossible(from_utf8(v[0])),
2008                                        translateIfPossible(from_utf8(v[1])));
2009                 }
2010                 // The idea here is to format all but the last two items...
2011                 int const vSize = v.size();
2012                 docstring t2 = _("%1$s, %2$s");
2013                 docstring retval = translateIfPossible(from_utf8(v[0]));
2014                 for (int i = 1; i < vSize - 2; ++i)
2015                         retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2016                 //...and then to  plug them, and the last two, into this schema
2017                 docstring t = _("%1$s, %2$s, and %3$s");
2018                 t = subst(t, _("and"), s);
2019                 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2020                                translateIfPossible(from_utf8(v[vSize - 1])));
2021         }
2022
2023         vector<string> idsToNames(vector<string> const & idList)
2024         {
2025                 vector<string> retval;
2026                 vector<string>::const_iterator it  = idList.begin();
2027                 vector<string>::const_iterator end = idList.end();
2028                 for (; it != end; ++it) {
2029                         LyXModule const * const mod = theModuleList[*it];
2030                         if (!mod)
2031                                 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2032                                                 translateIfPossible(from_utf8(*it)))));
2033                         else
2034                                 retval.push_back(mod->getName());
2035                 }
2036                 return retval;
2037         }
2038 } // end anonymous namespace
2039
2040
2041 void GuiDocument::modulesToParams(BufferParams & bp)
2042 {
2043         // update list of loaded modules
2044         bp.clearLayoutModules();
2045         int const srows = modules_sel_model_.rowCount();
2046         for (int i = 0; i < srows; ++i)
2047                 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2048
2049         // update the list of removed modules
2050         bp.clearRemovedModules();
2051         LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2052         list<string>::const_iterator rit = reqmods.begin();
2053         list<string>::const_iterator ren = reqmods.end();
2054
2055         // check each of the default modules
2056         for (; rit != ren; rit++) {
2057                 list<string>::const_iterator mit = bp.getModules().begin();
2058                 list<string>::const_iterator men = bp.getModules().end();
2059                 bool found = false;
2060                 for (; mit != men; mit++) {
2061                         if (*rit == *mit) {
2062                                 found = true;
2063                                 break;
2064                         }
2065                 }
2066                 if (!found) {
2067                         // the module isn't present so must have been removed by the user
2068                         bp.addRemovedModule(*rit);
2069                 }
2070         }
2071 }
2072
2073 void GuiDocument::modulesChanged()
2074 {
2075         modulesToParams(bp_);
2076         bp_.makeDocumentClass();
2077         paramsToDialog();
2078 }
2079
2080
2081 void GuiDocument::updateModuleInfo()
2082 {
2083         selectionManager->update();
2084
2085         //Module description
2086         bool const focus_on_selected = selectionManager->selectedFocused();
2087         QAbstractItemView * lv;
2088         if (focus_on_selected)
2089                 lv = modulesModule->selectedLV;
2090         else
2091                 lv= modulesModule->availableLV;
2092         if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2093                 modulesModule->infoML->document()->clear();
2094                 return;
2095         }
2096         QModelIndex const & idx = lv->selectionModel()->currentIndex();
2097         GuiIdListModel const & id_model =
2098                         focus_on_selected  ? modules_sel_model_ : modules_av_model_;
2099         string const modName = id_model.getIDString(idx.row());
2100         docstring desc = getModuleDescription(modName);
2101
2102         LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2103         if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2104                 if (!desc.empty())
2105                         desc += "\n";
2106                 desc += _("Module provided by document class.");
2107         }
2108
2109         vector<string> pkglist = getPackageList(modName);
2110         docstring pkgdesc = formatStrVec(pkglist, _("and"));
2111         if (!pkgdesc.empty()) {
2112                 if (!desc.empty())
2113                         desc += "\n";
2114                 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2115         }
2116
2117         pkglist = getRequiredList(modName);
2118         if (!pkglist.empty()) {
2119                 vector<string> const reqdescs = idsToNames(pkglist);
2120                 pkgdesc = formatStrVec(reqdescs, _("or"));
2121                 if (!desc.empty())
2122                         desc += "\n";
2123                 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2124         }
2125
2126         pkglist = getExcludedList(modName);
2127         if (!pkglist.empty()) {
2128                 vector<string> const reqdescs = idsToNames(pkglist);
2129                 pkgdesc = formatStrVec(reqdescs, _( "and"));
2130                 if (!desc.empty())
2131                         desc += "\n";
2132                 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2133         }
2134
2135         if (!isModuleAvailable(modName)) {
2136                 if (!desc.empty())
2137                         desc += "\n";
2138                 desc += _("WARNING: Some required packages are unavailable!");
2139         }
2140
2141         modulesModule->infoML->document()->setPlainText(toqstr(desc));
2142 }
2143
2144
2145 void GuiDocument::updateNumbering()
2146 {
2147         DocumentClass const & tclass = documentClass();
2148
2149         numberingModule->tocTW->setUpdatesEnabled(false);
2150         numberingModule->tocTW->clear();
2151
2152         int const depth = numberingModule->depthSL->value();
2153         int const toc = numberingModule->tocSL->value();
2154         QString const no = qt_("No");
2155         QString const yes = qt_("Yes");
2156         QTreeWidgetItem * item = 0;
2157
2158         DocumentClass::const_iterator lit = tclass.begin();
2159         DocumentClass::const_iterator len = tclass.end();
2160         for (; lit != len; ++lit) {
2161                 int const toclevel = lit->toclevel;
2162                 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
2163                         item = new QTreeWidgetItem(numberingModule->tocTW);
2164                         item->setText(0, toqstr(translateIfPossible(lit->name())));
2165                         item->setText(1, (toclevel <= depth) ? yes : no);
2166                         item->setText(2, (toclevel <= toc) ? yes : no);
2167                 }
2168         }
2169
2170         numberingModule->tocTW->setUpdatesEnabled(true);
2171         numberingModule->tocTW->update();
2172 }
2173
2174
2175 void GuiDocument::updateDefaultFormat()
2176 {
2177         if (!bufferview())
2178                 return;
2179         // make a copy in order to consider unapplied changes
2180         BufferParams param_copy = buffer().params();
2181         param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2182         int const idx = latexModule->classCO->currentIndex();
2183         if (idx >= 0) {
2184                 string const classname = classes_model_.getIDString(idx);
2185                 param_copy.setBaseClass(classname);
2186                 param_copy.makeDocumentClass();
2187         }
2188         outputModule->defaultFormatCO->blockSignals(true);
2189         outputModule->defaultFormatCO->clear();
2190         outputModule->defaultFormatCO->addItem(qt_("Default"),
2191                                 QVariant(QString("default")));
2192         typedef vector<Format const *> Formats;
2193         Formats formats = param_copy.exportableFormats(true);
2194         Formats::const_iterator cit = formats.begin();
2195         Formats::const_iterator end = formats.end();
2196         for (; cit != end; ++cit)
2197                 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2198                                 QVariant(toqstr((*cit)->name())));
2199         outputModule->defaultFormatCO->blockSignals(false);
2200 }
2201
2202
2203 bool GuiDocument::isChildIncluded(string const & child)
2204 {
2205         if (includeonlys_.empty())
2206                 return false;
2207         return (std::find(includeonlys_.begin(),
2208                           includeonlys_.end(), child) != includeonlys_.end());
2209 }
2210
2211
2212 void GuiDocument::applyView()
2213 {
2214         // preamble
2215         preambleModule->apply(bp_);
2216         localLayout->apply(bp_);
2217
2218         // date
2219         bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2220         bp_.use_refstyle  = latexModule->refstyleCB->isChecked();
2221
2222         // biblio
2223         bp_.setCiteEngine(ENGINE_BASIC);
2224
2225         if (biblioModule->citeNatbibRB->isChecked()) {
2226                 bool const use_numerical_citations =
2227                         biblioModule->citeStyleCO->currentIndex();
2228                 if (use_numerical_citations)
2229                         bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
2230                 else
2231                         bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
2232
2233         } else if (biblioModule->citeJurabibRB->isChecked())
2234                 bp_.setCiteEngine(ENGINE_JURABIB);
2235
2236         bp_.use_bibtopic =
2237                 biblioModule->bibtopicCB->isChecked();
2238
2239         string const bibtex_command =
2240                 fromqstr(biblioModule->bibtexCO->itemData(
2241                         biblioModule->bibtexCO->currentIndex()).toString());
2242         string const bibtex_options =
2243                 fromqstr(biblioModule->bibtexOptionsLE->text());
2244         if (bibtex_command == "default" || bibtex_options.empty())
2245                 bp_.bibtex_command = bibtex_command;
2246         else
2247                 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2248
2249         buffer().removeBiblioTempFiles();
2250
2251         // Indices
2252         indicesModule->apply(bp_);
2253
2254         // language & quotes
2255         if (langModule->defaultencodingRB->isChecked()) {
2256                 bp_.inputenc = "auto";
2257         } else {
2258                 int i = langModule->encodingCO->currentIndex();
2259                 if (i == 0)
2260                         bp_.inputenc = "default";
2261                 else {
2262                         QString const enc_gui =
2263                                 langModule->encodingCO->currentText();
2264                         Encodings::const_iterator it = encodings.begin();
2265                         Encodings::const_iterator const end = encodings.end();
2266                         bool found = false;
2267                         for (; it != end; ++it) {
2268                                 if (qt_(it->guiName()) == enc_gui) {
2269                                         bp_.inputenc = it->latexName();
2270                                         found = true;
2271                                         break;
2272                                 }
2273                         }
2274                         if (!found) {
2275                                 // should not happen
2276                                 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2277                                 bp_.inputenc = "default";
2278                         }
2279                 }
2280         }
2281
2282         InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
2283         switch (langModule->quoteStyleCO->currentIndex()) {
2284         case 0:
2285                 lga = InsetQuotes::EnglishQuotes;
2286                 break;
2287         case 1:
2288                 lga = InsetQuotes::SwedishQuotes;
2289                 break;
2290         case 2:
2291                 lga = InsetQuotes::GermanQuotes;
2292                 break;
2293         case 3:
2294                 lga = InsetQuotes::PolishQuotes;
2295                 break;
2296         case 4:
2297                 lga = InsetQuotes::FrenchQuotes;
2298                 break;
2299         case 5:
2300                 lga = InsetQuotes::DanishQuotes;
2301                 break;
2302         }
2303         bp_.quotes_language = lga;
2304
2305         QString const lang = langModule->languageCO->itemData(
2306                 langModule->languageCO->currentIndex()).toString();
2307         bp_.language = lyx::languages.getLanguage(fromqstr(lang));
2308
2309         QString const pack = langModule->languagePackageCO->itemData(
2310                 langModule->languagePackageCO->currentIndex()).toString();
2311         if (pack == "custom")
2312                 bp_.lang_package =
2313                         fromqstr(langModule->languagePackageLE->text());
2314         else
2315                 bp_.lang_package = fromqstr(pack);
2316
2317         //color
2318         bp_.backgroundcolor = set_backgroundcolor;
2319         bp_.isbackgroundcolor = is_backgroundcolor;
2320         bp_.fontcolor = set_fontcolor;
2321         bp_.isfontcolor = is_fontcolor;
2322         bp_.notefontcolor = set_notefontcolor;
2323         bp_.boxbgcolor = set_boxbgcolor;
2324
2325         // numbering
2326         if (bp_.documentClass().hasTocLevels()) {
2327                 bp_.tocdepth = numberingModule->tocSL->value();
2328                 bp_.secnumdepth = numberingModule->depthSL->value();
2329         }
2330
2331         // bullets
2332         bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2333         bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2334         bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2335         bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2336
2337         // packages
2338         bp_.graphics_driver =
2339                 tex_graphics[latexModule->psdriverCO->currentIndex()];
2340
2341         // text layout
2342         int idx = latexModule->classCO->currentIndex();
2343         if (idx >= 0) {
2344                 string const classname = classes_model_.getIDString(idx);
2345                 bp_.setBaseClass(classname);
2346         }
2347
2348         // Modules
2349         modulesToParams(bp_);
2350
2351         // Math
2352         if (mathsModule->amsautoCB->isChecked())
2353                 bp_.use_amsmath = BufferParams::package_auto;
2354         else {
2355                 if (mathsModule->amsCB->isChecked())
2356                         bp_.use_amsmath = BufferParams::package_on;
2357                 else
2358                         bp_.use_amsmath = BufferParams::package_off;
2359         }
2360         if (mathsModule->esintautoCB->isChecked())
2361                 bp_.use_esint = BufferParams::package_auto;
2362         else {
2363                 if (mathsModule->esintCB->isChecked())
2364                         bp_.use_esint = BufferParams::package_on;
2365                 else
2366                         bp_.use_esint = BufferParams::package_off;
2367         }
2368         if (mathsModule->mhchemautoCB->isChecked())
2369                 bp_.use_mhchem = BufferParams::package_auto;
2370         else {
2371                 if (mathsModule->mhchemCB->isChecked())
2372                         bp_.use_mhchem = BufferParams::package_on;
2373                 else
2374                         bp_.use_mhchem = BufferParams::package_off;
2375         }
2376         if (mathsModule->mathdotsautoCB->isChecked())
2377                 bp_.use_mathdots = BufferParams::package_auto;
2378         else {
2379                 if (mathsModule->mathdotsCB->isChecked())
2380                         bp_.use_mathdots = BufferParams::package_on;
2381                 else
2382                         bp_.use_mathdots = BufferParams::package_off;
2383         }
2384         if (mathsModule->undertildeautoCB->isChecked())
2385                 bp_.use_undertilde = BufferParams::package_auto;
2386         else {
2387                 if (mathsModule->undertildeCB->isChecked())
2388                         bp_.use_undertilde = BufferParams::package_on;
2389                 else
2390                         bp_.use_undertilde = BufferParams::package_off;
2391         }
2392
2393         // Page Layout
2394         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2395                 bp_.pagestyle = "default";
2396         else {
2397                 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2398                 for (size_t i = 0; i != pagestyles.size(); ++i)
2399                         if (pagestyles[i].second == style_gui)
2400                                 bp_.pagestyle = pagestyles[i].first;
2401         }
2402
2403         // Text Layout
2404         switch (textLayoutModule->lspacingCO->currentIndex()) {
2405         case 0:
2406                 bp_.spacing().set(Spacing::Single);
2407                 break;
2408         case 1:
2409                 bp_.spacing().set(Spacing::Onehalf);
2410                 break;
2411         case 2:
2412                 bp_.spacing().set(Spacing::Double);
2413                 break;
2414         case 3: {
2415                 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2416                 if (s.empty())
2417                         bp_.spacing().set(Spacing::Single);
2418                 else
2419                         bp_.spacing().set(Spacing::Other, s);
2420                 break;
2421                 }
2422         }
2423
2424         if (textLayoutModule->twoColumnCB->isChecked())
2425                 bp_.columns = 2;
2426         else
2427                 bp_.columns = 1;
2428
2429         if (textLayoutModule->indentRB->isChecked()) {
2430                 // if paragraphs are separated by an indentation
2431                 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2432                 switch (textLayoutModule->indentCO->currentIndex()) {
2433                 case 0:
2434                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2435                         break;
2436                 case 1: {
2437                         HSpace indent = HSpace(
2438                                 widgetsToLength(textLayoutModule->indentLE,
2439                                 textLayoutModule->indentLengthCO)
2440                                 );
2441                         bp_.setIndentation(indent);
2442                         break;
2443                         }
2444                 default:
2445                         // this should never happen
2446                         bp_.setIndentation(HSpace(HSpace::DEFAULT));
2447                         break;
2448                 }
2449         } else {
2450                 // if paragraphs are separated by a skip
2451                 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2452                 switch (textLayoutModule->skipCO->currentIndex()) {
2453                 case 0:
2454                         bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2455                         break;
2456                 case 1:
2457                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2458                         break;
2459                 case 2:
2460                         bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2461                         break;
2462                 case 3:
2463                         {
2464                         VSpace vs = VSpace(
2465                                 widgetsToLength(textLayoutModule->skipLE,
2466                                 textLayoutModule->skipLengthCO)
2467                                 );
2468                         bp_.setDefSkip(vs);
2469                         break;
2470                         }
2471                 default:
2472                         // this should never happen
2473                         bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2474                         break;
2475                 }
2476         }
2477
2478         bp_.options =
2479                 fromqstr(latexModule->optionsLE->text());
2480
2481         bp_.use_default_options =
2482                 latexModule->defaultOptionsCB->isChecked();
2483
2484         if (latexModule->childDocGB->isChecked())
2485                 bp_.master =
2486                         fromqstr(latexModule->childDocLE->text());
2487         else
2488                 bp_.master = string();
2489
2490         // Master/Child
2491         bp_.clearIncludedChildren();
2492         if (masterChildModule->includeonlyRB->isChecked()) {
2493                 list<string>::const_iterator it = includeonlys_.begin();
2494                 for (; it != includeonlys_.end() ; ++it) {
2495                         bp_.addIncludedChildren(*it);
2496                 }
2497         }
2498         bp_.maintain_unincluded_children =
2499                 masterChildModule->maintainAuxCB->isChecked();
2500
2501         // Float Placement
2502         bp_.float_placement = floatModule->get();
2503
2504         // Listings
2505         // text should have passed validation
2506         bp_.listings_params =
2507                 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2508
2509         // output
2510         bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2511                 outputModule->defaultFormatCO->currentIndex()).toString());
2512
2513         bool const nontexfonts = fontModule->osFontsCB->isChecked();
2514         bp_.useNonTeXFonts = nontexfonts;
2515
2516         bp_.output_sync = outputModule->outputsyncCB->isChecked();
2517         bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2518
2519         int mathfmt = outputModule->mathoutCB->currentIndex();
2520         if (mathfmt == -1)
2521                 mathfmt = 0;
2522         BufferParams::MathOutput const mo =
2523                 static_cast<BufferParams::MathOutput>(mathfmt);
2524         bp_.html_math_output = mo;
2525         bp_.html_be_strict = outputModule->strictCB->isChecked();
2526         bp_.html_math_img_scale = outputModule->mathimgSB->value();
2527
2528         // fonts
2529         bp_.fonts_roman =
2530                 fromqstr(fontModule->fontsRomanCO->
2531                         itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2532
2533         bp_.fonts_sans =
2534                 fromqstr(fontModule->fontsSansCO->
2535                         itemData(fontModule->fontsSansCO->currentIndex()).toString());
2536
2537         bp_.fonts_typewriter =
2538                 fromqstr(fontModule->fontsTypewriterCO->
2539                         itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2540
2541         if (fontModule->fontencCO->currentIndex() == 0)
2542                 bp_.fontenc = "global";
2543         else if (fontModule->fontencCO->currentIndex() == 1)
2544                 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2545         else if (fontModule->fontencCO->currentIndex() == 2)
2546                 bp_.fontenc = "default";
2547
2548         bp_.fonts_cjk =
2549                 fromqstr(fontModule->cjkFontLE->text());
2550
2551         bp_.fonts_sans_scale = fontModule->scaleSansSB->value();
2552
2553         bp_.fonts_typewriter_scale = fontModule->scaleTypewriterSB->value();
2554
2555         bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2556
2557         bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2558
2559         if (nontexfonts)
2560                 bp_.fonts_default_family = "default";
2561         else
2562                 bp_.fonts_default_family = GuiDocument::fontfamilies[
2563                         fontModule->fontsDefaultCO->currentIndex()];
2564
2565         if (fontModule->fontsizeCO->currentIndex() == 0)
2566                 bp_.fontsize = "default";
2567         else
2568                 bp_.fontsize =
2569                         fromqstr(fontModule->fontsizeCO->currentText());
2570
2571         // paper
2572         bp_.papersize = PAPER_SIZE(
2573                 pageLayoutModule->papersizeCO->currentIndex());
2574
2575         bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2576                 pageLayoutModule->paperwidthUnitCO);
2577
2578         bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2579                 pageLayoutModule->paperheightUnitCO);
2580
2581         if (pageLayoutModule->facingPagesCB->isChecked())
2582                 bp_.sides = TwoSides;
2583         else
2584                 bp_.sides = OneSide;
2585
2586         if (pageLayoutModule->landscapeRB->isChecked())
2587                 bp_.orientation = ORIENTATION_LANDSCAPE;
2588         else
2589                 bp_.orientation = ORIENTATION_PORTRAIT;
2590
2591         // margins
2592         bp_.use_geometry = !marginsModule->marginCB->isChecked();
2593
2594         Ui::MarginsUi const * m = marginsModule;
2595
2596         bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2597         bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2598         bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2599         bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2600         bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2601         bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2602         bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2603         bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2604
2605         // branches
2606         branchesModule->apply(bp_);
2607
2608         // PDF support
2609         PDFOptions & pdf = bp_.pdfoptions();
2610         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2611         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2612         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2613         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2614         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2615
2616         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2617         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2618         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2619         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2620
2621         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2622         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2623         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2624         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2625         pdf.backref =
2626                 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2627         if (pdfSupportModule->fullscreenCB->isChecked())
2628                 pdf.pagemode = pdf.pagemode_fullscreen;
2629         else
2630                 pdf.pagemode.clear();
2631         pdf.quoted_options = pdf.quoted_options_check(
2632                                 fromqstr(pdfSupportModule->optionsLE->text()));
2633 }
2634
2635
2636 void GuiDocument::paramsToDialog()
2637 {
2638         // set the default unit
2639         Length::UNIT const default_unit = Length::defaultUnit();
2640
2641         // preamble
2642         preambleModule->update(bp_, id());
2643         localLayout->update(bp_, id());
2644
2645         // date
2646         latexModule->suppressDateCB->setChecked(bp_.suppress_date);
2647         latexModule->refstyleCB->setChecked(bp_.use_refstyle);
2648
2649         // biblio
2650         biblioModule->citeDefaultRB->setChecked(
2651                 bp_.citeEngine() == ENGINE_BASIC);
2652
2653         biblioModule->citeNatbibRB->setChecked(
2654                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2655                 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2656
2657         biblioModule->citeStyleCO->setCurrentIndex(
2658                 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2659
2660         biblioModule->citeJurabibRB->setChecked(
2661                 bp_.citeEngine() == ENGINE_JURABIB);
2662
2663         biblioModule->bibtopicCB->setChecked(
2664                 bp_.use_bibtopic);
2665
2666         string command;
2667         string options =
2668                 split(bp_.bibtex_command, command, ' ');
2669
2670         int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2671         if (bpos != -1) {
2672                 biblioModule->bibtexCO->setCurrentIndex(bpos);
2673                 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
2674         } else {
2675                 // We reset to default if we do not know the specified compiler
2676                 // This is for security reasons
2677                 biblioModule->bibtexCO->setCurrentIndex(
2678                         biblioModule->bibtexCO->findData(toqstr("default")));
2679                 biblioModule->bibtexOptionsLE->clear();
2680         }
2681         biblioModule->bibtexOptionsLE->setEnabled(
2682                 biblioModule->bibtexCO->currentIndex() != 0);
2683
2684         // indices
2685         indicesModule->update(bp_);
2686
2687         // language & quotes
2688         int const pos = langModule->languageCO->findData(toqstr(
2689                 bp_.language->lang()));
2690         langModule->languageCO->setCurrentIndex(pos);
2691
2692         langModule->quoteStyleCO->setCurrentIndex(
2693                 bp_.quotes_language);
2694
2695         bool default_enc = true;
2696         if (bp_.inputenc != "auto") {
2697                 default_enc = false;
2698                 if (bp_.inputenc == "default") {
2699                         langModule->encodingCO->setCurrentIndex(0);
2700                 } else {
2701                         string enc_gui;
2702                         Encodings::const_iterator it = encodings.begin();
2703                         Encodings::const_iterator const end = encodings.end();
2704                         for (; it != end; ++it) {
2705                                 if (it->latexName() == bp_.inputenc) {
2706                                         enc_gui = it->guiName();
2707                                         break;
2708                                 }
2709                         }
2710                         int const i = langModule->encodingCO->findText(
2711                                         qt_(enc_gui));
2712                         if (i >= 0)
2713                                 langModule->encodingCO->setCurrentIndex(i);
2714                         else
2715                                 // unknown encoding. Set to default.
2716                                 default_enc = true;
2717                 }
2718         }
2719         langModule->defaultencodingRB->setChecked(default_enc);
2720         langModule->otherencodingRB->setChecked(!default_enc);
2721
2722         int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
2723         if (p == -1) {
2724                 langModule->languagePackageCO->setCurrentIndex(
2725                           langModule->languagePackageCO->findData("custom"));
2726                 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
2727         } else {
2728                 langModule->languagePackageCO->setCurrentIndex(p);
2729                 langModule->languagePackageLE->clear();
2730         }
2731
2732         //color
2733         if (bp_.isfontcolor) {
2734                 colorModule->fontColorPB->setStyleSheet(
2735                         colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
2736         }
2737         set_fontcolor = bp_.fontcolor;
2738         is_fontcolor = bp_.isfontcolor;
2739
2740         colorModule->noteFontColorPB->setStyleSheet(
2741                 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
2742         set_notefontcolor = bp_.notefontcolor;
2743
2744         if (bp_.isbackgroundcolor) {
2745                 colorModule->backgroundPB->setStyleSheet(
2746                         colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2747         }
2748         set_backgroundcolor = bp_.backgroundcolor;
2749         is_backgroundcolor = bp_.isbackgroundcolor;
2750
2751         colorModule->boxBackgroundPB->setStyleSheet(
2752                 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
2753         set_boxbgcolor = bp_.boxbgcolor;
2754
2755         // numbering
2756         int const min_toclevel = documentClass().min_toclevel();
2757         int const max_toclevel = documentClass().max_toclevel();
2758         if (documentClass().hasTocLevels()) {
2759                 numberingModule->setEnabled(true);
2760                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2761                 numberingModule->depthSL->setMaximum(max_toclevel);
2762                 numberingModule->depthSL->setValue(bp_.secnumdepth);
2763                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2764                 numberingModule->tocSL->setMaximum(max_toclevel);
2765                 numberingModule->tocSL->setValue(bp_.tocdepth);
2766                 updateNumbering();
2767         } else {
2768                 numberingModule->setEnabled(false);
2769                 numberingModule->tocTW->clear();
2770         }
2771
2772         // bullets
2773         bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2774         bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2775         bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2776         bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2777         bulletsModule->init();
2778
2779         // packages
2780         int nitem = findToken(tex_graphics, bp_.graphics_driver);
2781         if (nitem >= 0)
2782                 latexModule->psdriverCO->setCurrentIndex(nitem);
2783         updateModuleInfo();
2784
2785         mathsModule->amsCB->setChecked(
2786                 bp_.use_amsmath == BufferParams::package_on);
2787         mathsModule->amsautoCB->setChecked(
2788                 bp_.use_amsmath == BufferParams::package_auto);
2789
2790         mathsModule->esintCB->setChecked(
2791                 bp_.use_esint == BufferParams::package_on);
2792         mathsModule->esintautoCB->setChecked(
2793                 bp_.use_esint == BufferParams::package_auto);
2794
2795         mathsModule->mhchemCB->setChecked(
2796                 bp_.use_mhchem == BufferParams::package_on);
2797         mathsModule->mhchemautoCB->setChecked(
2798                 bp_.use_mhchem == BufferParams::package_auto);
2799
2800         mathsModule->mathdotsCB->setChecked(
2801                 bp_.use_mathdots == BufferParams::package_on);
2802         mathsModule->mathdotsautoCB->setChecked(
2803                 bp_.use_mathdots == BufferParams::package_auto);
2804
2805         mathsModule->undertildeCB->setChecked(
2806                 bp_.use_undertilde == BufferParams::package_on);
2807         mathsModule->undertildeautoCB->setChecked(
2808                 bp_.use_undertilde == BufferParams::package_auto);
2809
2810         switch (bp_.spacing().getSpace()) {
2811                 case Spacing::Other: nitem = 3; break;
2812                 case Spacing::Double: nitem = 2; break;
2813                 case Spacing::Onehalf: nitem = 1; break;
2814                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2815         }
2816
2817         // text layout
2818         string const & layoutID = bp_.baseClassID();
2819         setLayoutComboByIDString(layoutID);
2820
2821         updatePagestyle(documentClass().opt_pagestyle(),
2822                                  bp_.pagestyle);
2823
2824         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2825         if (bp_.spacing().getSpace() == Spacing::Other) {
2826                 doubleToWidget(textLayoutModule->lspacingLE,
2827                         bp_.spacing().getValueAsString());
2828         }
2829         setLSpacing(nitem);
2830
2831         if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
2832                 textLayoutModule->indentRB->setChecked(true);
2833                 string indentation = bp_.getIndentation().asLyXCommand();
2834                 int indent = 0;
2835                 if (indentation != "default") {
2836                         lengthToWidgets(textLayoutModule->indentLE,
2837                         textLayoutModule->indentLengthCO,
2838                         indentation, default_unit);
2839                         indent = 1;
2840                 }
2841                 textLayoutModule->indentCO->setCurrentIndex(indent);
2842                 setIndent(indent);
2843         } else {
2844                 textLayoutModule->skipRB->setChecked(true);
2845                 int skip = 0;
2846                 switch (bp_.getDefSkip().kind()) {
2847                 case VSpace::SMALLSKIP:
2848                         skip = 0;
2849                         break;
2850                 case VSpace::MEDSKIP:
2851                         skip = 1;
2852                         break;
2853                 case VSpace::BIGSKIP:
2854                         skip = 2;
2855                         break;
2856                 case VSpace::LENGTH:
2857                         {
2858                         skip = 3;
2859                         string const length = bp_.getDefSkip().asLyXCommand();
2860                         lengthToWidgets(textLayoutModule->skipLE,
2861                                 textLayoutModule->skipLengthCO,
2862                                 length, default_unit);
2863                         break;
2864                         }
2865                 default:
2866                         skip = 0;
2867                         break;
2868                 }
2869                 textLayoutModule->skipCO->setCurrentIndex(skip);
2870                 setSkip(skip);
2871         }
2872
2873         textLayoutModule->twoColumnCB->setChecked(
2874                 bp_.columns == 2);
2875
2876         if (!bp_.options.empty()) {
2877                 latexModule->optionsLE->setText(
2878                         toqstr(bp_.options));
2879         } else {
2880                 latexModule->optionsLE->setText(QString());
2881         }
2882
2883         // latex
2884         latexModule->defaultOptionsCB->setChecked(
2885                         bp_.use_default_options);
2886         updateSelectedModules();
2887         selectionManager->updateProvidedModules(
2888                         bp_.baseClass()->providedModules());
2889         selectionManager->updateExcludedModules(
2890                         bp_.baseClass()->excludedModules());
2891
2892         if (!documentClass().options().empty()) {
2893                 latexModule->defaultOptionsLE->setText(
2894                         toqstr(documentClass().options()));
2895         } else {
2896                 latexModule->defaultOptionsLE->setText(
2897                         toqstr(_("[No options predefined]")));
2898         }
2899
2900         latexModule->defaultOptionsLE->setEnabled(
2901                 bp_.use_default_options
2902                 && !documentClass().options().empty());
2903
2904         latexModule->defaultOptionsCB->setEnabled(
2905                 !documentClass().options().empty());
2906
2907         if (!bp_.master.empty()) {
2908                 latexModule->childDocGB->setChecked(true);
2909                 latexModule->childDocLE->setText(
2910                         toqstr(bp_.master));
2911         } else {
2912                 latexModule->childDocLE->setText(QString());
2913                 latexModule->childDocGB->setChecked(false);
2914         }
2915
2916         // Master/Child
2917         if (!bufferview() || !buffer().hasChildren()) {
2918                 masterChildModule->childrenTW->clear();
2919                 includeonlys_.clear();
2920                 docPS->showPanel(qt_("Child Documents"), false);
2921                 if (docPS->isCurrentPanel(qt_("Child Documents")))
2922                         docPS->setCurrentPanel(qt_("Document Class"));
2923         } else {
2924                 docPS->showPanel(qt_("Child Documents"), true);
2925                 masterChildModule->setEnabled(true);
2926                 includeonlys_ = bp_.getIncludedChildren();
2927                 updateIncludeonlys();
2928         }
2929         masterChildModule->maintainAuxCB->setChecked(
2930                 bp_.maintain_unincluded_children);
2931
2932         // Float Settings
2933         floatModule->set(bp_.float_placement);
2934
2935         // ListingsSettings
2936         // break listings_params to multiple lines
2937         string lstparams =
2938                 InsetListingsParams(bp_.listings_params).separatedParams();
2939         listingsModule->listingsED->setPlainText(toqstr(lstparams));
2940
2941         // Output
2942         // update combobox with formats
2943         updateDefaultFormat();
2944         int index = outputModule->defaultFormatCO->findData(toqstr(
2945                 bp_.default_output_format));
2946         // set to default if format is not found
2947         if (index == -1)
2948                 index = 0;
2949         outputModule->defaultFormatCO->setCurrentIndex(index);
2950         bool const os_fonts_available =
2951                 bp_.baseClass()->outputType() == lyx::LATEX
2952                 && LaTeXFeatures::isAvailable("fontspec");
2953         fontModule->osFontsCB->setEnabled(os_fonts_available);
2954         fontModule->osFontsCB->setChecked(
2955                 os_fonts_available && bp_.useNonTeXFonts);
2956
2957         outputModule->outputsyncCB->setChecked(bp_.output_sync);
2958         outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
2959
2960         outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
2961         outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
2962         outputModule->strictCB->setChecked(bp_.html_be_strict);
2963
2964         // Fonts
2965         updateFontsize(documentClass().opt_fontsize(),
2966                         bp_.fontsize);
2967
2968         QString font = toqstr(bp_.fonts_roman);
2969         int rpos = fontModule->fontsRomanCO->findData(font);
2970         if (rpos == -1) {
2971                 rpos = fontModule->fontsRomanCO->count();
2972                 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
2973         }
2974         fontModule->fontsRomanCO->setCurrentIndex(rpos);
2975
2976         font = toqstr(bp_.fonts_sans);
2977         int spos = fontModule->fontsSansCO->findData(font);
2978         if (spos == -1) {
2979                 spos = fontModule->fontsSansCO->count();
2980                 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
2981         }
2982         fontModule->fontsSansCO->setCurrentIndex(spos);
2983
2984         font = toqstr(bp_.fonts_typewriter);
2985         int tpos = fontModule->fontsTypewriterCO->findData(font);
2986         if (tpos == -1) {
2987                 tpos = fontModule->fontsTypewriterCO->count();
2988                 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
2989         }
2990         fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
2991
2992         if (bp_.useNonTeXFonts && os_fonts_available) {
2993                 fontModule->fontencLA->setEnabled(false);
2994                 fontModule->fontencCO->setEnabled(false);
2995                 fontModule->fontencLE->setEnabled(false);
2996         } else {
2997                 fontModule->fontencLA->setEnabled(true);
2998                 fontModule->fontencCO->setEnabled(true);
2999                 fontModule->fontencLE->setEnabled(true);
3000                 romanChanged(rpos);
3001                 sansChanged(spos);
3002                 ttChanged(tpos);
3003         }
3004
3005         if (!bp_.fonts_cjk.empty())
3006                 fontModule->cjkFontLE->setText(
3007                         toqstr(bp_.fonts_cjk));
3008         else
3009                 fontModule->cjkFontLE->setText(QString());
3010
3011         fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3012         fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3013         fontModule->scaleSansSB->setValue(bp_.fonts_sans_scale);
3014         fontModule->scaleTypewriterSB->setValue(bp_.fonts_typewriter_scale);
3015
3016         int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3017         if (nn >= 0)
3018                 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3019
3020         if (bp_.fontenc == "global") {
3021                 fontModule->fontencCO->setCurrentIndex(0);
3022                 fontModule->fontencLE->setEnabled(false);
3023         } else if (bp_.fontenc == "default") {
3024                 fontModule->fontencCO->setCurrentIndex(2);
3025                 fontModule->fontencLE->setEnabled(false);
3026         } else {
3027                 fontModule->fontencCO->setCurrentIndex(1);
3028                 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3029         }
3030
3031         // paper
3032         bool const extern_geometry =
3033                 documentClass().provides("geometry");
3034         int const psize = bp_.papersize;
3035         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3036         setCustomPapersize(!extern_geometry && psize == 1);
3037         pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3038
3039         bool const landscape =
3040                 bp_.orientation == ORIENTATION_LANDSCAPE;
3041         pageLayoutModule->landscapeRB->setChecked(landscape);
3042         pageLayoutModule->portraitRB->setChecked(!landscape);
3043         pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3044         pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3045
3046         pageLayoutModule->facingPagesCB->setChecked(
3047                 bp_.sides == TwoSides);
3048
3049         lengthToWidgets(pageLayoutModule->paperwidthLE,
3050                 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3051         lengthToWidgets(pageLayoutModule->paperheightLE,
3052                 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3053
3054         // margins
3055         Ui::MarginsUi * m = marginsModule;
3056
3057         setMargins();
3058
3059         lengthToWidgets(m->topLE, m->topUnit,
3060                 bp_.topmargin, default_unit);
3061
3062         lengthToWidgets(m->bottomLE, m->bottomUnit,
3063                 bp_.bottommargin, default_unit);
3064
3065         lengthToWidgets(m->innerLE, m->innerUnit,
3066                 bp_.leftmargin, default_unit);
3067
3068         lengthToWidgets(m->outerLE, m->outerUnit,
3069                 bp_.rightmargin, default_unit);
3070
3071         lengthToWidgets(m->headheightLE, m->headheightUnit,
3072                 bp_.headheight, default_unit);
3073
3074         lengthToWidgets(m->headsepLE, m->headsepUnit,
3075                 bp_.headsep, default_unit);
3076
3077         lengthToWidgets(m->footskipLE, m->footskipUnit,
3078                 bp_.footskip, default_unit);
3079
3080         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3081                 bp_.columnsep, default_unit);
3082
3083         // branches
3084         updateUnknownBranches();
3085         branchesModule->update(bp_);
3086
3087         // PDF support
3088         PDFOptions const & pdf = bp_.pdfoptions();
3089         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3090         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3091         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3092         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3093         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3094
3095         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3096         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3097         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3098
3099         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3100
3101         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3102         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3103         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3104         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3105
3106         nn = findToken(backref_opts, pdf.backref);
3107         if (nn >= 0)
3108                 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3109
3110         pdfSupportModule->fullscreenCB->setChecked
3111                 (pdf.pagemode == pdf.pagemode_fullscreen);
3112
3113         pdfSupportModule->optionsLE->setText(
3114                 toqstr(pdf.quoted_options));
3115
3116         // Make sure that the bc is in the INITIAL state
3117         if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3118                 bc().restore();
3119
3120         // clear changed branches cache
3121         changedBranches_.clear();
3122 }
3123
3124
3125 void GuiDocument::saveDocDefault()
3126 {
3127         // we have to apply the params first
3128         applyView();
3129         saveAsDefault();
3130 }
3131
3132
3133 void GuiDocument::updateAvailableModules()
3134 {
3135         modules_av_model_.clear();
3136         list<modInfoStruct> const & modInfoList = getModuleInfo();
3137         list<modInfoStruct>::const_iterator mit = modInfoList.begin();
3138         list<modInfoStruct>::const_iterator men = modInfoList.end();
3139         for (int i = 0; mit != men; ++mit, ++i)
3140                 modules_av_model_.insertRow(i, mit->name, mit->id,
3141                                 mit->description);
3142 }
3143
3144
3145 void GuiDocument::updateSelectedModules()
3146 {
3147         modules_sel_model_.clear();
3148         list<modInfoStruct> const selModList = getSelectedModules();
3149         list<modInfoStruct>::const_iterator mit = selModList.begin();
3150         list<modInfoStruct>::const_iterator men = selModList.end();
3151         for (int i = 0; mit != men; ++mit, ++i)
3152                 modules_sel_model_.insertRow(i, mit->name, mit->id,
3153                                 mit->description);
3154 }
3155
3156
3157 void GuiDocument::updateIncludeonlys()
3158 {
3159         masterChildModule->childrenTW->clear();
3160         QString const no = qt_("No");
3161         QString const yes = qt_("Yes");
3162
3163         if (includeonlys_.empty()) {
3164                 masterChildModule->includeallRB->setChecked(true);
3165                 masterChildModule->childrenTW->setEnabled(false);
3166                 masterChildModule->maintainAuxCB->setEnabled(false);
3167         } else {
3168                 masterChildModule->includeonlyRB->setChecked(true);
3169                 masterChildModule->childrenTW->setEnabled(true);
3170                 masterChildModule->maintainAuxCB->setEnabled(true);
3171         }
3172         QTreeWidgetItem * item = 0;
3173         ListOfBuffers children = buffer().getChildren();
3174         ListOfBuffers::const_iterator it  = children.begin();
3175         ListOfBuffers::const_iterator end = children.end();
3176         bool has_unincluded = false;
3177         bool all_unincluded = true;
3178         for (; it != end; ++it) {
3179                 item = new QTreeWidgetItem(masterChildModule->childrenTW);
3180                 // FIXME Unicode
3181                 string const name =
3182                         to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3183                                                         from_utf8(buffer().filePath())));
3184                 item->setText(0, toqstr(name));
3185                 item->setText(1, isChildIncluded(name) ? yes : no);
3186                 if (!isChildIncluded(name))
3187                         has_unincluded = true;
3188                 else
3189                         all_unincluded = false;
3190         }
3191         // Both if all childs are included and if none is included
3192         // is equal to "include all" (i.e., ommit \includeonly).
3193         // Thus, reset the GUI.
3194         if (!has_unincluded || all_unincluded) {
3195                 masterChildModule->includeallRB->setChecked(true);
3196                 masterChildModule->childrenTW->setEnabled(false);
3197                 includeonlys_.clear();
3198         }
3199         // If all are included, we need to update again.
3200         if (!has_unincluded)
3201                 updateIncludeonlys();
3202 }
3203
3204
3205 void GuiDocument::updateContents()
3206 {
3207         // Nothing to do here as the document settings is not cursor dependant.
3208         return;
3209 }
3210
3211
3212 void GuiDocument::useClassDefaults()
3213 {
3214         if (applyPB->isEnabled()) {
3215                 int const ret = Alert::prompt(_("Unapplied changes"),
3216                                 _("Some changes in the dialog were not yet applied.\n"
3217                                   "If you do not apply now, they will be lost after this action."),
3218                                 1, 1, _("&Apply"), _("&Dismiss"));
3219                 if (ret == 0)
3220                         applyView();
3221         }
3222
3223         int idx = latexModule->classCO->currentIndex();
3224         string const classname = classes_model_.getIDString(idx);
3225         if (!bp_.setBaseClass(classname)) {
3226                 Alert::error(_("Error"), _("Unable to set document class."));
3227                 return;
3228         }
3229         bp_.useClassDefaults();
3230         paramsToDialog();
3231 }
3232
3233
3234 void GuiDocument::setLayoutComboByIDString(string const & idString)
3235 {
3236         int idx = classes_model_.findIDString(idString);
3237         if (idx < 0)
3238                 Alert::warning(_("Can't set layout!"),
3239                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3240         else
3241                 latexModule->classCO->setCurrentIndex(idx);
3242 }
3243
3244
3245 bool GuiDocument::isValid()
3246 {
3247         return
3248                 validateListingsParameters().isEmpty() &&
3249                 localLayout->isValid() &&
3250                 (
3251                         // if we're asking for skips between paragraphs
3252                         !textLayoutModule->skipRB->isChecked() ||
3253                         // then either we haven't chosen custom
3254                         textLayoutModule->skipCO->currentIndex() != 3 ||
3255                         // or else a length has been given
3256                         !textLayoutModule->skipLE->text().isEmpty()
3257                 ) &&
3258                 (
3259                         // if we're asking for indentation
3260                         !textLayoutModule->indentRB->isChecked() ||
3261                         // then either we haven't chosen custom
3262                         textLayoutModule->indentCO->currentIndex() != 1 ||
3263                         // or else a length has been given
3264                         !textLayoutModule->indentLE->text().isEmpty()
3265                 );
3266 }
3267
3268
3269 char const * const GuiDocument::fontfamilies[5] = {
3270         "default", "rmdefault", "sfdefault", "ttdefault", ""
3271 };
3272
3273
3274 char const * GuiDocument::fontfamilies_gui[5] = {
3275         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3276 };
3277
3278
3279 bool GuiDocument::initialiseParams(string const &)
3280 {
3281         BufferView const * view = bufferview();
3282         if (!view) {
3283                 bp_ = BufferParams();
3284                 paramsToDialog();
3285                 return true;
3286         }
3287         bp_ = view->buffer().params();
3288         loadModuleInfo();
3289         updateAvailableModules();
3290         //FIXME It'd be nice to make sure here that the selected
3291         //modules are consistent: That required modules are actually
3292         //selected, and that we don't have conflicts. If so, we could
3293         //at least pop up a warning.
3294         paramsToDialog();
3295         return true;
3296 }
3297
3298
3299 void GuiDocument::clearParams()
3300 {
3301         bp_ = BufferParams();
3302 }
3303
3304
3305 BufferId GuiDocument::id() const
3306 {
3307         BufferView const * const view = bufferview();
3308         return view? &view->buffer() : 0;
3309 }
3310
3311
3312 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3313 {
3314         return moduleNames_;
3315 }
3316
3317
3318 list<GuiDocument::modInfoStruct> const
3319                 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3320 {
3321         LayoutModuleList::const_iterator it =  mods.begin();
3322         LayoutModuleList::const_iterator end = mods.end();
3323         list<modInfoStruct> mInfo;
3324         for (; it != end; ++it) {
3325                 modInfoStruct m;
3326                 m.id = *it;
3327                 LyXModule const * const mod = theModuleList[*it];
3328                 if (mod)
3329                         // FIXME Unicode
3330                         m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
3331                 else
3332                         m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
3333                 mInfo.push_back(m);
3334         }
3335         return mInfo;
3336 }
3337
3338
3339 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3340 {
3341         return makeModuleInfo(params().getModules());
3342 }
3343
3344
3345 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3346 {
3347         return makeModuleInfo(params().baseClass()->providedModules());
3348 }
3349
3350
3351 DocumentClass const & GuiDocument::documentClass() const
3352 {
3353         return bp_.documentClass();
3354 }
3355
3356
3357 static void dispatch_bufferparams(Dialog const & dialog,
3358         BufferParams const & bp, FuncCode lfun)
3359 {
3360         ostringstream ss;
3361         ss << "\\begin_header\n";
3362         bp.writeFile(ss);
3363         ss << "\\end_header\n";
3364         dialog.dispatch(FuncRequest(lfun, ss.str()));
3365 }
3366
3367
3368 void GuiDocument::dispatchParams()
3369 {
3370         // This must come first so that a language change is correctly noticed
3371         setLanguage();
3372
3373         // Apply the BufferParams. Note that this will set the base class
3374         // and then update the buffer's layout.
3375         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
3376
3377         if (!params().master.empty()) {
3378                 FileName const master_file = support::makeAbsPath(params().master,
3379                            support::onlyPath(buffer().absFileName()));
3380                 if (isLyXFileName(master_file.absFileName())) {
3381                         Buffer * master = checkAndLoadLyXFile(master_file);
3382                         if (master) {
3383                                 if (master->isChild(const_cast<Buffer *>(&buffer())))
3384                                         const_cast<Buffer &>(buffer()).setParent(master);
3385                                 else
3386                                         Alert::warning(_("Assigned master does not include this file"),
3387                                                 bformat(_("You must include this file in the document\n"
3388                                                           "'%1$s' in order to use the master document\n"
3389                                                           "feature."), from_utf8(params().master)));
3390                         } else
3391                                 Alert::warning(_("Could not load master"),
3392                                                 bformat(_("The master document '%1$s'\n"
3393                                                            "could not be loaded."),
3394                                                            from_utf8(params().master)));
3395                 }
3396         }
3397
3398         // Generate the colours requested by each new branch.
3399         BranchList & branchlist = params().branchlist();
3400         if (!branchlist.empty()) {
3401                 BranchList::const_iterator it = branchlist.begin();
3402                 BranchList::const_iterator const end = branchlist.end();
3403                 for (; it != end; ++it) {
3404                         docstring const & current_branch = it->branch();
3405                         Branch const * branch = branchlist.find(current_branch);
3406                         string const x11hexname = X11hexname(branch->color());
3407                         // display the new color
3408                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3409                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3410                 }
3411
3412                 // Open insets of selected branches, close deselected ones
3413                 dispatch(FuncRequest(LFUN_INSET_FORALL,
3414                         "Branch inset-toggle assign"));
3415         }
3416         // rename branches in the document
3417         executeBranchRenaming();
3418         // and clear changed branches cache
3419         changedBranches_.clear();
3420
3421         // Generate the colours requested by indices.
3422         IndicesList & indiceslist = params().indiceslist();
3423         if (!indiceslist.empty()) {
3424                 IndicesList::const_iterator it = indiceslist.begin();
3425                 IndicesList::const_iterator const end = indiceslist.end();
3426                 for (; it != end; ++it) {
3427                         docstring const & current_index = it->shortcut();
3428                         Index const * index = indiceslist.findShortcut(current_index);
3429                         string const x11hexname = X11hexname(index->color());
3430                         // display the new color
3431                         docstring const str = current_index + ' ' + from_ascii(x11hexname);
3432                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
3433                 }
3434         }
3435         // FIXME LFUN
3436         // If we used an LFUN, we would not need these two lines:
3437         BufferView * bv = const_cast<BufferView *>(bufferview());
3438         bv->processUpdateFlags(Update::Force | Update::FitCursor);
3439 }
3440
3441
3442 void GuiDocument::setLanguage() const
3443 {
3444         Language const * const newL = bp_.language;
3445         if (buffer().params().language == newL)
3446                 return;
3447
3448         string const & lang_name = newL->lang();
3449         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3450 }
3451
3452
3453 void GuiDocument::saveAsDefault() const
3454 {
3455         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3456 }
3457
3458
3459 bool GuiDocument::isFontAvailable(string const & font) const
3460 {
3461         if (font == "default" || font == "cmr"
3462             || font == "cmss" || font == "cmtt")
3463                 // these are standard
3464                 return true;
3465         if (font == "lmodern" || font == "lmss" || font == "lmtt")
3466                 return LaTeXFeatures::isAvailable("lmodern");
3467         if (font == "times" || font == "palatino"
3468                  || font == "helvet" || font == "courier")
3469                 return LaTeXFeatures::isAvailable("psnfss");
3470         if (font == "cmbr" || font == "cmtl")
3471                 return LaTeXFeatures::isAvailable("cmbright");
3472         if (font == "utopia")
3473                 return LaTeXFeatures::isAvailable("utopia")
3474                         || LaTeXFeatures::isAvailable("fourier");
3475         if (font == "beraserif" || font == "berasans"
3476                 || font == "beramono")
3477                 return LaTeXFeatures::isAvailable("bera");
3478         return LaTeXFeatures::isAvailable(font);
3479 }
3480
3481
3482 bool GuiDocument::providesOSF(string const & font) const
3483 {
3484         if (fontModule->osFontsCB->isChecked())
3485                 // FIXME: we should check if the fonts really
3486                 // have OSF support. But how?
3487                 return true;
3488         if (font == "cmr")
3489                 return isFontAvailable("eco");
3490         if (font == "palatino")
3491                 return isFontAvailable("mathpazo");
3492         return false;
3493 }
3494
3495
3496 bool GuiDocument::providesSC(string const & font) const
3497 {
3498         if (fontModule->osFontsCB->isChecked())
3499                 return false;
3500         if (font == "palatino")
3501                 return isFontAvailable("mathpazo");
3502         if (font == "utopia")
3503                 return isFontAvailable("fourier");
3504         return false;
3505 }
3506
3507
3508 bool GuiDocument::providesScale(string const & font) const
3509 {
3510         if (fontModule->osFontsCB->isChecked())
3511                 return true;
3512         return font == "helvet" || font == "luximono"
3513                 || font == "berasans"  || font == "beramono";
3514 }
3515
3516
3517 void GuiDocument::loadModuleInfo()
3518 {
3519         moduleNames_.clear();
3520         LyXModuleList::const_iterator it  = theModuleList.begin();
3521         LyXModuleList::const_iterator end = theModuleList.end();
3522         for (; it != end; ++it) {
3523                 modInfoStruct m;
3524                 m.id = it->getID();
3525                 // FIXME Unicode
3526                 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3527                 // this is supposed to give us the first sentence of the description
3528                 // FIXME Unicode
3529                 QString desc =
3530                         toqstr(translateIfPossible(from_utf8(it->getDescription())));
3531                 int const pos = desc.indexOf(".");
3532                 if (pos > 0)
3533                         desc.truncate(pos + 1);
3534                 m.description = desc;
3535                 moduleNames_.push_back(m);
3536         }
3537 }
3538
3539
3540 void GuiDocument::updateUnknownBranches()
3541 {
3542         if (!bufferview())
3543                 return;
3544         list<docstring> used_branches;
3545         buffer().getUsedBranches(used_branches);
3546         list<docstring>::const_iterator it = used_branches.begin();
3547         QStringList unknown_branches;
3548         for (; it != used_branches.end() ; ++it) {
3549                 if (!buffer().params().branchlist().find(*it))
3550                         unknown_branches.append(toqstr(*it));
3551         }
3552         branchesModule->setUnknownBranches(unknown_branches);
3553 }
3554
3555
3556 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3557 {
3558         map<docstring, docstring>::iterator it = changedBranches_.begin();
3559         for (; it != changedBranches_.end() ; ++it) {
3560                 if (it->second == oldname) {
3561                         // branch has already been renamed
3562                         it->second = newname;
3563                         return;
3564                 }
3565         }
3566         // store new name
3567         changedBranches_[oldname] = newname;
3568 }
3569
3570
3571 void GuiDocument::executeBranchRenaming() const
3572 {
3573         map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3574         for (; it != changedBranches_.end() ; ++it) {
3575                 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3576                 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3577         }
3578 }
3579
3580
3581 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3582
3583
3584 } // namespace frontend
3585 } // namespace lyx
3586
3587 #include "moc_GuiDocument.cpp"