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                 masterChildModule->setEnabled(false);
2492                 masterChildModule->includeallRB->setChecked(true);
2493                 includeonlys_.clear();
2494         } else {
2495                 masterChildModule->setEnabled(true);
2496                 includeonlys_ = bp_.getIncludedChildren();
2497                 updateIncludeonlys();
2498         }
2499         masterChildModule->maintainAuxCB->setChecked(
2500                 bp_.maintain_unincluded_children);
2501
2502         // Float Settings
2503         floatModule->set(bp_.float_placement);
2504
2505         // ListingsSettings
2506         // break listings_params to multiple lines
2507         string lstparams =
2508                 InsetListingsParams(bp_.listings_params).separatedParams();
2509         listingsModule->listingsED->setPlainText(toqstr(lstparams));
2510
2511         // Output
2512         // update combobox with formats
2513         updateDefaultFormat();
2514         int index = outputModule->defaultFormatCO->findData(toqstr(
2515                 bp_.defaultOutputFormat));
2516         // set to default if format is not found
2517         if (index == -1)
2518                 index = 0;
2519         outputModule->defaultFormatCO->setCurrentIndex(index);
2520         outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2521         outputModule->xetexCB->setChecked(
2522                 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2523
2524         // Fonts
2525         updateFontsize(documentClass().opt_fontsize(),
2526                         bp_.fontsize);
2527
2528         if (bp_.useXetex) {
2529                 fontModule->fontencLA->setEnabled(false);
2530                 fontModule->fontencCO->setEnabled(false);
2531                 fontModule->fontencLE->setEnabled(false);
2532                 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2533                         if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2534                                 fontModule->fontsRomanCO->setCurrentIndex(i);
2535                                 return;
2536                         }
2537                 }
2538
2539                 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2540                         if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2541                                 fontModule->fontsSansCO->setCurrentIndex(i);
2542                                 return;
2543                         }
2544                 }
2545                 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2546                         if (fontModule->fontsTypewriterCO->itemText(i) ==
2547                                 toqstr(bp_.fontsTypewriter)) {
2548                                 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2549                                 return;
2550                         }
2551                 }
2552         } else {
2553                 fontModule->fontencLA->setEnabled(true);
2554                 fontModule->fontencCO->setEnabled(true);
2555                 fontModule->fontencLE->setEnabled(true);
2556                 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2557                 if (n >= 0) {
2558                         fontModule->fontsRomanCO->setCurrentIndex(n);
2559                         romanChanged(n);
2560                 }
2561
2562                 n = findToken(tex_fonts_sans, bp_.fontsSans);
2563                 if (n >= 0) {
2564                         fontModule->fontsSansCO->setCurrentIndex(n);
2565                         sansChanged(n);
2566                 }
2567
2568                 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2569                 if (n >= 0) {
2570                         fontModule->fontsTypewriterCO->setCurrentIndex(n);
2571                         ttChanged(n);
2572                 }
2573         }
2574
2575         if (!bp_.fontsCJK.empty())
2576                 fontModule->cjkFontLE->setText(
2577                         toqstr(bp_.fontsCJK));
2578         else
2579                 fontModule->cjkFontLE->setText(QString());
2580
2581         fontModule->fontScCB->setChecked(bp_.fontsSC);
2582         fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2583         fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2584         fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2585
2586         int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2587         if (nn >= 0)
2588                 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2589
2590         if (bp_.fontenc == "global")
2591                 fontModule->fontencCO->setCurrentIndex(0);
2592         else if (bp_.fontenc == "default")
2593                 fontModule->fontencCO->setCurrentIndex(2);
2594         else {
2595                 fontModule->fontencCO->setCurrentIndex(1);
2596                 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
2597         }
2598
2599         // paper
2600         bool const extern_geometry =
2601                 documentClass().provides("geometry");
2602         int const psize = bp_.papersize;
2603         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2604         setCustomPapersize(!extern_geometry && psize == 1);
2605         pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2606
2607         bool const landscape =
2608                 bp_.orientation == ORIENTATION_LANDSCAPE;
2609         pageLayoutModule->landscapeRB->setChecked(landscape);
2610         pageLayoutModule->portraitRB->setChecked(!landscape);
2611         pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2612         pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2613
2614         pageLayoutModule->facingPagesCB->setChecked(
2615                 bp_.sides == TwoSides);
2616
2617         pageLayoutModule->backgroundPB->setStyleSheet(
2618                 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2619         set_backgroundcolor = bp_.backgroundcolor;
2620
2621         lengthToWidgets(pageLayoutModule->paperwidthLE,
2622                 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2623         lengthToWidgets(pageLayoutModule->paperheightLE,
2624                 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2625
2626         // margins
2627         Ui::MarginsUi * m = marginsModule;
2628
2629         setMargins(!bp_.use_geometry);
2630
2631         lengthToWidgets(m->topLE, m->topUnit,
2632                 bp_.topmargin, defaultUnit);
2633
2634         lengthToWidgets(m->bottomLE, m->bottomUnit,
2635                 bp_.bottommargin, defaultUnit);
2636
2637         lengthToWidgets(m->innerLE, m->innerUnit,
2638                 bp_.leftmargin, defaultUnit);
2639
2640         lengthToWidgets(m->outerLE, m->outerUnit,
2641                 bp_.rightmargin, defaultUnit);
2642
2643         lengthToWidgets(m->headheightLE, m->headheightUnit,
2644                 bp_.headheight, defaultUnit);
2645
2646         lengthToWidgets(m->headsepLE, m->headsepUnit,
2647                 bp_.headsep, defaultUnit);
2648
2649         lengthToWidgets(m->footskipLE, m->footskipUnit,
2650                 bp_.footskip, defaultUnit);
2651
2652         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2653                 bp_.columnsep, defaultUnit);
2654
2655         // branches
2656         updateUnknownBranches();
2657         branchesModule->update(bp_);
2658
2659         // PDF support
2660         PDFOptions const & pdf = bp_.pdfoptions();
2661         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2662         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2663         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2664         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2665         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2666
2667         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2668         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2669         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2670
2671         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2672
2673         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2674         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2675         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2676         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2677
2678         nn = findToken(backref_opts, pdf.backref);
2679         if (nn >= 0)
2680                 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2681
2682         pdfSupportModule->fullscreenCB->setChecked
2683                 (pdf.pagemode == pdf.pagemode_fullscreen);
2684
2685         pdfSupportModule->optionsLE->setText(
2686                 toqstr(pdf.quoted_options));
2687
2688         // Make sure that the bc is in the INITIAL state
2689         if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2690                 bc().restore();
2691
2692         // clear changed branches cache
2693         changedBranches_.clear();
2694 }
2695
2696
2697 void GuiDocument::saveDocDefault()
2698 {
2699         // we have to apply the params first
2700         applyView();
2701         saveAsDefault();
2702 }
2703
2704
2705 void GuiDocument::updateAvailableModules()
2706 {
2707         modules_av_model_.clear();
2708         list<modInfoStruct> const & modInfoList = getModuleInfo();
2709         list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2710         list<modInfoStruct>::const_iterator men = modInfoList.end();
2711         for (int i = 0; mit != men; ++mit, ++i)
2712                 modules_av_model_.insertRow(i, mit->name, mit->id,
2713                                 mit->description);
2714 }
2715
2716
2717 void GuiDocument::updateSelectedModules()
2718 {
2719         modules_sel_model_.clear();
2720         list<modInfoStruct> const selModList = getSelectedModules();
2721         list<modInfoStruct>::const_iterator mit = selModList.begin();
2722         list<modInfoStruct>::const_iterator men = selModList.end();
2723         for (int i = 0; mit != men; ++mit, ++i)
2724                 modules_sel_model_.insertRow(i, mit->name, mit->id,
2725                                 mit->description);
2726 }
2727
2728
2729 void GuiDocument::updateIncludeonlys()
2730 {
2731         masterChildModule->childrenTW->clear();
2732         QString const no = qt_("No");
2733         QString const yes = qt_("Yes");
2734
2735         if (includeonlys_.empty()) {
2736                 masterChildModule->includeallRB->setChecked(true);
2737                 masterChildModule->childrenTW->setEnabled(false);
2738                 masterChildModule->maintainAuxCB->setEnabled(false);
2739         } else {
2740                 masterChildModule->includeonlyRB->setChecked(true);
2741                 masterChildModule->childrenTW->setEnabled(true);
2742                 masterChildModule->maintainAuxCB->setEnabled(true);
2743         }
2744         QTreeWidgetItem * item = 0;
2745         std::vector<Buffer *> children = buffer().getChildren(false);
2746         vector<Buffer *>::const_iterator it  = children.begin();
2747         vector<Buffer *>::const_iterator end = children.end();
2748         bool has_unincluded = false;
2749         bool all_unincluded = true;
2750         for (; it != end; ++it) {
2751                 item = new QTreeWidgetItem(masterChildModule->childrenTW);
2752                 // FIXME Unicode
2753                 string const name =
2754                         to_utf8(makeRelPath(from_utf8((*it)->fileName().absFilename()),
2755                                                         from_utf8(buffer().filePath())));
2756                 item->setText(0, toqstr(name));
2757                 item->setText(1, isChildIncluded(name) ? yes : no);
2758                 if (!isChildIncluded(name))
2759                         has_unincluded = true;
2760                 else
2761                         all_unincluded = false;
2762         }
2763         // Both if all childs are included and if none is included
2764         // is equal to "include all" (i.e., ommit \includeonly).
2765         // Thus, reset the GUI.
2766         if (!has_unincluded || all_unincluded) {
2767                 masterChildModule->includeallRB->setChecked(true);
2768                 masterChildModule->childrenTW->setEnabled(false);
2769                 includeonlys_.clear();
2770         }
2771         // If all are included, we need to update again.
2772         if (!has_unincluded)
2773                 updateIncludeonlys();
2774 }
2775
2776
2777 void GuiDocument::updateContents()
2778 {
2779         // Nothing to do here as the document settings is not cursor dependant.
2780         return;
2781 }
2782
2783
2784 void GuiDocument::useClassDefaults()
2785 {
2786         if (applyPB->isEnabled()) {
2787                 int const ret = Alert::prompt(_("Unapplied changes"),
2788                                 _("Some changes in the dialog were not yet applied.\n"
2789                                   "If you do not apply now, they will be lost after this action."),
2790                                 1, 1, _("&Apply"), _("&Dismiss"));
2791                 if (ret == 0)
2792                         applyView();
2793         }
2794
2795         int idx = latexModule->classCO->currentIndex();
2796         string const classname = classes_model_.getIDString(idx);
2797         if (!bp_.setBaseClass(classname)) {
2798                 Alert::error(_("Error"), _("Unable to set document class."));
2799                 return;
2800         }
2801         bp_.useClassDefaults();
2802         paramsToDialog();
2803 }
2804
2805
2806 void GuiDocument::setLayoutComboByIDString(string const & idString)
2807 {
2808         int idx = classes_model_.findIDString(idString);
2809         if (idx < 0)
2810                 Alert::warning(_("Can't set layout!"),
2811                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2812         else
2813                 latexModule->classCO->setCurrentIndex(idx);
2814 }
2815
2816
2817 bool GuiDocument::isValid()
2818 {
2819         return validateListingsParameters().isEmpty()
2820                 && (textLayoutModule->skipCO->currentIndex() != 3
2821                         || !textLayoutModule->skipLE->text().isEmpty()
2822                         || textLayoutModule->indentRB->isChecked())
2823                 && (textLayoutModule->indentCO->currentIndex() != 1
2824                         || !textLayoutModule->indentLE->text().isEmpty()
2825                         || textLayoutModule->skipRB->isChecked());
2826 }
2827
2828
2829 char const * const GuiDocument::fontfamilies[5] = {
2830         "default", "rmdefault", "sfdefault", "ttdefault", ""
2831 };
2832
2833
2834 char const * GuiDocument::fontfamilies_gui[5] = {
2835         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2836 };
2837
2838
2839 bool GuiDocument::initialiseParams(string const &)
2840 {
2841         BufferView const * view = bufferview();
2842         if (!view) {
2843                 bp_ = BufferParams();
2844                 paramsToDialog();
2845                 return true;
2846         }
2847         bp_ = view->buffer().params();
2848         loadModuleInfo();
2849         updateAvailableModules();
2850         //FIXME It'd be nice to make sure here that the selected
2851         //modules are consistent: That required modules are actually
2852         //selected, and that we don't have conflicts. If so, we could
2853         //at least pop up a warning.
2854         paramsToDialog();
2855         return true;
2856 }
2857
2858
2859 void GuiDocument::clearParams()
2860 {
2861         bp_ = BufferParams();
2862 }
2863
2864
2865 BufferId GuiDocument::id() const
2866 {
2867         BufferView const * const view = bufferview();
2868         return view? &view->buffer() : 0;
2869 }
2870
2871
2872 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2873 {
2874         return moduleNames_;
2875 }
2876
2877
2878 list<GuiDocument::modInfoStruct> const
2879                 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2880 {
2881         LayoutModuleList::const_iterator it =  mods.begin();
2882         LayoutModuleList::const_iterator end = mods.end();
2883         list<modInfoStruct> mInfo;
2884         for (; it != end; ++it) {
2885                 modInfoStruct m;
2886                 m.id = *it;
2887                 LyXModule const * const mod = theModuleList[*it];
2888                 if (mod)
2889                         // FIXME Unicode
2890                         m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2891                 else
2892                         m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2893                 mInfo.push_back(m);
2894         }
2895         return mInfo;
2896 }
2897
2898
2899 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2900 {
2901         return makeModuleInfo(params().getModules());
2902 }
2903
2904
2905 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2906 {
2907         return makeModuleInfo(params().baseClass()->providedModules());
2908 }
2909
2910
2911 DocumentClass const & GuiDocument::documentClass() const
2912 {
2913         return bp_.documentClass();
2914 }
2915
2916
2917 static void dispatch_bufferparams(Dialog const & dialog,
2918         BufferParams const & bp, FuncCode lfun)
2919 {
2920         ostringstream ss;
2921         ss << "\\begin_header\n";
2922         bp.writeFile(ss);
2923         ss << "\\end_header\n";
2924         dialog.dispatch(FuncRequest(lfun, ss.str()));
2925 }
2926
2927
2928 void GuiDocument::dispatchParams()
2929 {
2930         // This must come first so that a language change is correctly noticed
2931         setLanguage();
2932
2933         // Apply the BufferParams. Note that this will set the base class
2934         // and then update the buffer's layout.
2935         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2936
2937         if (!params().master.empty()) {
2938                 FileName const master_file = support::makeAbsPath(params().master,
2939                            support::onlyPath(buffer().absFileName()));
2940                 if (isLyXFilename(master_file.absFilename())) {
2941                         Buffer * master = checkAndLoadLyXFile(master_file);
2942                         if (master) {
2943                                 if (master->isChild(const_cast<Buffer *>(&buffer())))
2944                                         const_cast<Buffer &>(buffer()).setParent(master);
2945                                 else
2946                                         Alert::warning(_("Assigned master does not include this file"),
2947                                                 bformat(_("You must include this file in the document\n"
2948                                                           "'%1$s' in order to use the master document\n"
2949                                                           "feature."), from_utf8(params().master)));
2950                         } else
2951                                 Alert::warning(_("Could not load master"),
2952                                                 bformat(_("The master document '%1$s'\n"
2953                                                            "could not be loaded."),
2954                                                            from_utf8(params().master)));
2955                 }
2956         }
2957
2958         // Generate the colours requested by each new branch.
2959         BranchList & branchlist = params().branchlist();
2960         if (!branchlist.empty()) {
2961                 BranchList::const_iterator it = branchlist.begin();
2962                 BranchList::const_iterator const end = branchlist.end();
2963                 for (; it != end; ++it) {
2964                         docstring const & current_branch = it->branch();
2965                         Branch const * branch = branchlist.find(current_branch);
2966                         string const x11hexname = X11hexname(branch->color());
2967                         // display the new color
2968                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2969                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
2970                 }
2971
2972                 // Open insets of selected branches, close deselected ones
2973                 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2974                         "assign branch"));
2975         }
2976         // rename branches in the document
2977         executeBranchRenaming();
2978         // and clear changed branches cache
2979         changedBranches_.clear();
2980
2981         // Generate the colours requested by indices.
2982         IndicesList & indiceslist = params().indiceslist();
2983         if (!indiceslist.empty()) {
2984                 IndicesList::const_iterator it = indiceslist.begin();
2985                 IndicesList::const_iterator const end = indiceslist.end();
2986                 for (; it != end; ++it) {
2987                         docstring const & current_index = it->shortcut();
2988                         Index const * index = indiceslist.findShortcut(current_index);
2989                         string const x11hexname = X11hexname(index->color());
2990                         // display the new color
2991                         docstring const str = current_index + ' ' + from_ascii(x11hexname);
2992                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
2993                 }
2994         }
2995         // FIXME: If we used an LFUN, we would not need those two lines:
2996         BufferView * bv = const_cast<BufferView *>(bufferview());
2997         bv->processUpdateFlags(Update::Force | Update::FitCursor);
2998 }
2999
3000
3001 void GuiDocument::setLanguage() const
3002 {
3003         Language const * const newL = bp_.language;
3004         if (buffer().params().language == newL)
3005                 return;
3006
3007         string const & lang_name = newL->lang();
3008         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3009 }
3010
3011
3012 void GuiDocument::saveAsDefault() const
3013 {
3014         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
3015 }
3016
3017
3018 bool GuiDocument::isFontAvailable(string const & font) const
3019 {
3020         if (font == "default" || font == "cmr"
3021             || font == "cmss" || font == "cmtt")
3022                 // these are standard
3023                 return true;
3024         if (font == "lmodern" || font == "lmss" || font == "lmtt")
3025                 return LaTeXFeatures::isAvailable("lmodern");
3026         if (font == "times" || font == "palatino"
3027                  || font == "helvet" || font == "courier")
3028                 return LaTeXFeatures::isAvailable("psnfss");
3029         if (font == "cmbr" || font == "cmtl")
3030                 return LaTeXFeatures::isAvailable("cmbright");
3031         if (font == "utopia")
3032                 return LaTeXFeatures::isAvailable("utopia")
3033                         || LaTeXFeatures::isAvailable("fourier");
3034         if (font == "beraserif" || font == "berasans"
3035                 || font == "beramono")
3036                 return LaTeXFeatures::isAvailable("bera");
3037         return LaTeXFeatures::isAvailable(font);
3038 }
3039
3040
3041 bool GuiDocument::providesOSF(string const & font) const
3042 {
3043         if (outputModule->xetexCB->isChecked())
3044                 // FIXME: we should check if the fonts really
3045                 // have OSF support. But how?
3046                 return true;
3047         if (font == "cmr")
3048                 return isFontAvailable("eco");
3049         if (font == "palatino")
3050                 return isFontAvailable("mathpazo");
3051         return false;
3052 }
3053
3054
3055 bool GuiDocument::providesSC(string const & font) const
3056 {
3057         if (outputModule->xetexCB->isChecked())
3058                 return false;
3059         if (font == "palatino")
3060                 return isFontAvailable("mathpazo");
3061         if (font == "utopia")
3062                 return isFontAvailable("fourier");
3063         return false;
3064 }
3065
3066
3067 bool GuiDocument::providesScale(string const & font) const
3068 {
3069         if (outputModule->xetexCB->isChecked())
3070                 return true;
3071         return font == "helvet" || font == "luximono"
3072                 || font == "berasans"  || font == "beramono";
3073 }
3074
3075
3076 void GuiDocument::loadModuleInfo()
3077 {
3078         moduleNames_.clear();
3079         LyXModuleList::const_iterator it  = theModuleList.begin();
3080         LyXModuleList::const_iterator end = theModuleList.end();
3081         for (; it != end; ++it) {
3082                 modInfoStruct m;
3083                 m.id = it->getID();
3084                 // FIXME Unicode
3085                 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
3086                 // this is supposed to give us the first sentence of the description
3087                 // FIXME Unicode
3088                 QString desc =
3089                         toqstr(translateIfPossible(from_utf8(it->getDescription())));
3090                 int const pos = desc.indexOf(".");
3091                 if (pos > 0)
3092                         desc.truncate(pos + 1);
3093                 m.description = desc;
3094                 moduleNames_.push_back(m);
3095         }
3096 }
3097
3098
3099 void GuiDocument::updateUnknownBranches()
3100 {
3101         list<docstring> used_branches;
3102         buffer().getUsedBranches(used_branches);
3103         list<docstring>::const_iterator it = used_branches.begin();
3104         QStringList unknown_branches;
3105         for (; it != used_branches.end() ; ++it) {
3106                 if (!buffer().params().branchlist().find(*it))
3107                         unknown_branches.append(toqstr(*it));
3108         }
3109         branchesModule->setUnknownBranches(unknown_branches);
3110 }
3111
3112
3113 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3114 {
3115         map<docstring, docstring>::iterator it = changedBranches_.begin();
3116         for (; it != changedBranches_.end() ; ++it) {
3117                 if (it->second == oldname) {
3118                         // branch has already been renamed
3119                         it->second = newname;
3120                         return;
3121                 }
3122         }
3123         // store new name
3124         changedBranches_[oldname] = newname;
3125 }
3126
3127
3128 void GuiDocument::executeBranchRenaming() const
3129 {
3130         map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3131         for (; it != changedBranches_.end() ; ++it) {
3132                 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
3133                 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
3134         }
3135 }
3136
3137
3138 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
3139
3140
3141 } // namespace frontend
3142 } // namespace lyx
3143
3144 #include "moc_GuiDocument.cpp"