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