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