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 "LayoutFile.h"
  17 #include "BranchList.h"
  18 #include "buffer_funcs.h"
  19 #include "Buffer.h"
  20 #include "BufferParams.h"
  21 #include "BufferView.h"
  22 #include "Color.h"
  23 #include "Encoding.h"
  24 #include "FloatPlacement.h"
  25 #include "FuncRequest.h"
  26 #include "support/gettext.h"
  27 #include "GuiBranches.h"
  28 #include "Language.h"
  29 #include "LaTeXFeatures.h"
  30 #include "LaTeXHighlighter.h"
  31 #include "Layout.h"
  32 #include "LengthCombo.h"
  33 #include "LyXRC.h" // defaultUnit
  34 #include "ModuleList.h"
  35 #include "OutputParams.h"
  36 #include "PanelStack.h"
  37 #include "PDFOptions.h"
  38 #include "qt_helpers.h"
  39 #include "Spacing.h"
  40 #include "Validator.h"
  41
  42 #include "insets/InsetListingsParams.h"
  43
  44 #include "support/debug.h"
  45 #include "support/FileName.h"
  46 #include "support/FileFilterList.h"
  47 #include "support/filetools.h"
  48 #include "support/lstrings.h"
  49
  50 #include "frontends/alert.h"
  51
  52 #include <QCloseEvent>
  53 #include <QScrollBar>
  54 #include <QTextCursor>
  55
  56 #include <sstream>
  57
  58 using namespace std;
  59 using namespace lyx::support;
  60
  61
  62 namespace {
  63
  64 char const * const tex_graphics[] =
  65 {
  66         "default", "dvips", "dvitops", "emtex",
  67         "ln", "oztex", "textures", "none", ""
  68 };
  69
  70
  71 char const * const tex_graphics_gui[] =
  72 {
  73         N_("Default"), "Dvips", "DVItoPS", "EmTeX",
  74         "LN", "OzTeX", "Textures", N_("None"), ""
  75 };
  76
  77
  78 char const * const tex_fonts_roman[] =
  79 {
  80         "default", "cmr", "lmodern", "ae", "times", "palatino",
  81         "charter", "newcent", "bookman", "utopia", "beraserif",
  82         "ccfonts", "chancery", ""
  83 };
  84
  85
  86 char const * tex_fonts_roman_gui[] =
  87 {
  88         N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
  89         N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
  90         N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
  91         N_("Utopia"),  N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
  92         ""
  93 };
  94
  95
  96 char const * const tex_fonts_sans[] =
  97 {
  98         "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
  99 };
 100
 101
 102 char const * tex_fonts_sans_gui[] =
 103 {
 104         N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
 105         N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
 106 };
 107
 108
 109 char const * const tex_fonts_monospaced[] =
 110 {
 111         "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
 112 };
 113
 114
 115 char const * tex_fonts_monospaced_gui[] =
 116 {
 117         N_("Default"), N_("Computer Modern Typewriter"),
 118         N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
 119         N_("LuxiMono"), N_("CM Typewriter Light"), ""
 120 };
 121
 122
 123 vector<pair<string, lyx::docstring> > pagestyles;
 124
 125
 126 } // anonymous namespace
 127
 128 namespace lyx {
 129
 130 namespace {
 131 // used when sorting the textclass list.
 132 class less_textclass_avail_desc
 133         : public binary_function<string, string, int>
 134 {
 135 public:
 136         int operator()(string const & lhs, string const & rhs) const
 137         {
 138                 // Ordering criteria:
 139                 //   1. Availability of text class
 140                 //   2. Description (lexicographic)
 141                 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
 142                 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
 143                 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
 144                         (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() &&
 145                          _(tc1.description()) < _(tc2.description()));
 146         }
 147 };
 148
 149 }
 150
 151 namespace frontend {
 152
 153
 154 ///
 155 QModelIndex getSelectedIndex(QListView * lv)
 156 {
 157         QModelIndex retval = QModelIndex();
 158         QModelIndexList selIdx =
 159                         lv->selectionModel()->selectedIndexes();
 160         if (!selIdx.empty())
 161                 retval = selIdx.first();
 162         return retval;
 163 }
 164
 165
 166 namespace {
 167         vector<string> getRequiredList(string const & modName)
 168         {
 169                 LyXModule const * const mod = moduleList[modName];
 170                 if (!mod)
 171                         return vector<string>(); //empty such thing
 172                 return mod->getRequiredModules();
 173         }
 174
 175
 176         vector<string> getExcludedList(string const & modName)
 177         {
 178                 LyXModule const * const mod = moduleList[modName];
 179                 if (!mod)
 180                         return vector<string>(); //empty such thing
 181                 return mod->getExcludedModules();
 182         }
 183
 184
 185         docstring getModuleDescription(string const & modName)
 186         {
 187                 LyXModule const * const mod = moduleList[modName];
 188                 if (!mod)
 189                         return _("Module not found!");
 190                 return _(mod->getDescription());
 191         }
 192
 193
 194         vector<string> getPackageList(string const & modName)
 195         {
 196                 LyXModule const * const mod = moduleList[modName];
 197                 if (!mod)
 198                         return vector<string>(); //empty such thing
 199                 return mod->getPackageList();
 200         }
 201
 202
 203         bool isModuleAvailable(string const & modName)
 204         {
 205                 LyXModule * mod = moduleList[modName];
 206                 if (!mod)
 207                         return false;
 208                 return mod->isAvailable();
 209         }
 210 } //anonymous namespace
 211
 212
 213 ModuleSelMan::ModuleSelMan(
 214         QListView * availableLV,
 215         QListView * selectedLV,
 216         QPushButton * addPB,
 217         QPushButton * delPB,
 218         QPushButton * upPB,
 219         QPushButton * downPB,
 220         GuiIdListModel * availableModel,
 221         GuiIdListModel * selectedModel) :
 222 GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
 223                     upPB, downPB, availableModel, selectedModel)
 224 {}
 225
 226
 227 void ModuleSelMan::updateAddPB()
 228 {
 229         int const arows = availableModel->rowCount();
 230         QModelIndexList const availSels =
 231                         availableLV->selectionModel()->selectedIndexes();
 232         if (arows == 0 || availSels.isEmpty()  || isSelected(availSels.first())) {
 233                 addPB->setEnabled(false);
 234                 return;
 235         }
 236
 237         QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
 238         string const modName = getAvailableModel()->getIDString(idx.row());
 239         vector<string> reqs = getRequiredList(modName);
 240         vector<string> excl = getExcludedList(modName);
 241
 242         if (reqs.empty() && excl.empty()) {
 243                 addPB->setEnabled(true);
 244                 return;
 245         }
 246
 247         int const srows = selectedModel->rowCount();
 248         vector<string> selModList;
 249         for (int i = 0; i < srows; ++i)
 250                 selModList.push_back(getSelectedModel()->getIDString(i));
 251
 252         vector<string>::const_iterator selModStart = selModList.begin();
 253         vector<string>::const_iterator selModEnd   = selModList.end();
 254
 255         //Check whether some required module is available
 256         if (!reqs.empty()) {
 257                 bool foundOne = false;
 258                 vector<string>::const_iterator it  = reqs.begin();
 259                 vector<string>::const_iterator end = reqs.end();
 260                 for (; it != end; ++it) {
 261                         if (find(selModStart, selModEnd, *it) != selModEnd) {
 262                                 foundOne = true;
 263                                 break;
 264                         }
 265                 }
 266                 if (!foundOne) {
 267                         addPB->setEnabled(false);
 268                         return;
 269                 }
 270         }
 271
 272         //Check whether any excluded module is being used
 273         if (!excl.empty()) {
 274                 vector<string>::const_iterator it  = excl.begin();
 275                 vector<string>::const_iterator end = excl.end();
 276                 for (; it != end; ++it) {
 277                         if (find(selModStart, selModEnd, *it) != selModEnd) {
 278                                 addPB->setEnabled(false);
 279                                 return;
 280                         }
 281                 }
 282         }
 283
 284         addPB->setEnabled(true);
 285 }
 286
 287
 288 void ModuleSelMan::updateDownPB()
 289 {
 290         int const srows = selectedModel->rowCount();
 291         if (srows == 0) {
 292                 downPB->setEnabled(false);
 293                 return;
 294         }
 295         QModelIndexList const selSels =
 296                         selectedLV->selectionModel()->selectedIndexes();
 297         //disable if empty or last item is selected
 298         if (selSels.empty() || selSels.first().row() == srows - 1) {
 299                 downPB->setEnabled(false);
 300                 return;
 301         }
 302         //determine whether immediately succeding element requires this one
 303         QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
 304         int curRow = curIdx.row();
 305         if (curRow < 0 || curRow >= srows - 1) { //this shouldn't happen...
 306                 downPB->setEnabled(false);
 307                 return;
 308         }
 309         string const curModName = getSelectedModel()->getIDString(curRow);
 310         string const nextModName = getSelectedModel()->getIDString(curRow + 1);
 311
 312         vector<string> reqs = getRequiredList(nextModName);
 313
 314         //if it doesn't require anything....
 315         if (reqs.empty()) {
 316                 downPB->setEnabled(true);
 317                 return;
 318         }
 319
 320         //FIXME This should perhaps be more flexible and check whether, even
 321         //if this one is required, there is also an earlier one that is required.
 322         //enable it if this module isn't required
 323         downPB->setEnabled(
 324                         find(reqs.begin(), reqs.end(), curModName) == reqs.end());
 325 }
 326
 327 void ModuleSelMan::updateUpPB()
 328 {
 329         int const srows = selectedModel->rowCount();
 330         if (srows == 0) {
 331                 upPB->setEnabled(false);
 332                 return;
 333         }
 334         QModelIndexList const selSels =
 335                         selectedLV->selectionModel()->selectedIndexes();
 336         //disable if empty or first item is selected
 337         if (selSels.empty() || selSels.first().row() == 0) {
 338                 upPB->setEnabled(false);
 339                 return;
 340         }
 341
 342         //determine whether immediately preceding element is required by this one
 343         QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
 344         int curRow = curIdx.row();
 345         if (curRow <= -1 || curRow > srows - 1) { //sanity check
 346                 downPB->setEnabled(false);
 347                 return;
 348         }
 349         string const curModName = getSelectedModel()->getIDString(curRow);
 350         vector<string> reqs = getRequiredList(curModName);
 351
 352         //if this one doesn't require anything....
 353         if (reqs.empty()) {
 354                 upPB->setEnabled(true);
 355                 return;
 356         }
 357
 358         string preModName = getSelectedModel()->getIDString(curRow - 1);
 359
 360         //NOTE This is less flexible than it might be. You could check whether, even
 361         //if this one is required, there is also an earlier one that is required.
 362         //enable it if the preceding module isn't required
 363         upPB->setEnabled(find(reqs.begin(), reqs.end(), preModName) == reqs.end());
 364 }
 365
 366 void ModuleSelMan::updateDelPB()
 367 {
 368         int const srows = selectedModel->rowCount();
 369         if (srows == 0) {
 370                 deletePB->setEnabled(false);
 371                 return;
 372         }
 373         QModelIndexList const selSels =
 374                         selectedLV->selectionModel()->selectedIndexes();
 375         if (selSels.empty() || selSels.first().row() < 0) {
 376                 deletePB->setEnabled(false);
 377                 return;
 378         }
 379
 380         //determine whether some LATER module requires this one
 381         //NOTE Things are arranged so that this is the only way there
 382         //can be a problem. At least, we hope so.
 383         QModelIndex const & curIdx =
 384                 selectedLV->selectionModel()->currentIndex();
 385         int const curRow = curIdx.row();
 386         if (curRow < 0 || curRow >= srows) { //this shouldn't happen
 387                 deletePB->setEnabled(false);
 388                 return;
 389         }
 390
 391         QString const curModName = curIdx.data().toString();
 392
 393         //We're looking here for a reason NOT to enable the button. If we
 394         //find one, we disable it and return. If we don't, we'll end up at
 395         //the end of the function, and then we enable it.
 396         for (int i = curRow + 1; i < srows; ++i) {
 397                 string const thisMod = getSelectedModel()->getIDString(i);
 398                 vector<string> reqs = getRequiredList(thisMod);
 399                 //does this one require us?
 400                 if (find(reqs.begin(), reqs.end(), fromqstr(curModName)) == reqs.end())
 401                         //no...
 402                         continue;
 403
 404                 //OK, so this module requires us
 405                 //is there an EARLIER module that also satisfies the require?
 406                 //NOTE We demand that it be earlier to keep the list of modules
 407                 //consistent with the rule that a module must be proceeded by a
 408                 //required module. There would be more flexible ways to proceed,
 409                 //but that would be a lot more complicated, and the logic here is
 410                 //already complicated. (That's why I've left the debugging code.)
 411                 //lyxerr << "Testing " << thisMod << std::endl;
 412                 bool foundOne = false;
 413                 for (int j = 0; j < curRow; ++j) {
 414                         string const mod = getSelectedModel()->getIDString(j);
 415                         //lyxerr << "In loop: Testing " << mod << std::endl;
 416                         //do we satisfy the require?
 417                         if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
 418                                 //lyxerr << mod << " does the trick." << std::endl;
 419                                 foundOne = true;
 420                                 break;
 421                         }
 422                 }
 423                 //did we find a module to satisfy the require?
 424                 if (!foundOne) {
 425                         //lyxerr << "No matching module found." << std::endl;
 426                         deletePB->setEnabled(false);
 427                         return;
 428                 }
 429         }
 430         //lyxerr << "All's well that ends well." << std::endl;
 431         deletePB->setEnabled(true);
 432 }
 433
 434
 435 /////////////////////////////////////////////////////////////////////
 436 //
 437 // PreambleModule
 438 //
 439 /////////////////////////////////////////////////////////////////////
 440
 441 PreambleModule::PreambleModule(): current_id_(0)
 442 {
 443         // This is not a memory leak. The object will be destroyed
 444         // with this.
 445         (void) new LaTeXHighlighter(preambleTE->document());
 446         setFocusProxy(preambleTE);
 447         connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
 448 }
 449
 450
 451 void PreambleModule::update(BufferParams const & params, BufferId id)
 452 {
 453         QString preamble = toqstr(params.preamble);
 454         // Nothing to do if the params and preamble are unchanged.
 455         if (id == current_id_
 456                 && preamble == preambleTE->document()->toPlainText())
 457                 return;
 458
 459         QTextCursor cur = preambleTE->textCursor();
 460         // Save the coords before switching to the new one.
 461         preamble_coords_[current_id_] =
 462                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 463
 464         // Save the params address for further use.
 465         current_id_ = id;
 466         preambleTE->document()->setPlainText(preamble);
 467         Coords::const_iterator it = preamble_coords_.find(current_id_);
 468         if (it == preamble_coords_.end())
 469                 // First time we open this one.
 470                 preamble_coords_[current_id_] = make_pair(0,0);
 471         else {
 472                 // Restore saved coords.
 473                 QTextCursor cur = preambleTE->textCursor();
 474                 cur.setPosition(it->second.first);
 475                 preambleTE->setTextCursor(cur);
 476                 preambleTE->verticalScrollBar()->setValue(it->second.second);
 477         }
 478 }
 479
 480
 481 void PreambleModule::apply(BufferParams & params)
 482 {
 483         params.preamble = fromqstr(preambleTE->document()->toPlainText());
 484 }
 485
 486
 487 void PreambleModule::closeEvent(QCloseEvent * e)
 488 {
 489         // Save the coords before closing.
 490         QTextCursor cur = preambleTE->textCursor();
 491         preamble_coords_[current_id_] =
 492                 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
 493         e->accept();
 494 }
 495
 496
 497 /////////////////////////////////////////////////////////////////////
 498 //
 499 // DocumentDialog
 500 //
 501 /////////////////////////////////////////////////////////////////////
 502
 503
 504 GuiDocument::GuiDocument(GuiView & lv)
 505         : GuiDialog(lv, "document", qt_("Document Settings")), current_id_(0)
 506 {
 507         setupUi(this);
 508
 509         QList<LanguagePair> langs = languageData(false);
 510         for (int i = 0; i != langs.size(); ++i)
 511                 lang_.append(langs[i].second);
 512
 513         connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
 514         connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
 515         connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
 516         connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
 517
 518         connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
 519         connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
 520
 521         // Manage the restore, ok, apply, restore and cancel/close buttons
 522         bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
 523         bc().setOK(okPB);
 524         bc().setApply(applyPB);
 525         bc().setCancel(closePB);
 526         bc().setRestore(restorePB);
 527
 528         textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
 529         // text layout
 530         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 531                 this, SLOT(change_adaptor()));
 532         connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
 533                 this, SLOT(setLSpacing(int)));
 534         connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
 535                 this, SLOT(change_adaptor()));
 536         connect(textLayoutModule->skipRB, SIGNAL(clicked()),
 537                 this, SLOT(change_adaptor()));
 538         connect(textLayoutModule->indentRB, SIGNAL(clicked()),
 539                 this, SLOT(change_adaptor()));
 540         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 541                 this, SLOT(change_adaptor()));
 542         connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
 543                 this, SLOT(change_adaptor()));
 544         connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
 545                 this, SLOT(change_adaptor()));
 546         connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
 547                 this, SLOT(setSkip(int)));
 548         connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
 549                 this, SLOT(enableSkip(bool)));
 550         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 551                 this, SLOT(change_adaptor()));
 552         connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
 553                 this, SLOT(setColSep()));
 554         connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
 555                 this, SLOT(change_adaptor()));
 556         connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
 557                 this, SLOT(change_adaptor()));
 558         connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
 559                 this, SLOT(set_listings_msg()));
 560         connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
 561                 this, SLOT(set_listings_msg()));
 562         textLayoutModule->listingsTB->setPlainText(
 563                 qt_("Input listings parameters on the right. Enter ? for a list of parameters."));
 564         textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
 565                 textLayoutModule->lspacingLE));
 566         textLayoutModule->skipLE->setValidator(unsignedLengthValidator(
 567                 textLayoutModule->skipLE));
 568
 569         textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
 570         textLayoutModule->skipCO->addItem(qt_("MedSkip"));
 571         textLayoutModule->skipCO->addItem(qt_("BigSkip"));
 572         textLayoutModule->skipCO->addItem(qt_("Length"));
 573         // remove the %-items from the unit choice
 574         textLayoutModule->skipLengthCO->noPercents();
 575         textLayoutModule->lspacingCO->insertItem(
 576                 Spacing::Single, qt_("Single"));
 577         textLayoutModule->lspacingCO->insertItem(
 578                 Spacing::Onehalf, qt_("OneHalf"));
 579         textLayoutModule->lspacingCO->insertItem(
 580                 Spacing::Double, qt_("Double"));
 581         textLayoutModule->lspacingCO->insertItem(
 582                 Spacing::Other, qt_("Custom"));
 583
 584         // initialize the length validator
 585         bc().addCheckedLineEdit(textLayoutModule->skipLE);
 586
 587         fontModule = new UiWidget<Ui::FontUi>;
 588         // fonts
 589         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 590                 this, SLOT(change_adaptor()));
 591         connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
 592                 this, SLOT(romanChanged(int)));
 593         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 594                 this, SLOT(change_adaptor()));
 595         connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
 596                 this, SLOT(sansChanged(int)));
 597         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 598                 this, SLOT(change_adaptor()));
 599         connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
 600                 this, SLOT(ttChanged(int)));
 601         connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
 602                 this, SLOT(change_adaptor()));
 603         connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
 604                 this, SLOT(change_adaptor()));
 605         connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
 606                 this, SLOT(change_adaptor()));
 607         connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
 608                 this, SLOT(change_adaptor()));
 609         connect(fontModule->fontScCB, SIGNAL(clicked()),
 610                 this, SLOT(change_adaptor()));
 611         connect(fontModule->fontOsfCB, SIGNAL(clicked()),
 612                 this, SLOT(change_adaptor()));
 613
 614         for (int n = 0; tex_fonts_roman[n][0]; ++n) {
 615                 QString font = qt_(tex_fonts_roman_gui[n]);
 616                 if (!isFontAvailable(tex_fonts_roman[n]))
 617                         font += qt_(" (not installed)");
 618                 fontModule->fontsRomanCO->addItem(font);
 619         }
 620         for (int n = 0; tex_fonts_sans[n][0]; ++n) {
 621                 QString font = qt_(tex_fonts_sans_gui[n]);
 622                 if (!isFontAvailable(tex_fonts_sans[n]))
 623                         font += qt_(" (not installed)");
 624                 fontModule->fontsSansCO->addItem(font);
 625         }
 626         for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
 627                 QString font = qt_(tex_fonts_monospaced_gui[n]);
 628                 if (!isFontAvailable(tex_fonts_monospaced[n]))
 629                         font += qt_(" (not installed)");
 630                 fontModule->fontsTypewriterCO->addItem(font);
 631         }
 632
 633         fontModule->fontsizeCO->addItem(qt_("Default"));
 634         fontModule->fontsizeCO->addItem(qt_("10"));
 635         fontModule->fontsizeCO->addItem(qt_("11"));
 636         fontModule->fontsizeCO->addItem(qt_("12"));
 637
 638         for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
 639                 fontModule->fontsDefaultCO->addItem(
 640                         qt_(GuiDocument::fontfamilies_gui[n]));
 641
 642
 643         pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
 644         // page layout
 645         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 646                 this, SLOT(setCustomPapersize(int)));
 647         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 648                 this, SLOT(setCustomPapersize(int)));
 649         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 650                 this, SLOT(portraitChanged()));
 651         connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
 652                 this, SLOT(change_adaptor()));
 653         connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
 654                 this, SLOT(change_adaptor()));
 655         connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
 656                 this, SLOT(change_adaptor()));
 657         connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
 658                 this, SLOT(change_adaptor()));
 659         connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
 660                 this, SLOT(change_adaptor()));
 661         connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
 662                 this, SLOT(change_adaptor()));
 663         connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
 664                 this, SLOT(change_adaptor()));
 665         connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
 666                 this, SLOT(change_adaptor()));
 667         connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
 668                 this, SLOT(change_adaptor()));
 669
 670         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
 671         pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
 672         pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
 673         pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
 674         pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
 675         bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
 676                 pageLayoutModule->paperheightL);
 677         bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
 678                 pageLayoutModule->paperwidthL);
 679
 680         // paper
 681         QComboBox * cb = pageLayoutModule->papersizeCO;
 682         cb->addItem(qt_("Default"));
 683         cb->addItem(qt_("Custom"));
 684         cb->addItem(qt_("US letter"));
 685         cb->addItem(qt_("US legal"));
 686         cb->addItem(qt_("US executive"));
 687         cb->addItem(qt_("A3"));
 688         cb->addItem(qt_("A4"));
 689         cb->addItem(qt_("A5"));
 690         cb->addItem(qt_("B3"));
 691         cb->addItem(qt_("B4"));
 692         cb->addItem(qt_("B5"));
 693         // remove the %-items from the unit choice
 694         pageLayoutModule->paperwidthUnitCO->noPercents();
 695         pageLayoutModule->paperheightUnitCO->noPercents();
 696         pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
 697                 pageLayoutModule->paperheightLE));
 698         pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
 699                 pageLayoutModule->paperwidthLE));
 700
 701
 702         marginsModule = new UiWidget<Ui::MarginsUi>;
 703         // margins
 704         connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
 705                 this, SLOT(setCustomMargins(bool)));
 706         connect(marginsModule->marginCB, SIGNAL(clicked()),
 707                 this, SLOT(change_adaptor()));
 708         connect(marginsModule->topLE, SIGNAL(textChanged(const QString &)),
 709                 this, SLOT(change_adaptor()));
 710         connect(marginsModule->topUnit, SIGNAL(activated(int)),
 711                 this, SLOT(change_adaptor()));
 712         connect(marginsModule->bottomLE, SIGNAL(textChanged(const QString &)),
 713                 this, SLOT(change_adaptor()));
 714         connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
 715                 this, SLOT(change_adaptor()));
 716         connect(marginsModule->innerLE, SIGNAL(textChanged(const QString &)),
 717                 this, SLOT(change_adaptor()));
 718         connect(marginsModule->innerUnit, SIGNAL(activated(int)),
 719                 this, SLOT(change_adaptor()));
 720         connect(marginsModule->outerLE, SIGNAL(textChanged(const QString &)),
 721                 this, SLOT(change_adaptor()));
 722         connect(marginsModule->outerUnit, SIGNAL(activated(int)),
 723                 this, SLOT(change_adaptor()));
 724         connect(marginsModule->headheightLE, SIGNAL(textChanged(const QString &)),
 725                 this, SLOT(change_adaptor()));
 726         connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
 727                 this, SLOT(change_adaptor()));
 728         connect(marginsModule->headsepLE, SIGNAL(textChanged(const QString &)),
 729                 this, SLOT(change_adaptor()));
 730         connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
 731                 this, SLOT(change_adaptor()));
 732         connect(marginsModule->footskipLE, SIGNAL(textChanged(const QString&)),
 733                 this, SLOT(change_adaptor()));
 734         connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
 735                 this, SLOT(change_adaptor()));
 736         connect(marginsModule->columnsepLE, SIGNAL(textChanged(const QString&)),
 737                 this, SLOT(change_adaptor()));
 738         connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
 739                 this, SLOT(change_adaptor()));
 740         marginsModule->topLE->setValidator(unsignedLengthValidator(
 741                 marginsModule->topLE));
 742         marginsModule->bottomLE->setValidator(unsignedLengthValidator(
 743                 marginsModule->bottomLE));
 744         marginsModule->innerLE->setValidator(unsignedLengthValidator(
 745                 marginsModule->innerLE));
 746         marginsModule->outerLE->setValidator(unsignedLengthValidator(
 747                 marginsModule->outerLE));
 748         marginsModule->headsepLE->setValidator(unsignedLengthValidator(
 749                 marginsModule->headsepLE));
 750         marginsModule->headheightLE->setValidator(unsignedLengthValidator(
 751                 marginsModule->headheightLE));
 752         marginsModule->footskipLE->setValidator(unsignedLengthValidator(
 753                 marginsModule->footskipLE));
 754         marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
 755                 marginsModule->columnsepLE));
 756
 757         bc().addCheckedLineEdit(marginsModule->topLE,
 758                 marginsModule->topL);
 759         bc().addCheckedLineEdit(marginsModule->bottomLE,
 760                 marginsModule->bottomL);
 761         bc().addCheckedLineEdit(marginsModule->innerLE,
 762                 marginsModule->innerL);
 763         bc().addCheckedLineEdit(marginsModule->outerLE,
 764                 marginsModule->outerL);
 765         bc().addCheckedLineEdit(marginsModule->headsepLE,
 766                 marginsModule->headsepL);
 767         bc().addCheckedLineEdit(marginsModule->headheightLE,
 768                 marginsModule->headheightL);
 769         bc().addCheckedLineEdit(marginsModule->footskipLE,
 770                 marginsModule->footskipL);
 771         bc().addCheckedLineEdit(marginsModule->columnsepLE,
 772                 marginsModule->columnsepL);
 773
 774
 775         langModule = new UiWidget<Ui::LanguageUi>;
 776         // language & quote
 777         connect(langModule->languageCO, SIGNAL(activated(int)),
 778                 this, SLOT(change_adaptor()));
 779         connect(langModule->defaultencodingRB, SIGNAL(clicked()),
 780                 this, SLOT(change_adaptor()));
 781         connect(langModule->otherencodingRB, SIGNAL(clicked()),
 782                 this, SLOT(change_adaptor()));
 783         connect(langModule->encodingCO, SIGNAL(activated(int)),
 784                 this, SLOT(change_adaptor()));
 785         connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
 786                 this, SLOT(change_adaptor()));
 787         // language & quotes
 788
 789         QList<LanguagePair>::const_iterator lit  = langs.begin();
 790         QList<LanguagePair>::const_iterator lend = langs.end();
 791         for (; lit != lend; ++lit)
 792                 langModule->languageCO->addItem(lit->first);
 793
 794         // Always put the default encoding in the first position.
 795         // It is special because the displayed text is translated.
 796         langModule->encodingCO->addItem(qt_("LaTeX default"));
 797         Encodings::const_iterator it = encodings.begin();
 798         Encodings::const_iterator const end = encodings.end();
 799         for (; it != end; ++it)
 800                 langModule->encodingCO->addItem(toqstr(it->latexName()));
 801
 802         langModule->quoteStyleCO->addItem(qt_("``text''"));
 803         langModule->quoteStyleCO->addItem(qt_("''text''"));
 804         langModule->quoteStyleCO->addItem(qt_(",,text``"));
 805         langModule->quoteStyleCO->addItem(qt_(",,text''"));
 806         langModule->quoteStyleCO->addItem(qt_("<<text>>"));
 807         langModule->quoteStyleCO->addItem(qt_(">>text<<"));
 808
 809
 810         numberingModule = new UiWidget<Ui::NumberingUi>;
 811         // numbering
 812         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
 813                 this, SLOT(change_adaptor()));
 814         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
 815                 this, SLOT(change_adaptor()));
 816         connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
 817                 this, SLOT(updateNumbering()));
 818         connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
 819                 this, SLOT(updateNumbering()));
 820         numberingModule->tocTW->setColumnCount(3);
 821         numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
 822         numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
 823         numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
 824
 825
 826         biblioModule = new UiWidget<Ui::BiblioUi>;
 827         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
 828                 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
 829         connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
 830                 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
 831         // biblio
 832         connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
 833                 this, SLOT(change_adaptor()));
 834         connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
 835                 this, SLOT(change_adaptor()));
 836         connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
 837                 this, SLOT(change_adaptor()));
 838         connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
 839                 this, SLOT(change_adaptor()));
 840         connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
 841                 this, SLOT(change_adaptor()));
 842         // biblio
 843         biblioModule->citeStyleCO->addItem(qt_("Author-year"));
 844         biblioModule->citeStyleCO->addItem(qt_("Numerical"));
 845         biblioModule->citeStyleCO->setCurrentIndex(0);
 846
 847
 848         mathsModule = new UiWidget<Ui::MathsUi>;
 849         connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
 850                 mathsModule->amsCB, SLOT(setDisabled(bool)));
 851         connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
 852                 mathsModule->esintCB, SLOT(setDisabled(bool)));
 853         // maths
 854         connect(mathsModule->amsCB, SIGNAL(clicked()),
 855                 this, SLOT(change_adaptor()));
 856         connect(mathsModule->amsautoCB, SIGNAL(clicked()),
 857                 this, SLOT(change_adaptor()));
 858         connect(mathsModule->esintCB, SIGNAL(clicked()),
 859                 this, SLOT(change_adaptor()));
 860         connect(mathsModule->esintautoCB, SIGNAL(clicked()),
 861                 this, SLOT(change_adaptor()));
 862
 863         latexModule = new UiWidget<Ui::LaTeXUi>;
 864         // latex class
 865         connect(latexModule->optionsLE, SIGNAL(textChanged(const QString &)),
 866                 this, SLOT(change_adaptor()));
 867         connect(latexModule->psdriverCO, SIGNAL(activated(int)),
 868                 this, SLOT(change_adaptor()));
 869         connect(latexModule->classCO, SIGNAL(activated(int)),
 870                 this, SLOT(classChanged()));
 871         connect(latexModule->classCO, SIGNAL(activated(int)),
 872                 this, SLOT(change_adaptor()));
 873         connect(latexModule->layoutPB, SIGNAL(clicked()),
 874                 this, SLOT(browseLayout()));
 875
 876         selectionManager =
 877                 new ModuleSelMan(latexModule->availableLV, latexModule->selectedLV,
 878                         latexModule->addPB, latexModule->deletePB,
 879                         latexModule->upPB, latexModule->downPB,
 880                         availableModel(), selectedModel());
 881         connect(selectionManager, SIGNAL(updateHook()),
 882                 this, SLOT(updateModuleInfo()));
 883         connect(selectionManager, SIGNAL(updateHook()),
 884                 this, SLOT(change_adaptor()));
 885
 886         // postscript drivers
 887         for (int n = 0; tex_graphics[n][0]; ++n) {
 888                 QString enc = qt_(tex_graphics_gui[n]);
 889                 latexModule->psdriverCO->addItem(enc);
 890         }
 891         // latex classes
 892         latexModule->classCO->setModel(&classes_model_);
 893         LayoutFileList const & bcl = LayoutFileList::get();
 894         vector<LayoutFileIndex> classList = bcl.classList();
 895         sort(classList.begin(), classList.end(), less_textclass_avail_desc());
 896
 897         vector<LayoutFileIndex>::const_iterator cit  = classList.begin();
 898         vector<LayoutFileIndex>::const_iterator cen = classList.end();
 899         for (int i = 0; cit != cen; ++cit, ++i) {
 900                 LayoutFile const & tc = bcl[*cit];
 901                 docstring item = (tc.isTeXClassAvailable()) ?
 902                         from_utf8(tc.description()) :
 903                         bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
 904                 classes_model_.insertRow(i, toqstr(item), *cit);
 905         }
 906
 907         // branches
 908         branchesModule = new GuiBranches;
 909         connect(branchesModule, SIGNAL(changed()),
 910                 this, SLOT(change_adaptor()));
 911
 912         // preamble
 913         preambleModule = new PreambleModule;
 914         connect(preambleModule, SIGNAL(changed()),
 915                 this, SLOT(change_adaptor()));
 916
 917         // bullets
 918         bulletsModule = new BulletsModule;
 919         connect(bulletsModule, SIGNAL(changed()),
 920                 this, SLOT(change_adaptor()));
 921
 922         // embedded files
 923         embeddedFilesModule = new UiWidget<Ui::EmbeddedFilesUi>;
 924         connect(embeddedFilesModule->addPB, SIGNAL(clicked()),
 925                 this, SLOT(addExtraEmbeddedFile()));
 926         connect(embeddedFilesModule->removePB, SIGNAL(clicked()),
 927                 this, SLOT(removeExtraEmbeddedFile()));
 928
 929         // PDF support
 930         pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
 931
 932         connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
 933                 this, SLOT(change_adaptor()));
 934         connect(pdfSupportModule->titleLE, SIGNAL(textChanged(const QString &)),
 935                 this, SLOT(change_adaptor()));
 936         connect(pdfSupportModule->authorLE, SIGNAL(textChanged(const QString &)),
 937                 this, SLOT(change_adaptor()));
 938         connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(const QString &)),
 939                 this, SLOT(change_adaptor()));
 940         connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(const QString &)),
 941                 this, SLOT(change_adaptor()));
 942         connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
 943                 this, SLOT(change_adaptor()));
 944         connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
 945                 this, SLOT(change_adaptor()));
 946         connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
 947                 this, SLOT(change_adaptor()));
 948         connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
 949                 this, SLOT(change_adaptor()));
 950         connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
 951                 this, SLOT(change_adaptor()));
 952         connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
 953                 this, SLOT(change_adaptor()));
 954         connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
 955                 this, SLOT(change_adaptor()));
 956         connect(pdfSupportModule->backrefCB, SIGNAL(toggled(bool)),
 957                 this, SLOT(change_adaptor()));
 958         connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
 959                 this, SLOT(change_adaptor()));
 960         connect(pdfSupportModule->pagebackrefCB, SIGNAL(toggled(bool)),
 961                 this, SLOT(change_adaptor()));
 962         connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
 963                 this, SLOT(change_adaptor()));
 964         connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(const QString &)),
 965                 this, SLOT(change_adaptor()));
 966
 967         // float
 968         floatModule = new FloatPlacement;
 969         connect(floatModule, SIGNAL(changed()),
 970                 this, SLOT(change_adaptor()));
 971
 972         docPS->addPanel(latexModule, qt_("Document Class"));
 973         docPS->addPanel(fontModule, qt_("Fonts"));
 974         docPS->addPanel(textLayoutModule, qt_("Text Layout"));
 975         docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
 976         docPS->addPanel(marginsModule, qt_("Page Margins"));
 977         docPS->addPanel(langModule, qt_("Language"));
 978         docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
 979         docPS->addPanel(biblioModule, qt_("Bibliography"));
 980         docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
 981         docPS->addPanel(mathsModule, qt_("Math Options"));
 982         docPS->addPanel(floatModule, qt_("Float Placement"));
 983         docPS->addPanel(bulletsModule, qt_("Bullets"));
 984         docPS->addPanel(branchesModule, qt_("Branches"));
 985         docPS->addPanel(embeddedFilesModule, qt_("Embedded Files"));
 986         docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
 987         docPS->setCurrentPanel(qt_("Document Class"));
 988 // FIXME: hack to work around resizing bug in Qt >= 4.2
 989 // bug verified with Qt 4.2.{0-3} (JSpitzm)
 990 #if QT_VERSION >= 0x040200
 991         docPS->updateGeometry();
 992 #endif
 993 }
 994
 995
 996 void GuiDocument::showPreamble()
 997 {
 998         docPS->setCurrentPanel(qt_("LaTeX Preamble"));
 999 }
1000
1001
1002 void GuiDocument::saveDefaultClicked()
1003 {
1004         saveDocDefault();
1005 }
1006
1007
1008 void GuiDocument::useDefaultsClicked()
1009 {
1010         useClassDefaults();
1011 }
1012
1013
1014 void GuiDocument::change_adaptor()
1015 {
1016         changed();
1017 }
1018
1019
1020 docstring GuiDocument::validate_listings_params()
1021 {
1022         // use a cache here to avoid repeated validation
1023         // of the same parameters
1024         static string param_cache = string();
1025         static docstring msg_cache = docstring();
1026
1027         if (textLayoutModule->bypassCB->isChecked())
1028                 return docstring();
1029
1030         string params = fromqstr(textLayoutModule->listingsED->toPlainText());
1031         if (params != param_cache) {
1032                 param_cache = params;
1033                 msg_cache = InsetListingsParams(params).validate();
1034         }
1035         return msg_cache;
1036 }
1037
1038
1039 void GuiDocument::set_listings_msg()
1040 {
1041         static bool isOK = true;
1042         docstring msg = validate_listings_params();
1043         if (msg.empty()) {
1044                 if (isOK)
1045                         return;
1046                 isOK = true;
1047                 // listingsTB->setTextColor("black");
1048                 textLayoutModule->listingsTB->setPlainText(
1049                         qt_("Input listings parameters on the right. Enter ? for a list of parameters."));
1050         } else {
1051                 isOK = false;
1052                 // listingsTB->setTextColor("red");
1053                 textLayoutModule->listingsTB->setPlainText(toqstr(msg));
1054         }
1055 }
1056
1057
1058 void GuiDocument::setLSpacing(int item)
1059 {
1060         textLayoutModule->lspacingLE->setEnabled(item == 3);
1061 }
1062
1063
1064 void GuiDocument::setSkip(int item)
1065 {
1066         bool const enable = (item == 3);
1067         textLayoutModule->skipLE->setEnabled(enable);
1068         textLayoutModule->skipLengthCO->setEnabled(enable);
1069 }
1070
1071
1072 void GuiDocument::enableSkip(bool skip)
1073 {
1074         textLayoutModule->skipCO->setEnabled(skip);
1075         textLayoutModule->skipLE->setEnabled(skip);
1076         textLayoutModule->skipLengthCO->setEnabled(skip);
1077         if (skip)
1078                 setSkip(textLayoutModule->skipCO->currentIndex());
1079 }
1080
1081 void GuiDocument::portraitChanged()
1082 {
1083         setMargins(pageLayoutModule->papersizeCO->currentIndex());
1084 }
1085
1086 void GuiDocument::setMargins(bool custom)
1087 {
1088         marginsModule->marginCB->setChecked(custom);
1089         setCustomMargins(custom);
1090 }
1091
1092
1093 void GuiDocument::setCustomPapersize(int papersize)
1094 {
1095         bool const custom = (papersize == 1);
1096
1097         pageLayoutModule->paperwidthL->setEnabled(custom);
1098         pageLayoutModule->paperwidthLE->setEnabled(custom);
1099         pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1100         pageLayoutModule->paperheightL->setEnabled(custom);
1101         pageLayoutModule->paperheightLE->setEnabled(custom);
1102         pageLayoutModule->paperheightLE->setFocus();
1103         pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1104 }
1105
1106
1107 void GuiDocument::setColSep()
1108 {
1109         setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1110 }
1111
1112
1113 void GuiDocument::setCustomMargins(bool custom)
1114 {
1115         marginsModule->topL->setEnabled(!custom);
1116         marginsModule->topLE->setEnabled(!custom);
1117         marginsModule->topUnit->setEnabled(!custom);
1118
1119         marginsModule->bottomL->setEnabled(!custom);
1120         marginsModule->bottomLE->setEnabled(!custom);
1121         marginsModule->bottomUnit->setEnabled(!custom);
1122
1123         marginsModule->innerL->setEnabled(!custom);
1124         marginsModule->innerLE->setEnabled(!custom);
1125         marginsModule->innerUnit->setEnabled(!custom);
1126
1127         marginsModule->outerL->setEnabled(!custom);
1128         marginsModule->outerLE->setEnabled(!custom);
1129         marginsModule->outerUnit->setEnabled(!custom);
1130
1131         marginsModule->headheightL->setEnabled(!custom);
1132         marginsModule->headheightLE->setEnabled(!custom);
1133         marginsModule->headheightUnit->setEnabled(!custom);
1134
1135         marginsModule->headsepL->setEnabled(!custom);
1136         marginsModule->headsepLE->setEnabled(!custom);
1137         marginsModule->headsepUnit->setEnabled(!custom);
1138
1139         marginsModule->footskipL->setEnabled(!custom);
1140         marginsModule->footskipLE->setEnabled(!custom);
1141         marginsModule->footskipUnit->setEnabled(!custom);
1142
1143         bool const enableColSep = !custom &&
1144                         textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1145         marginsModule->columnsepL->setEnabled(enableColSep);
1146         marginsModule->columnsepLE->setEnabled(enableColSep);
1147         marginsModule->columnsepUnit->setEnabled(enableColSep);
1148 }
1149
1150
1151 void GuiDocument::updateFontsize(string const & items, string const & sel)
1152 {
1153         fontModule->fontsizeCO->clear();
1154         fontModule->fontsizeCO->addItem(qt_("Default"));
1155
1156         for (int n = 0; !token(items,'|',n).empty(); ++n)
1157                 fontModule->fontsizeCO->
1158                         addItem(toqstr(token(items,'|',n)));
1159
1160         for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1161                 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1162                         fontModule->fontsizeCO->setCurrentIndex(n);
1163                         break;
1164                 }
1165         }
1166 }
1167
1168
1169 void GuiDocument::romanChanged(int item)
1170 {
1171         string const font = tex_fonts_roman[item];
1172         fontModule->fontScCB->setEnabled(providesSC(font));
1173         fontModule->fontOsfCB->setEnabled(providesOSF(font));
1174 }
1175
1176
1177 void GuiDocument::sansChanged(int item)
1178 {
1179         string const font = tex_fonts_sans[item];
1180         bool scaleable = providesScale(font);
1181         fontModule->scaleSansSB->setEnabled(scaleable);
1182         fontModule->scaleSansLA->setEnabled(scaleable);
1183 }
1184
1185
1186 void GuiDocument::ttChanged(int item)
1187 {
1188         string const font = tex_fonts_monospaced[item];
1189         bool scaleable = providesScale(font);
1190         fontModule->scaleTypewriterSB->setEnabled(scaleable);
1191         fontModule->scaleTypewriterLA->setEnabled(scaleable);
1192 }
1193
1194
1195 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1196 {
1197         pagestyles.clear();
1198         pageLayoutModule->pagestyleCO->clear();
1199         pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1200
1201         for (int n = 0; !token(items,'|',n).empty(); ++n) {
1202                 string style = token(items, '|', n);
1203                 docstring style_gui = _(style);
1204                 pagestyles.push_back(pair<string, docstring>(style, style_gui));
1205                 pageLayoutModule->pagestyleCO->addItem(toqstr(style_gui));
1206         }
1207
1208         if (sel == "default") {
1209                 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1210                 return;
1211         }
1212
1213         int nn = 0;
1214
1215         for (size_t i = 0; i < pagestyles.size(); ++i)
1216                 if (pagestyles[i].first == sel)
1217                         nn = pageLayoutModule->pagestyleCO->findText(
1218                                         toqstr(pagestyles[i].second));
1219
1220         if (nn > 0)
1221                 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1222 }
1223
1224
1225 void GuiDocument::browseLayout()
1226 {
1227         QString const label1 = qt_("Layouts|#o#O");
1228         QString const dir1 = toqstr(lyxrc.document_path);
1229         FileFilterList const filter(_("LyX Layout (*.layout)"));
1230         QString file = browseRelFile(QString(), bufferFilepath(),
1231                 qt_("Local layout file"), filter, false,
1232                 label1, dir1);
1233
1234         if (!suffixIs(fromqstr(file), ".layout"))
1235                 return;
1236
1237         FileName layoutFile = makeAbsPath(fromqstr(file),
1238                 fromqstr(bufferFilepath()));
1239
1240         // load the layout file
1241         LayoutFileList & bcl = LayoutFileList::get();
1242         string classname = layoutFile.onlyFileName();
1243         LayoutFileIndex name = bcl.addLayoutFile(
1244                 classname.substr(0, classname.size() - 7),
1245                 layoutFile.onlyPath().absFilename());
1246
1247         if (name.empty()) {
1248                 Alert::error(_("Error"),
1249                         _("Unable to read local layout file."));
1250                 return;
1251         }
1252
1253         // do not trigger classChanged if there is no change.
1254         if (latexModule->classCO->currentText() == toqstr(name))
1255                 return;
1256
1257         // add to combo box
1258         int idx = latexModule->classCO->findText(toqstr(name));
1259         if (idx == -1) {
1260                 classes_model_.insertRow(0, toqstr(name), name);
1261                 latexModule->classCO->setCurrentIndex(0);
1262         } else
1263                 latexModule->classCO->setCurrentIndex(idx);
1264         classChanged();
1265 }
1266
1267
1268 void GuiDocument::classChanged()
1269 {
1270         int idx = latexModule->classCO->currentIndex();
1271         if (idx < 0)
1272                 return;
1273         string const classname = classes_model_.getIDString(idx);
1274         // check if this is a local layout file
1275         if (prefixIs(classname, LayoutFileList::localPrefix)) {
1276                 int const ret = Alert::prompt(_("Local layout file"),
1277                                 _("The layout file you have selected is a local layout\n"
1278                                   "file, not one in the system or user directory. Your\n"
1279                                   "document may not work with this layout if you do not\n"
1280                                   "keep the layout file in the same directory."),
1281                                   1, 1, _("&Set Layout"), _("&Cancel"));
1282                 if (ret == 1) {
1283                         // try to reset the layout combo
1284                         setLayoutComboByIDString(bp_.baseClassID());
1285                         return;
1286                 }
1287         }
1288         if (!bp_.setBaseClass(classname)) {
1289                 Alert::error(_("Error"), _("Unable to set document class."));
1290                 return;
1291         }
1292         if (lyxrc.auto_reset_options) {
1293                 if (applyPB->isEnabled()) {
1294                         int const ret = Alert::prompt(_("Unapplied changes"),
1295                                         _("Some changes in the dialog were not yet applied.\n"
1296                                         "If you do not apply now, they will be lost after this action."),
1297                                         1, 1, _("&Apply"), _("&Dismiss"));
1298                         if (ret == 0)
1299                                 applyView();
1300                 }
1301                 bp_.useClassDefaults();
1302                 forceUpdate();
1303         }
1304 }
1305
1306
1307 namespace {
1308         // This is an insanely complicated attempt to make this sort of thing
1309         // work with RTL languages.
1310         docstring formatStrVec(vector<string> const & v, docstring const & s)
1311         {
1312                 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1313                 int const vSize = v.size();
1314                 if (v.size() == 0)
1315                         return docstring();
1316                 else if (v.size() == 1)
1317                         return from_ascii(v[0]);
1318                 else if (v.size() == 2) {
1319                         docstring retval = _("%1$s and %2$s");
1320                         retval = subst(retval, _("and"), s);
1321                         return bformat(retval, from_ascii(v[0]), from_ascii(v[1]));
1322                 }
1323                 //The idea here is to format all but the last two items...
1324                 docstring t2 = _("%1$s, %2$s");
1325                 docstring retval = from_ascii(v[0]);
1326                 for (int i = 1; i < vSize - 2; ++i)
1327                         retval = bformat(t2, retval, from_ascii(v[i]));
1328                 //...and then to  plug them, and the last two, into this schema
1329                 docstring t = _("%1$s, %2$s, and %3$s");
1330                 t = subst(t, _("and"), s);
1331                 return bformat(t, retval, from_ascii(v[vSize - 2]), from_ascii(v[vSize - 1]));
1332         }
1333
1334         vector<string> idsToNames(vector<string> const & idList)
1335         {
1336                 vector<string> retval;
1337                 vector<string>::const_iterator it  = idList.begin();
1338                 vector<string>::const_iterator end = idList.end();
1339                 for (; it != end; ++it) {
1340                         LyXModule const * const mod = moduleList[*it];
1341                         if (!mod)
1342                                 retval.push_back(*it + " (Unavailable)");
1343                         else
1344                                 retval.push_back(mod->getName());
1345                 }
1346                 return retval;
1347         }
1348 }
1349
1350
1351 void GuiDocument::updateModuleInfo()
1352 {
1353         selectionManager->update();
1354
1355         //Module description
1356         bool const focusOnSelected = selectionManager->selectedFocused();
1357         QListView const * const lv =
1358                         focusOnSelected ? latexModule->selectedLV : latexModule->availableLV;
1359         if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1360                 latexModule->infoML->document()->clear();
1361                 return;
1362         }
1363         QModelIndex const & idx = lv->selectionModel()->currentIndex();
1364         GuiIdListModel const & idModel =
1365                         focusOnSelected  ? modules_sel_model_ : modules_av_model_;
1366         string const modName = idModel.getIDString(idx.row());
1367         docstring desc = getModuleDescription(modName);
1368
1369         vector<string> pkgList = getPackageList(modName);
1370         docstring pkgdesc = formatStrVec(pkgList, _("and"));
1371         if (!pkgdesc.empty()) {
1372                 if (!desc.empty())
1373                         desc += "\n";
1374                 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1375         }
1376
1377         pkgList = getRequiredList(modName);
1378         if (!pkgList.empty()) {
1379                 vector<string> const reqDescs = idsToNames(pkgList);
1380                 pkgdesc = formatStrVec(reqDescs, _("or"));
1381                 if (!desc.empty())
1382                         desc += "\n";
1383                 desc += bformat(_("Module required: %1$s."), pkgdesc);
1384         }
1385
1386         pkgList = getExcludedList(modName);
1387         if (!pkgList.empty()) {
1388                 vector<string> const reqDescs = idsToNames(pkgList);
1389                 pkgdesc = formatStrVec(reqDescs, _( "and"));
1390                 if (!desc.empty())
1391                         desc += "\n";
1392                 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1393         }
1394
1395         if (!isModuleAvailable(modName)) {
1396                 if (!desc.empty())
1397                         desc += "\n";
1398                 desc += _("WARNING: Some packages are unavailable!");
1399         }
1400
1401         latexModule->infoML->document()->setPlainText(toqstr(desc));
1402 }
1403
1404
1405 void GuiDocument::setExtraEmbeddedFileList()
1406 {
1407         embeddedFilesModule->extraLW->clear();
1408         // add current embedded files
1409         vector<string> const & files = buffer().params().extraEmbeddedFiles();
1410         vector<string>::const_iterator fit = files.begin();
1411         vector<string>::const_iterator fit_end = files.end();
1412         for (; fit != fit_end; ++fit)
1413                 embeddedFilesModule->extraLW->addItem(toqstr(*fit));
1414 }
1415
1416
1417 void GuiDocument::addExtraEmbeddedFile()
1418 {
1419         QString file = browseRelFile(QString(), bufferFilepath(),
1420                 qt_("Extra embedded file"), FileFilterList(), true);
1421
1422         if (embeddedFilesModule->extraLW->findItems(file, Qt::MatchExactly).empty())
1423                 embeddedFilesModule->extraLW->addItem(file);
1424 }
1425
1426
1427 void GuiDocument::removeExtraEmbeddedFile()
1428 {
1429         int index = embeddedFilesModule->extraLW->currentRow();
1430         delete embeddedFilesModule->extraLW->takeItem(index);
1431 }
1432
1433
1434 void GuiDocument::updateNumbering()
1435 {
1436         DocumentClass const & tclass = bp_.documentClass();
1437
1438         numberingModule->tocTW->setUpdatesEnabled(false);
1439         numberingModule->tocTW->clear();
1440
1441         int const depth = numberingModule->depthSL->value();
1442         int const toc = numberingModule->tocSL->value();
1443         QString const no = qt_("No");
1444         QString const yes = qt_("Yes");
1445         QTreeWidgetItem * item = 0;
1446
1447         DocumentClass::const_iterator lit = tclass.begin();
1448         DocumentClass::const_iterator len = tclass.end();
1449         for (; lit != len; ++lit) {
1450                 int const toclevel = lit->toclevel;
1451                 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1452                         item = new QTreeWidgetItem(numberingModule->tocTW);
1453                         item->setText(0, toqstr(translateIfPossible(lit->name())));
1454                         item->setText(1, (toclevel <= depth) ? yes : no);
1455                         item->setText(2, (toclevel <= toc) ? yes : no);
1456                 }
1457         }
1458
1459         numberingModule->tocTW->setUpdatesEnabled(true);
1460         numberingModule->tocTW->update();
1461 }
1462
1463
1464 void GuiDocument::apply(BufferParams & params)
1465 {
1466         // preamble
1467         preambleModule->apply(params);
1468
1469         // biblio
1470         params.setCiteEngine(biblio::ENGINE_BASIC);
1471
1472         if (biblioModule->citeNatbibRB->isChecked()) {
1473                 bool const use_numerical_citations =
1474                         biblioModule->citeStyleCO->currentIndex();
1475                 if (use_numerical_citations)
1476                         params.setCiteEngine(biblio::ENGINE_NATBIB_NUMERICAL);
1477                 else
1478                         params.setCiteEngine(biblio::ENGINE_NATBIB_AUTHORYEAR);
1479
1480         } else if (biblioModule->citeJurabibRB->isChecked())
1481                 params.setCiteEngine(biblio::ENGINE_JURABIB);
1482
1483         params.use_bibtopic =
1484                 biblioModule->bibtopicCB->isChecked();
1485
1486         // language & quotes
1487         if (langModule->defaultencodingRB->isChecked()) {
1488                 params.inputenc = "auto";
1489         } else {
1490                 int i = langModule->encodingCO->currentIndex();
1491                 if (i == 0)
1492                         params.inputenc = "default";
1493                 else
1494                         params.inputenc =
1495                                 fromqstr(langModule->encodingCO->currentText());
1496         }
1497
1498         InsetQuotes::quote_language lga = InsetQuotes::EnglishQ;
1499         switch (langModule->quoteStyleCO->currentIndex()) {
1500         case 0:
1501                 lga = InsetQuotes::EnglishQ;
1502                 break;
1503         case 1:
1504                 lga = InsetQuotes::SwedishQ;
1505                 break;
1506         case 2:
1507                 lga = InsetQuotes::GermanQ;
1508                 break;
1509         case 3:
1510                 lga = InsetQuotes::PolishQ;
1511                 break;
1512         case 4:
1513                 lga = InsetQuotes::FrenchQ;
1514                 break;
1515         case 5:
1516                 lga = InsetQuotes::DanishQ;
1517                 break;
1518         }
1519         params.quotes_language = lga;
1520
1521         int const pos = langModule->languageCO->currentIndex();
1522         params.language = lyx::languages.getLanguage(fromqstr(lang_[pos]));
1523
1524         // numbering
1525         if (params.documentClass().hasTocLevels()) {
1526                 params.tocdepth = numberingModule->tocSL->value();
1527                 params.secnumdepth = numberingModule->depthSL->value();
1528         }
1529
1530         // bullets
1531         params.user_defined_bullet(0) = bulletsModule->getBullet(0);
1532         params.user_defined_bullet(1) = bulletsModule->getBullet(1);
1533         params.user_defined_bullet(2) = bulletsModule->getBullet(2);
1534         params.user_defined_bullet(3) = bulletsModule->getBullet(3);
1535
1536         // packages
1537         params.graphicsDriver =
1538                 tex_graphics[latexModule->psdriverCO->currentIndex()];
1539
1540         // text layout
1541         int idx = latexModule->classCO->currentIndex();
1542         if (idx >= 0) {
1543                 string const classname = classes_model_.getIDString(idx);
1544                 params.setBaseClass(classname);
1545         }
1546
1547         // Modules
1548         params.clearLayoutModules();
1549         int const srows = modules_sel_model_.rowCount();
1550         vector<string> selModList;
1551         for (int i = 0; i < srows; ++i)
1552                 params.addLayoutModule(modules_sel_model_.getIDString(i));
1553
1554         if (mathsModule->amsautoCB->isChecked()) {
1555                 params.use_amsmath = BufferParams::package_auto;
1556         } else {
1557                 if (mathsModule->amsCB->isChecked())
1558                         params.use_amsmath = BufferParams::package_on;
1559                 else
1560                         params.use_amsmath = BufferParams::package_off;
1561         }
1562
1563         if (mathsModule->esintautoCB->isChecked())
1564                 params.use_esint = BufferParams::package_auto;
1565         else {
1566                 if (mathsModule->esintCB->isChecked())
1567                         params.use_esint = BufferParams::package_on;
1568                 else
1569                         params.use_esint = BufferParams::package_off;
1570         }
1571
1572         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1573                 params.pagestyle = "default";
1574         else {
1575                 docstring style_gui =
1576                         qstring_to_ucs4(pageLayoutModule->pagestyleCO->currentText());
1577                 for (size_t i = 0; i < pagestyles.size(); ++i)
1578                         if (pagestyles[i].second == style_gui)
1579                                 params.pagestyle = pagestyles[i].first;
1580         }
1581
1582         switch (textLayoutModule->lspacingCO->currentIndex()) {
1583         case 0:
1584                 params.spacing().set(Spacing::Single);
1585                 break;
1586         case 1:
1587                 params.spacing().set(Spacing::Onehalf);
1588                 break;
1589         case 2:
1590                 params.spacing().set(Spacing::Double);
1591                 break;
1592         case 3:
1593                 params.spacing().set(Spacing::Other,
1594                         fromqstr(textLayoutModule->lspacingLE->text()));
1595                 break;
1596         }
1597
1598         if (textLayoutModule->twoColumnCB->isChecked())
1599                 params.columns = 2;
1600         else
1601                 params.columns = 1;
1602
1603         // text should have passed validation
1604         params.listings_params =
1605                 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1606
1607         if (textLayoutModule->indentRB->isChecked())
1608                 params.paragraph_separation = BufferParams::PARSEP_INDENT;
1609         else
1610                 params.paragraph_separation = BufferParams::PARSEP_SKIP;
1611
1612         switch (textLayoutModule->skipCO->currentIndex()) {
1613         case 0:
1614                 params.setDefSkip(VSpace(VSpace::SMALLSKIP));
1615                 break;
1616         case 1:
1617                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1618                 break;
1619         case 2:
1620                 params.setDefSkip(VSpace(VSpace::BIGSKIP));
1621                 break;
1622         case 3:
1623         {
1624                 VSpace vs = VSpace(
1625                         widgetsToLength(textLayoutModule->skipLE,
1626                                 textLayoutModule->skipLengthCO)
1627                         );
1628                 params.setDefSkip(vs);
1629                 break;
1630         }
1631         default:
1632                 // DocumentDefskipCB assures that this never happens
1633                 // so Assert then !!!  - jbl
1634                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1635                 break;
1636         }
1637
1638         params.options =
1639                 fromqstr(latexModule->optionsLE->text());
1640
1641         params.float_placement = floatModule->get();
1642
1643         // fonts
1644         params.fontsRoman =
1645                 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1646
1647         params.fontsSans =
1648                 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1649
1650         params.fontsTypewriter =
1651                 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1652
1653         params.fontsSansScale = fontModule->scaleSansSB->value();
1654
1655         params.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1656
1657         params.fontsSC = fontModule->fontScCB->isChecked();
1658
1659         params.fontsOSF = fontModule->fontOsfCB->isChecked();
1660
1661         params.fontsDefaultFamily = GuiDocument::fontfamilies[
1662                 fontModule->fontsDefaultCO->currentIndex()];
1663
1664         if (fontModule->fontsizeCO->currentIndex() == 0)
1665                 params.fontsize = "default";
1666         else
1667                 params.fontsize =
1668                         fromqstr(fontModule->fontsizeCO->currentText());
1669
1670         // paper
1671         params.papersize = PAPER_SIZE(
1672                 pageLayoutModule->papersizeCO->currentIndex());
1673
1674         // custom, A3, B3 and B4 paper sizes need geometry
1675         int psize = pageLayoutModule->papersizeCO->currentIndex();
1676         bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
1677
1678         params.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
1679                 pageLayoutModule->paperwidthUnitCO);
1680
1681         params.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
1682                 pageLayoutModule->paperheightUnitCO);
1683
1684         if (pageLayoutModule->facingPagesCB->isChecked())
1685                 params.sides = TwoSides;
1686         else
1687                 params.sides = OneSide;
1688
1689         if (pageLayoutModule->landscapeRB->isChecked())
1690                 params.orientation = ORIENTATION_LANDSCAPE;
1691         else
1692                 params.orientation = ORIENTATION_PORTRAIT;
1693
1694         // margins
1695         params.use_geometry = !marginsModule->marginCB->isChecked()
1696                 || geom_papersize;
1697
1698         Ui::MarginsUi const * m = marginsModule;
1699
1700         params.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
1701         params.topmargin = widgetsToLength(m->topLE, m->topUnit);
1702         params.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
1703         params.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
1704         params.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
1705         params.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
1706         params.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
1707         params.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
1708
1709         branchesModule->apply(params);
1710
1711         // PDF support
1712         PDFOptions & pdf = params.pdfoptions();
1713         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
1714         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
1715         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
1716         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
1717         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
1718
1719         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
1720         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
1721         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
1722         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
1723
1724         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
1725         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
1726         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
1727         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
1728         pdf.backref = pdfSupportModule->backrefCB->isChecked();
1729         pdf.pagebackref = pdfSupportModule->pagebackrefCB->isChecked();
1730         if (pdfSupportModule->fullscreenCB->isChecked())
1731                 pdf.pagemode = pdf.pagemode_fullscreen;
1732         else
1733                 pdf.pagemode.clear();
1734         pdf.quoted_options = pdf.quoted_options_check(
1735                                 fromqstr(pdfSupportModule->optionsLE->text()));
1736
1737         // Embedded files
1738         vector<string> & files = params.extraEmbeddedFiles();
1739         files.clear();
1740         for (int i = 0; i < embeddedFilesModule->extraLW->count(); ++i) {
1741                 QListWidgetItem * item = embeddedFilesModule->extraLW->item(i);
1742                 files.push_back(fromqstr(item->text()));
1743         }
1744 }
1745
1746
1747 static int findPos(QStringList const & vec, QString const & val)
1748 {
1749         for (int i = 0; i != vec.size(); ++i)
1750                 if (vec[i] == val)
1751                         return i;
1752         return 0;
1753 }
1754
1755
1756 void GuiDocument::updateParams()
1757 {
1758         updateParams(bp_);
1759 }
1760
1761
1762 void GuiDocument::updateParams(BufferParams const & params)
1763 {
1764         // set the default unit
1765         Length::UNIT defaultUnit = Length::CM;
1766         switch (lyxrc.default_papersize) {
1767                 case PAPER_DEFAULT: break;
1768
1769                 case PAPER_USLETTER:
1770                 case PAPER_USLEGAL:
1771                 case PAPER_USEXECUTIVE:
1772                         defaultUnit = Length::IN;
1773                         break;
1774
1775                 case PAPER_A3:
1776                 case PAPER_A4:
1777                 case PAPER_A5:
1778                 case PAPER_B3:
1779                 case PAPER_B4:
1780                 case PAPER_B5:
1781                         defaultUnit = Length::CM;
1782                         break;
1783                 case PAPER_CUSTOM:
1784                         break;
1785         }
1786
1787         // preamble
1788         preambleModule->update(params, id());
1789
1790         // biblio
1791         biblioModule->citeDefaultRB->setChecked(
1792                 params.getEngine() == biblio::ENGINE_BASIC);
1793
1794         biblioModule->citeNatbibRB->setChecked(
1795                 params.getEngine() == biblio::ENGINE_NATBIB_NUMERICAL ||
1796                 params.getEngine() == biblio::ENGINE_NATBIB_AUTHORYEAR);
1797
1798         biblioModule->citeStyleCO->setCurrentIndex(
1799                 params.getEngine() == biblio::ENGINE_NATBIB_NUMERICAL);
1800
1801         biblioModule->citeJurabibRB->setChecked(
1802                 params.getEngine() == biblio::ENGINE_JURABIB);
1803
1804         biblioModule->bibtopicCB->setChecked(
1805                 params.use_bibtopic);
1806
1807         // language & quotes
1808         int const pos = findPos(lang_, toqstr(params.language->lang()));
1809         langModule->languageCO->setCurrentIndex(pos);
1810
1811         langModule->quoteStyleCO->setCurrentIndex(
1812                 params.quotes_language);
1813
1814         bool default_enc = true;
1815         if (params.inputenc != "auto") {
1816                 default_enc = false;
1817                 if (params.inputenc == "default") {
1818                         langModule->encodingCO->setCurrentIndex(0);
1819                 } else {
1820                         int const i = langModule->encodingCO->findText(
1821                                         toqstr(params.inputenc));
1822                         if (i >= 0)
1823                                 langModule->encodingCO->setCurrentIndex(i);
1824                         else
1825                                 // unknown encoding. Set to default.
1826                                 default_enc = true;
1827                 }
1828         }
1829         langModule->defaultencodingRB->setChecked(default_enc);
1830         langModule->otherencodingRB->setChecked(!default_enc);
1831
1832         // numbering
1833         int const min_toclevel = documentClass().min_toclevel();
1834         int const max_toclevel = documentClass().max_toclevel();
1835         if (documentClass().hasTocLevels()) {
1836                 numberingModule->setEnabled(true);
1837                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
1838                 numberingModule->depthSL->setMaximum(max_toclevel);
1839                 numberingModule->depthSL->setValue(params.secnumdepth);
1840                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
1841                 numberingModule->tocSL->setMaximum(max_toclevel);
1842                 numberingModule->tocSL->setValue(params.tocdepth);
1843                 updateNumbering();
1844         } else {
1845                 numberingModule->setEnabled(false);
1846                 numberingModule->tocTW->clear();
1847         }
1848
1849         // bullets
1850         bulletsModule->setBullet(0, params.user_defined_bullet(0));
1851         bulletsModule->setBullet(1, params.user_defined_bullet(1));
1852         bulletsModule->setBullet(2, params.user_defined_bullet(2));
1853         bulletsModule->setBullet(3, params.user_defined_bullet(3));
1854         bulletsModule->init();
1855
1856         // packages
1857         int nitem = findToken(tex_graphics, params.graphicsDriver);
1858         if (nitem >= 0)
1859                 latexModule->psdriverCO->setCurrentIndex(nitem);
1860         updateModuleInfo();
1861
1862         mathsModule->amsCB->setChecked(
1863                 params.use_amsmath == BufferParams::package_on);
1864         mathsModule->amsautoCB->setChecked(
1865                 params.use_amsmath == BufferParams::package_auto);
1866
1867         mathsModule->esintCB->setChecked(
1868                 params.use_esint == BufferParams::package_on);
1869         mathsModule->esintautoCB->setChecked(
1870                 params.use_esint == BufferParams::package_auto);
1871
1872         switch (params.spacing().getSpace()) {
1873                 case Spacing::Other: nitem = 3; break;
1874                 case Spacing::Double: nitem = 2; break;
1875                 case Spacing::Onehalf: nitem = 1; break;
1876                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
1877         }
1878
1879         // text layout
1880         string const & layoutID = params.baseClassID();
1881         setLayoutComboByIDString(layoutID);
1882
1883         updatePagestyle(documentClass().opt_pagestyle(),
1884                                  params.pagestyle);
1885
1886         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
1887         if (params.spacing().getSpace() == Spacing::Other) {
1888                 textLayoutModule->lspacingLE->setText(
1889                         toqstr(params.spacing().getValueAsString()));
1890         }
1891         setLSpacing(nitem);
1892
1893         if (params.paragraph_separation == BufferParams::PARSEP_INDENT)
1894                 textLayoutModule->indentRB->setChecked(true);
1895         else
1896                 textLayoutModule->skipRB->setChecked(true);
1897
1898         int skip = 0;
1899         switch (params.getDefSkip().kind()) {
1900         case VSpace::SMALLSKIP:
1901                 skip = 0;
1902                 break;
1903         case VSpace::MEDSKIP:
1904                 skip = 1;
1905                 break;
1906         case VSpace::BIGSKIP:
1907                 skip = 2;
1908                 break;
1909         case VSpace::LENGTH:
1910         {
1911                 skip = 3;
1912                 string const length = params.getDefSkip().asLyXCommand();
1913                 lengthToWidgets(textLayoutModule->skipLE,
1914                         textLayoutModule->skipLengthCO,
1915                         length, defaultUnit);
1916                 break;
1917         }
1918         default:
1919                 skip = 0;
1920                 break;
1921         }
1922         textLayoutModule->skipCO->setCurrentIndex(skip);
1923         setSkip(skip);
1924
1925         textLayoutModule->twoColumnCB->setChecked(
1926                 params.columns == 2);
1927
1928         // break listings_params to multiple lines
1929         string lstparams =
1930                 InsetListingsParams(params.listings_params).separatedParams();
1931         textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
1932
1933         if (!params.options.empty()) {
1934                 latexModule->optionsLE->setText(
1935                         toqstr(params.options));
1936         } else {
1937                 latexModule->optionsLE->setText(QString());
1938         }
1939
1940         floatModule->set(params.float_placement);
1941
1942         // Fonts
1943         updateFontsize(documentClass().opt_fontsize(),
1944                         params.fontsize);
1945
1946         int n = findToken(tex_fonts_roman, params.fontsRoman);
1947         if (n >= 0) {
1948                 fontModule->fontsRomanCO->setCurrentIndex(n);
1949                 romanChanged(n);
1950         }
1951
1952         n = findToken(tex_fonts_sans, params.fontsSans);
1953         if (n >= 0)     {
1954                 fontModule->fontsSansCO->setCurrentIndex(n);
1955                 sansChanged(n);
1956         }
1957
1958         n = findToken(tex_fonts_monospaced, params.fontsTypewriter);
1959         if (n >= 0) {
1960                 fontModule->fontsTypewriterCO->setCurrentIndex(n);
1961                 ttChanged(n);
1962         }
1963
1964         fontModule->fontScCB->setChecked(params.fontsSC);
1965         fontModule->fontOsfCB->setChecked(params.fontsOSF);
1966         fontModule->scaleSansSB->setValue(params.fontsSansScale);
1967         fontModule->scaleTypewriterSB->setValue(params.fontsTypewriterScale);
1968         n = findToken(GuiDocument::fontfamilies, params.fontsDefaultFamily);
1969         if (n >= 0)
1970                 fontModule->fontsDefaultCO->setCurrentIndex(n);
1971
1972         // paper
1973         int const psize = params.papersize;
1974         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
1975         setCustomPapersize(psize);
1976
1977         bool const landscape =
1978                 params.orientation == ORIENTATION_LANDSCAPE;
1979         pageLayoutModule->landscapeRB->setChecked(landscape);
1980         pageLayoutModule->portraitRB->setChecked(!landscape);
1981
1982         pageLayoutModule->facingPagesCB->setChecked(
1983                 params.sides == TwoSides);
1984
1985
1986         lengthToWidgets(pageLayoutModule->paperwidthLE,
1987                 pageLayoutModule->paperwidthUnitCO, params.paperwidth, defaultUnit);
1988
1989         lengthToWidgets(pageLayoutModule->paperheightLE,
1990                 pageLayoutModule->paperheightUnitCO, params.paperheight, defaultUnit);
1991
1992         // margins
1993         Ui::MarginsUi * m = marginsModule;
1994
1995         setMargins(!params.use_geometry);
1996
1997         lengthToWidgets(m->topLE, m->topUnit,
1998                 params.topmargin, defaultUnit);
1999
2000         lengthToWidgets(m->bottomLE, m->bottomUnit,
2001                 params.bottommargin, defaultUnit);
2002
2003         lengthToWidgets(m->innerLE, m->innerUnit,
2004                 params.leftmargin, defaultUnit);
2005
2006         lengthToWidgets(m->outerLE, m->outerUnit,
2007                 params.rightmargin, defaultUnit);
2008
2009         lengthToWidgets(m->headheightLE, m->headheightUnit,
2010                 params.headheight, defaultUnit);
2011
2012         lengthToWidgets(m->headsepLE, m->headsepUnit,
2013                 params.headsep, defaultUnit);
2014
2015         lengthToWidgets(m->footskipLE, m->footskipUnit,
2016                 params.footskip, defaultUnit);
2017
2018         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2019                 params.columnsep, defaultUnit);
2020
2021         branchesModule->update(params);
2022
2023         // PDF support
2024         PDFOptions const & pdf = params.pdfoptions();
2025         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2026         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2027         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2028         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2029         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2030
2031         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2032         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2033         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2034
2035         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2036
2037         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2038         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2039         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2040         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2041         pdfSupportModule->backrefCB->setChecked(pdf.backref);
2042         pdfSupportModule->pagebackrefCB->setChecked(pdf.pagebackref);
2043         pdfSupportModule->fullscreenCB->setChecked
2044                 (pdf.pagemode == pdf.pagemode_fullscreen);
2045
2046         pdfSupportModule->optionsLE->setText(
2047                 toqstr(pdf.quoted_options));
2048
2049         setExtraEmbeddedFileList();
2050 }
2051
2052
2053 void GuiDocument::applyView()
2054 {
2055         apply(params());
2056 }
2057
2058
2059 void GuiDocument::saveDocDefault()
2060 {
2061         // we have to apply the params first
2062         applyView();
2063         saveAsDefault();
2064 }
2065
2066
2067 void GuiDocument::updateAvailableModules()
2068 {
2069         modules_av_model_.clear();
2070         vector<modInfoStruct> const modInfoList = getModuleInfo();
2071         int const mSize = modInfoList.size();
2072         for (int i = 0; i != mSize; ++i) {
2073                 modInfoStruct const & modInfo = modInfoList[i];
2074                 modules_av_model_.insertRow(i, qt_(modInfo.name), modInfo.id);
2075         }
2076 }
2077
2078
2079 void GuiDocument::updateSelectedModules()
2080 {
2081         // and selected ones, too
2082         modules_sel_model_.clear();
2083         vector<modInfoStruct> const selModList = getSelectedModules();
2084         int const sSize = selModList.size();
2085         for (int i = 0; i != sSize; ++i) {
2086                 modInfoStruct const & modInfo = selModList[i];
2087                 modules_sel_model_.insertRow(i, qt_(modInfo.name), modInfo.id);
2088         }
2089 }
2090
2091
2092 void GuiDocument::updateContents()
2093 {
2094         if (id() == current_id_)
2095                 return;
2096
2097         updateAvailableModules();
2098         updateSelectedModules();
2099
2100         //FIXME It'd be nice to make sure here that the selected
2101         //modules are consistent: That required modules are actually
2102         //selected, and that we don't have conflicts. If so, we could
2103         //at least pop up a warning.
2104         updateParams(bp_);
2105         current_id_ = id();
2106 }
2107
2108
2109 void GuiDocument::forceUpdate()
2110 {
2111         // reset to force dialog update
2112         current_id_ = 0;
2113         updateContents();
2114 }
2115
2116
2117 void GuiDocument::useClassDefaults()
2118 {
2119         if (applyPB->isEnabled()) {
2120                 int const ret = Alert::prompt(_("Unapplied changes"),
2121                                 _("Some changes in the dialog were not yet applied.\n"
2122                                   "If you do not apply now, they will be lost after this action."),
2123                                 1, 1, _("&Apply"), _("&Dismiss"));
2124                 if (ret == 0)
2125                         applyView();
2126         }
2127
2128         int idx = latexModule->classCO->currentIndex();
2129         string const classname = classes_model_.getIDString(idx);
2130         if (!bp_.setBaseClass(classname)) {
2131                 Alert::error(_("Error"), _("Unable to set document class."));
2132                 return;
2133         }
2134         bp_.useClassDefaults();
2135         forceUpdate();
2136 }
2137
2138
2139 void GuiDocument::setLayoutComboByIDString(std::string const & idString)
2140 {
2141         int idx = classes_model_.findIDString(idString);
2142         if (idx < 0)
2143                 Alert::warning(_("Can't set layout!"),
2144                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2145         else
2146                 latexModule->classCO->setCurrentIndex(idx);
2147 }
2148
2149
2150 bool GuiDocument::isValid()
2151 {
2152         return validate_listings_params().empty()
2153                 && (textLayoutModule->skipCO->currentIndex() != 3
2154                         || !textLayoutModule->skipLE->text().isEmpty());
2155 }
2156
2157
2158 char const * const GuiDocument::fontfamilies[5] = {
2159         "default", "rmdefault", "sfdefault", "ttdefault", ""
2160 };
2161
2162
2163 char const * GuiDocument::fontfamilies_gui[5] = {
2164         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2165 };
2166
2167
2168 bool GuiDocument::initialiseParams(string const &)
2169 {
2170         bp_ = buffer().params();
2171         loadModuleInfo();
2172         return true;
2173 }
2174
2175
2176 void GuiDocument::clearParams()
2177 {
2178         bp_ = BufferParams();
2179 }
2180
2181
2182 BufferId GuiDocument::id() const
2183 {
2184         return &buffer();
2185 }
2186
2187
2188 vector<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2189 {
2190         return moduleNames_;
2191 }
2192
2193
2194 vector<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2195 {
2196         vector<string> const & mods = params().getModules();
2197         vector<string>::const_iterator it =  mods.begin();
2198         vector<string>::const_iterator end = mods.end();
2199         vector<modInfoStruct> mInfo;
2200         for (; it != end; ++it) {
2201                 modInfoStruct m;
2202                 m.id = *it;
2203                 LyXModule * mod = moduleList[*it];
2204                 if (mod)
2205                         m.name = mod->getName();
2206                 else
2207                         m.name = *it + " (Not Found)";
2208                 mInfo.push_back(m);
2209         }
2210         return mInfo;
2211 }
2212
2213
2214 DocumentClass const & GuiDocument::documentClass() const
2215 {
2216         return bp_.documentClass();
2217 }
2218
2219
2220 static void dispatch_bufferparams(Dialog const & dialog,
2221         BufferParams const & bp, kb_action lfun)
2222 {
2223         ostringstream ss;
2224         ss << "\\begin_header\n";
2225         bp.writeFile(ss);
2226         ss << "\\end_header\n";
2227         dialog.dispatch(FuncRequest(lfun, ss.str()));
2228 }
2229
2230
2231 void GuiDocument::dispatchParams()
2232 {
2233         // This must come first so that a language change is correctly noticed
2234         setLanguage();
2235
2236         // Apply the BufferParams. Note that this will set the base class
2237         // and then update the buffer's layout.
2238         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2239
2240         // Generate the colours requested by each new branch.
2241         BranchList & branchlist = params().branchlist();
2242         if (!branchlist.empty()) {
2243                 BranchList::const_iterator it = branchlist.begin();
2244                 BranchList::const_iterator const end = branchlist.end();
2245                 for (; it != end; ++it) {
2246                         docstring const & current_branch = it->getBranch();
2247                         Branch const * branch = branchlist.find(current_branch);
2248                         string const x11hexname = X11hexname(branch->getColor());
2249                         // display the new color
2250                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2251                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
2252                 }
2253
2254                 // Open insets of selected branches, close deselected ones
2255                 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2256                         "assign branch"));
2257         }
2258         // FIXME: If we used an LFUN, we would not need those two lines:
2259         bufferview()->processUpdateFlags(Update::Force | Update::FitCursor);
2260 }
2261
2262
2263 void GuiDocument::setLanguage() const
2264 {
2265         Language const * const newL = bp_.language;
2266         if (buffer().params().language == newL)
2267                 return;
2268
2269         string const & lang_name = newL->lang();
2270         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2271 }
2272
2273
2274 void GuiDocument::saveAsDefault() const
2275 {
2276         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2277 }
2278
2279
2280 bool GuiDocument::isFontAvailable(string const & font) const
2281 {
2282         if (font == "default" || font == "cmr"
2283             || font == "cmss" || font == "cmtt")
2284                 // these are standard
2285                 return true;
2286         if (font == "lmodern" || font == "lmss" || font == "lmtt")
2287                 return LaTeXFeatures::isAvailable("lmodern");
2288         if (font == "times" || font == "palatino"
2289                  || font == "helvet" || font == "courier")
2290                 return LaTeXFeatures::isAvailable("psnfss");
2291         if (font == "cmbr" || font == "cmtl")
2292                 return LaTeXFeatures::isAvailable("cmbright");
2293         if (font == "utopia")
2294                 return LaTeXFeatures::isAvailable("utopia")
2295                         || LaTeXFeatures::isAvailable("fourier");
2296         if (font == "beraserif" || font == "berasans"
2297                 || font == "beramono")
2298                 return LaTeXFeatures::isAvailable("bera");
2299         return LaTeXFeatures::isAvailable(font);
2300 }
2301
2302
2303 bool GuiDocument::providesOSF(string const & font) const
2304 {
2305         if (font == "cmr")
2306                 return isFontAvailable("eco");
2307         if (font == "palatino")
2308                 return isFontAvailable("mathpazo");
2309         return false;
2310 }
2311
2312
2313 bool GuiDocument::providesSC(string const & font) const
2314 {
2315         if (font == "palatino")
2316                 return isFontAvailable("mathpazo");
2317         if (font == "utopia")
2318                 return isFontAvailable("fourier");
2319         return false;
2320 }
2321
2322
2323 bool GuiDocument::providesScale(string const & font) const
2324 {
2325         return font == "helvet" || font == "luximono"
2326                 || font == "berasans"  || font == "beramono";
2327 }
2328
2329
2330 void GuiDocument::loadModuleInfo()
2331 {
2332         moduleNames_.clear();
2333         LyXModuleList::const_iterator it  = moduleList.begin();
2334         LyXModuleList::const_iterator end = moduleList.end();
2335         for (; it != end; ++it) {
2336                 modInfoStruct m;
2337                 m.id = it->getID();
2338                 m.name = it->getName();
2339                 moduleNames_.push_back(m);
2340         }
2341 }
2342
2343
2344 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2345
2346
2347 } // namespace frontend
2348 } // namespace lyx
2349
2350 #include "GuiDocument_moc.cpp"