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                 LayoutFileList::Local);
1247
1248         if (name.empty()) {
1249                 Alert::error(_("Error"),
1250                         _("Unable to read local layout file."));
1251                 return;
1252         }
1253
1254         // do not trigger classChanged if there is no change.
1255         if (latexModule->classCO->currentText() == toqstr(name))
1256                 return;
1257
1258         // add to combo box
1259         int idx = latexModule->classCO->findText(toqstr(name));
1260         if (idx == -1) {
1261                 classes_model_.insertRow(0, toqstr(name), name);
1262                 latexModule->classCO->setCurrentIndex(0);
1263         } else
1264                 latexModule->classCO->setCurrentIndex(idx);
1265         classChanged();
1266 }
1267
1268
1269 void GuiDocument::classChanged()
1270 {
1271         int idx = latexModule->classCO->currentIndex();
1272         if (idx < 0)
1273                 return;
1274         string const classname = classes_model_.getIDString(idx);
1275         // check if this is a local layout file
1276         if (prefixIs(classname, LayoutFileList::localPrefix)) {
1277                 int const ret = Alert::prompt(_("Local layout file"),
1278                                 _("The layout file you have selected is a local layout\n"
1279                                   "file, not one in the system or user directory. Your\n"
1280                                   "document may not work with this layout if you do not\n"
1281                                   "keep the layout file in the same directory."),
1282                                   1, 1, _("&Set Layout"), _("&Cancel"));
1283                 if (ret == 1) {
1284                         // try to reset the layout combo
1285                         setLayoutComboByIDString(bp_.baseClassID());
1286                         return;
1287                 }
1288         } else if (prefixIs(classname, LayoutFileList::embeddedPrefix)) {
1289                 int const ret = Alert::prompt(_("Embedded layout"),
1290                                 _("The layout file you have selected is an embedded layout that\n"
1291                                   "is embedded to a buffer. You cannot make use of it unless\n"
1292                                   "it is already embedded to this buffer.\n"),
1293                                   1, 1, _("&Set Layout"), _("&Cancel"));
1294                 if (ret == 1) {
1295                         setLayoutComboByIDString(bp_.baseClassID());
1296                         return;
1297                 }
1298         }
1299         if (!bp_.setBaseClass(classname)) {
1300                 Alert::error(_("Error"), _("Unable to set document class."));
1301                 return;
1302         }
1303         if (lyxrc.auto_reset_options) {
1304                 if (applyPB->isEnabled()) {
1305                         int const ret = Alert::prompt(_("Unapplied changes"),
1306                                         _("Some changes in the dialog were not yet applied.\n"
1307                                         "If you do not apply now, they will be lost after this action."),
1308                                         1, 1, _("&Apply"), _("&Dismiss"));
1309                         if (ret == 0)
1310                                 applyView();
1311                 }
1312                 bp_.useClassDefaults();
1313                 forceUpdate();
1314         }
1315 }
1316
1317
1318 namespace {
1319         // This is an insanely complicated attempt to make this sort of thing
1320         // work with RTL languages.
1321         docstring formatStrVec(vector<string> const & v, docstring const & s)
1322         {
1323                 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1324                 int const vSize = v.size();
1325                 if (v.size() == 0)
1326                         return docstring();
1327                 else if (v.size() == 1)
1328                         return from_ascii(v[0]);
1329                 else if (v.size() == 2) {
1330                         docstring retval = _("%1$s and %2$s");
1331                         retval = subst(retval, _("and"), s);
1332                         return bformat(retval, from_ascii(v[0]), from_ascii(v[1]));
1333                 }
1334                 //The idea here is to format all but the last two items...
1335                 docstring t2 = _("%1$s, %2$s");
1336                 docstring retval = from_ascii(v[0]);
1337                 for (int i = 1; i < vSize - 2; ++i)
1338                         retval = bformat(t2, retval, from_ascii(v[i]));
1339                 //...and then to  plug them, and the last two, into this schema
1340                 docstring t = _("%1$s, %2$s, and %3$s");
1341                 t = subst(t, _("and"), s);
1342                 return bformat(t, retval, from_ascii(v[vSize - 2]), from_ascii(v[vSize - 1]));
1343         }
1344
1345         vector<string> idsToNames(vector<string> const & idList)
1346         {
1347                 vector<string> retval;
1348                 vector<string>::const_iterator it  = idList.begin();
1349                 vector<string>::const_iterator end = idList.end();
1350                 for (; it != end; ++it) {
1351                         LyXModule const * const mod = moduleList[*it];
1352                         if (!mod)
1353                                 retval.push_back(*it + " (Unavailable)");
1354                         else
1355                                 retval.push_back(mod->getName());
1356                 }
1357                 return retval;
1358         }
1359 }
1360
1361
1362 void GuiDocument::updateModuleInfo()
1363 {
1364         selectionManager->update();
1365
1366         //Module description
1367         bool const focusOnSelected = selectionManager->selectedFocused();
1368         QListView const * const lv =
1369                         focusOnSelected ? latexModule->selectedLV : latexModule->availableLV;
1370         if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1371                 latexModule->infoML->document()->clear();
1372                 return;
1373         }
1374         QModelIndex const & idx = lv->selectionModel()->currentIndex();
1375         GuiIdListModel const & idModel =
1376                         focusOnSelected  ? modules_sel_model_ : modules_av_model_;
1377         string const modName = idModel.getIDString(idx.row());
1378         docstring desc = getModuleDescription(modName);
1379
1380         vector<string> pkgList = getPackageList(modName);
1381         docstring pkgdesc = formatStrVec(pkgList, _("and"));
1382         if (!pkgdesc.empty()) {
1383                 if (!desc.empty())
1384                         desc += "\n";
1385                 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1386         }
1387
1388         pkgList = getRequiredList(modName);
1389         if (!pkgList.empty()) {
1390                 vector<string> const reqDescs = idsToNames(pkgList);
1391                 pkgdesc = formatStrVec(reqDescs, _("or"));
1392                 if (!desc.empty())
1393                         desc += "\n";
1394                 desc += bformat(_("Module required: %1$s."), pkgdesc);
1395         }
1396
1397         pkgList = getExcludedList(modName);
1398         if (!pkgList.empty()) {
1399                 vector<string> const reqDescs = idsToNames(pkgList);
1400                 pkgdesc = formatStrVec(reqDescs, _( "and"));
1401                 if (!desc.empty())
1402                         desc += "\n";
1403                 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1404         }
1405
1406         if (!isModuleAvailable(modName)) {
1407                 if (!desc.empty())
1408                         desc += "\n";
1409                 desc += _("WARNING: Some packages are unavailable!");
1410         }
1411
1412         latexModule->infoML->document()->setPlainText(toqstr(desc));
1413 }
1414
1415
1416 void GuiDocument::setExtraEmbeddedFileList()
1417 {
1418         embeddedFilesModule->extraLW->clear();
1419         // add current embedded files
1420         vector<string> const & files = buffer().params().extraEmbeddedFiles();
1421         vector<string>::const_iterator fit = files.begin();
1422         vector<string>::const_iterator fit_end = files.end();
1423         for (; fit != fit_end; ++fit)
1424                 embeddedFilesModule->extraLW->addItem(toqstr(*fit));
1425 }
1426
1427
1428 void GuiDocument::addExtraEmbeddedFile()
1429 {
1430         QString const label1 = qt_("Documents|#o#O");
1431         QString const dir1 = toqstr(lyxrc.document_path);
1432         FileFilterList const filter(_("LyX Layout (*.layout);;LaTeX Classes (*.{cls,sty});;BibTeX Databases (*.{bib,bst})"));
1433         QString file = browseRelFile(QString(), bufferFilepath(),
1434                 qt_("Extra embedded file"), filter, true, label1, dir1);
1435
1436         if (file.isEmpty())
1437                 return;
1438
1439         if (embeddedFilesModule->extraLW->findItems(file, Qt::MatchExactly).empty())
1440                 embeddedFilesModule->extraLW->addItem(file);
1441 }
1442
1443
1444 void GuiDocument::removeExtraEmbeddedFile()
1445 {
1446         int index = embeddedFilesModule->extraLW->currentRow();
1447         delete embeddedFilesModule->extraLW->takeItem(index);
1448 }
1449
1450
1451 void GuiDocument::updateNumbering()
1452 {
1453         DocumentClass const & tclass = bp_.documentClass();
1454
1455         numberingModule->tocTW->setUpdatesEnabled(false);
1456         numberingModule->tocTW->clear();
1457
1458         int const depth = numberingModule->depthSL->value();
1459         int const toc = numberingModule->tocSL->value();
1460         QString const no = qt_("No");
1461         QString const yes = qt_("Yes");
1462         QTreeWidgetItem * item = 0;
1463
1464         DocumentClass::const_iterator lit = tclass.begin();
1465         DocumentClass::const_iterator len = tclass.end();
1466         for (; lit != len; ++lit) {
1467                 int const toclevel = lit->toclevel;
1468                 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1469                         item = new QTreeWidgetItem(numberingModule->tocTW);
1470                         item->setText(0, toqstr(translateIfPossible(lit->name())));
1471                         item->setText(1, (toclevel <= depth) ? yes : no);
1472                         item->setText(2, (toclevel <= toc) ? yes : no);
1473                 }
1474         }
1475
1476         numberingModule->tocTW->setUpdatesEnabled(true);
1477         numberingModule->tocTW->update();
1478 }
1479
1480
1481 void GuiDocument::apply(BufferParams & params)
1482 {
1483         // preamble
1484         preambleModule->apply(params);
1485
1486         // biblio
1487         params.setCiteEngine(biblio::ENGINE_BASIC);
1488
1489         if (biblioModule->citeNatbibRB->isChecked()) {
1490                 bool const use_numerical_citations =
1491                         biblioModule->citeStyleCO->currentIndex();
1492                 if (use_numerical_citations)
1493                         params.setCiteEngine(biblio::ENGINE_NATBIB_NUMERICAL);
1494                 else
1495                         params.setCiteEngine(biblio::ENGINE_NATBIB_AUTHORYEAR);
1496
1497         } else if (biblioModule->citeJurabibRB->isChecked())
1498                 params.setCiteEngine(biblio::ENGINE_JURABIB);
1499
1500         params.use_bibtopic =
1501                 biblioModule->bibtopicCB->isChecked();
1502
1503         // language & quotes
1504         if (langModule->defaultencodingRB->isChecked()) {
1505                 params.inputenc = "auto";
1506         } else {
1507                 int i = langModule->encodingCO->currentIndex();
1508                 if (i == 0)
1509                         params.inputenc = "default";
1510                 else
1511                         params.inputenc =
1512                                 fromqstr(langModule->encodingCO->currentText());
1513         }
1514
1515         InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1516         switch (langModule->quoteStyleCO->currentIndex()) {
1517         case 0:
1518                 lga = InsetQuotes::EnglishQuotes;
1519                 break;
1520         case 1:
1521                 lga = InsetQuotes::SwedishQuotes;
1522                 break;
1523         case 2:
1524                 lga = InsetQuotes::GermanQuotes;
1525                 break;
1526         case 3:
1527                 lga = InsetQuotes::PolishQuotes;
1528                 break;
1529         case 4:
1530                 lga = InsetQuotes::FrenchQuotes;
1531                 break;
1532         case 5:
1533                 lga = InsetQuotes::DanishQuotes;
1534                 break;
1535         }
1536         params.quotes_language = lga;
1537
1538         int const pos = langModule->languageCO->currentIndex();
1539         params.language = lyx::languages.getLanguage(fromqstr(lang_[pos]));
1540
1541         // numbering
1542         if (params.documentClass().hasTocLevels()) {
1543                 params.tocdepth = numberingModule->tocSL->value();
1544                 params.secnumdepth = numberingModule->depthSL->value();
1545         }
1546
1547         // bullets
1548         params.user_defined_bullet(0) = bulletsModule->getBullet(0);
1549         params.user_defined_bullet(1) = bulletsModule->getBullet(1);
1550         params.user_defined_bullet(2) = bulletsModule->getBullet(2);
1551         params.user_defined_bullet(3) = bulletsModule->getBullet(3);
1552
1553         // packages
1554         params.graphicsDriver =
1555                 tex_graphics[latexModule->psdriverCO->currentIndex()];
1556
1557         // text layout
1558         int idx = latexModule->classCO->currentIndex();
1559         if (idx >= 0) {
1560                 string const classname = classes_model_.getIDString(idx);
1561                 params.setBaseClass(classname);
1562         }
1563
1564         // Modules
1565         params.clearLayoutModules();
1566         int const srows = modules_sel_model_.rowCount();
1567         vector<string> selModList;
1568         for (int i = 0; i < srows; ++i)
1569                 params.addLayoutModule(modules_sel_model_.getIDString(i));
1570
1571         if (mathsModule->amsautoCB->isChecked()) {
1572                 params.use_amsmath = BufferParams::package_auto;
1573         } else {
1574                 if (mathsModule->amsCB->isChecked())
1575                         params.use_amsmath = BufferParams::package_on;
1576                 else
1577                         params.use_amsmath = BufferParams::package_off;
1578         }
1579
1580         if (mathsModule->esintautoCB->isChecked())
1581                 params.use_esint = BufferParams::package_auto;
1582         else {
1583                 if (mathsModule->esintCB->isChecked())
1584                         params.use_esint = BufferParams::package_on;
1585                 else
1586                         params.use_esint = BufferParams::package_off;
1587         }
1588
1589         if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1590                 params.pagestyle = "default";
1591         else {
1592                 docstring style_gui =
1593                         qstring_to_ucs4(pageLayoutModule->pagestyleCO->currentText());
1594                 for (size_t i = 0; i < pagestyles.size(); ++i)
1595                         if (pagestyles[i].second == style_gui)
1596                                 params.pagestyle = pagestyles[i].first;
1597         }
1598
1599         switch (textLayoutModule->lspacingCO->currentIndex()) {
1600         case 0:
1601                 params.spacing().set(Spacing::Single);
1602                 break;
1603         case 1:
1604                 params.spacing().set(Spacing::Onehalf);
1605                 break;
1606         case 2:
1607                 params.spacing().set(Spacing::Double);
1608                 break;
1609         case 3:
1610                 params.spacing().set(Spacing::Other,
1611                         fromqstr(textLayoutModule->lspacingLE->text()));
1612                 break;
1613         }
1614
1615         if (textLayoutModule->twoColumnCB->isChecked())
1616                 params.columns = 2;
1617         else
1618                 params.columns = 1;
1619
1620         // text should have passed validation
1621         params.listings_params =
1622                 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1623
1624         if (textLayoutModule->indentRB->isChecked())
1625                 params.paragraph_separation = BufferParams::ParagraphIndentSeparation;
1626         else
1627                 params.paragraph_separation = BufferParams::ParagraphSkipSeparation;
1628
1629         switch (textLayoutModule->skipCO->currentIndex()) {
1630         case 0:
1631                 params.setDefSkip(VSpace(VSpace::SMALLSKIP));
1632                 break;
1633         case 1:
1634                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1635                 break;
1636         case 2:
1637                 params.setDefSkip(VSpace(VSpace::BIGSKIP));
1638                 break;
1639         case 3:
1640         {
1641                 VSpace vs = VSpace(
1642                         widgetsToLength(textLayoutModule->skipLE,
1643                                 textLayoutModule->skipLengthCO)
1644                         );
1645                 params.setDefSkip(vs);
1646                 break;
1647         }
1648         default:
1649                 // DocumentDefskipCB assures that this never happens
1650                 // so Assert then !!!  - jbl
1651                 params.setDefSkip(VSpace(VSpace::MEDSKIP));
1652                 break;
1653         }
1654
1655         params.options =
1656                 fromqstr(latexModule->optionsLE->text());
1657
1658         params.float_placement = floatModule->get();
1659
1660         // fonts
1661         params.fontsRoman =
1662                 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1663
1664         params.fontsSans =
1665                 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1666
1667         params.fontsTypewriter =
1668                 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1669
1670         params.fontsSansScale = fontModule->scaleSansSB->value();
1671
1672         params.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1673
1674         params.fontsSC = fontModule->fontScCB->isChecked();
1675
1676         params.fontsOSF = fontModule->fontOsfCB->isChecked();
1677
1678         params.fontsDefaultFamily = GuiDocument::fontfamilies[
1679                 fontModule->fontsDefaultCO->currentIndex()];
1680
1681         if (fontModule->fontsizeCO->currentIndex() == 0)
1682                 params.fontsize = "default";
1683         else
1684                 params.fontsize =
1685                         fromqstr(fontModule->fontsizeCO->currentText());
1686
1687         // paper
1688         params.papersize = PAPER_SIZE(
1689                 pageLayoutModule->papersizeCO->currentIndex());
1690
1691         // custom, A3, B3 and B4 paper sizes need geometry
1692         int psize = pageLayoutModule->papersizeCO->currentIndex();
1693         bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
1694
1695         params.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
1696                 pageLayoutModule->paperwidthUnitCO);
1697
1698         params.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
1699                 pageLayoutModule->paperheightUnitCO);
1700
1701         if (pageLayoutModule->facingPagesCB->isChecked())
1702                 params.sides = TwoSides;
1703         else
1704                 params.sides = OneSide;
1705
1706         if (pageLayoutModule->landscapeRB->isChecked())
1707                 params.orientation = ORIENTATION_LANDSCAPE;
1708         else
1709                 params.orientation = ORIENTATION_PORTRAIT;
1710
1711         // margins
1712         params.use_geometry = !marginsModule->marginCB->isChecked()
1713                 || geom_papersize;
1714
1715         Ui::MarginsUi const * m = marginsModule;
1716
1717         params.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
1718         params.topmargin = widgetsToLength(m->topLE, m->topUnit);
1719         params.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
1720         params.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
1721         params.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
1722         params.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
1723         params.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
1724         params.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
1725
1726         branchesModule->apply(params);
1727
1728         // PDF support
1729         PDFOptions & pdf = params.pdfoptions();
1730         pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
1731         pdf.title = fromqstr(pdfSupportModule->titleLE->text());
1732         pdf.author = fromqstr(pdfSupportModule->authorLE->text());
1733         pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
1734         pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
1735
1736         pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
1737         pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
1738         pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
1739         pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
1740
1741         pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
1742         pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
1743         pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
1744         pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
1745         pdf.backref = pdfSupportModule->backrefCB->isChecked();
1746         pdf.pagebackref = pdfSupportModule->pagebackrefCB->isChecked();
1747         if (pdfSupportModule->fullscreenCB->isChecked())
1748                 pdf.pagemode = pdf.pagemode_fullscreen;
1749         else
1750                 pdf.pagemode.clear();
1751         pdf.quoted_options = pdf.quoted_options_check(
1752                                 fromqstr(pdfSupportModule->optionsLE->text()));
1753
1754         // Embedded files
1755         vector<string> & files = params.extraEmbeddedFiles();
1756         files.clear();
1757         for (int i = 0; i < embeddedFilesModule->extraLW->count(); ++i) {
1758                 QListWidgetItem * item = embeddedFilesModule->extraLW->item(i);
1759                 files.push_back(fromqstr(item->text()));
1760         }
1761 }
1762
1763
1764 static int findPos(QStringList const & vec, QString const & val)
1765 {
1766         for (int i = 0; i != vec.size(); ++i)
1767                 if (vec[i] == val)
1768                         return i;
1769         return 0;
1770 }
1771
1772
1773 void GuiDocument::updateParams()
1774 {
1775         updateParams(bp_);
1776 }
1777
1778
1779 void GuiDocument::updateParams(BufferParams const & params)
1780 {
1781         // set the default unit
1782         Length::UNIT defaultUnit = Length::CM;
1783         switch (lyxrc.default_papersize) {
1784                 case PAPER_DEFAULT: break;
1785
1786                 case PAPER_USLETTER:
1787                 case PAPER_USLEGAL:
1788                 case PAPER_USEXECUTIVE:
1789                         defaultUnit = Length::IN;
1790                         break;
1791
1792                 case PAPER_A3:
1793                 case PAPER_A4:
1794                 case PAPER_A5:
1795                 case PAPER_B3:
1796                 case PAPER_B4:
1797                 case PAPER_B5:
1798                         defaultUnit = Length::CM;
1799                         break;
1800                 case PAPER_CUSTOM:
1801                         break;
1802         }
1803
1804         // preamble
1805         preambleModule->update(params, id());
1806
1807         // biblio
1808         biblioModule->citeDefaultRB->setChecked(
1809                 params.citeEngine() == biblio::ENGINE_BASIC);
1810
1811         biblioModule->citeNatbibRB->setChecked(
1812                 params.citeEngine() == biblio::ENGINE_NATBIB_NUMERICAL ||
1813                 params.citeEngine() == biblio::ENGINE_NATBIB_AUTHORYEAR);
1814
1815         biblioModule->citeStyleCO->setCurrentIndex(
1816                 params.citeEngine() == biblio::ENGINE_NATBIB_NUMERICAL);
1817
1818         biblioModule->citeJurabibRB->setChecked(
1819                 params.citeEngine() == biblio::ENGINE_JURABIB);
1820
1821         biblioModule->bibtopicCB->setChecked(
1822                 params.use_bibtopic);
1823
1824         // language & quotes
1825         int const pos = findPos(lang_, toqstr(params.language->lang()));
1826         langModule->languageCO->setCurrentIndex(pos);
1827
1828         langModule->quoteStyleCO->setCurrentIndex(
1829                 params.quotes_language);
1830
1831         bool default_enc = true;
1832         if (params.inputenc != "auto") {
1833                 default_enc = false;
1834                 if (params.inputenc == "default") {
1835                         langModule->encodingCO->setCurrentIndex(0);
1836                 } else {
1837                         int const i = langModule->encodingCO->findText(
1838                                         toqstr(params.inputenc));
1839                         if (i >= 0)
1840                                 langModule->encodingCO->setCurrentIndex(i);
1841                         else
1842                                 // unknown encoding. Set to default.
1843                                 default_enc = true;
1844                 }
1845         }
1846         langModule->defaultencodingRB->setChecked(default_enc);
1847         langModule->otherencodingRB->setChecked(!default_enc);
1848
1849         // numbering
1850         int const min_toclevel = documentClass().min_toclevel();
1851         int const max_toclevel = documentClass().max_toclevel();
1852         if (documentClass().hasTocLevels()) {
1853                 numberingModule->setEnabled(true);
1854                 numberingModule->depthSL->setMinimum(min_toclevel - 1);
1855                 numberingModule->depthSL->setMaximum(max_toclevel);
1856                 numberingModule->depthSL->setValue(params.secnumdepth);
1857                 numberingModule->tocSL->setMaximum(min_toclevel - 1);
1858                 numberingModule->tocSL->setMaximum(max_toclevel);
1859                 numberingModule->tocSL->setValue(params.tocdepth);
1860                 updateNumbering();
1861         } else {
1862                 numberingModule->setEnabled(false);
1863                 numberingModule->tocTW->clear();
1864         }
1865
1866         // bullets
1867         bulletsModule->setBullet(0, params.user_defined_bullet(0));
1868         bulletsModule->setBullet(1, params.user_defined_bullet(1));
1869         bulletsModule->setBullet(2, params.user_defined_bullet(2));
1870         bulletsModule->setBullet(3, params.user_defined_bullet(3));
1871         bulletsModule->init();
1872
1873         // packages
1874         int nitem = findToken(tex_graphics, params.graphicsDriver);
1875         if (nitem >= 0)
1876                 latexModule->psdriverCO->setCurrentIndex(nitem);
1877         updateModuleInfo();
1878
1879         mathsModule->amsCB->setChecked(
1880                 params.use_amsmath == BufferParams::package_on);
1881         mathsModule->amsautoCB->setChecked(
1882                 params.use_amsmath == BufferParams::package_auto);
1883
1884         mathsModule->esintCB->setChecked(
1885                 params.use_esint == BufferParams::package_on);
1886         mathsModule->esintautoCB->setChecked(
1887                 params.use_esint == BufferParams::package_auto);
1888
1889         switch (params.spacing().getSpace()) {
1890                 case Spacing::Other: nitem = 3; break;
1891                 case Spacing::Double: nitem = 2; break;
1892                 case Spacing::Onehalf: nitem = 1; break;
1893                 case Spacing::Default: case Spacing::Single: nitem = 0; break;
1894         }
1895
1896         // text layout
1897         string const & layoutID = params.baseClassID();
1898         setLayoutComboByIDString(layoutID);
1899
1900         updatePagestyle(documentClass().opt_pagestyle(),
1901                                  params.pagestyle);
1902
1903         textLayoutModule->lspacingCO->setCurrentIndex(nitem);
1904         if (params.spacing().getSpace() == Spacing::Other) {
1905                 textLayoutModule->lspacingLE->setText(
1906                         toqstr(params.spacing().getValueAsString()));
1907         }
1908         setLSpacing(nitem);
1909
1910         if (params.paragraph_separation == BufferParams::ParagraphIndentSeparation)
1911                 textLayoutModule->indentRB->setChecked(true);
1912         else
1913                 textLayoutModule->skipRB->setChecked(true);
1914
1915         int skip = 0;
1916         switch (params.getDefSkip().kind()) {
1917         case VSpace::SMALLSKIP:
1918                 skip = 0;
1919                 break;
1920         case VSpace::MEDSKIP:
1921                 skip = 1;
1922                 break;
1923         case VSpace::BIGSKIP:
1924                 skip = 2;
1925                 break;
1926         case VSpace::LENGTH:
1927         {
1928                 skip = 3;
1929                 string const length = params.getDefSkip().asLyXCommand();
1930                 lengthToWidgets(textLayoutModule->skipLE,
1931                         textLayoutModule->skipLengthCO,
1932                         length, defaultUnit);
1933                 break;
1934         }
1935         default:
1936                 skip = 0;
1937                 break;
1938         }
1939         textLayoutModule->skipCO->setCurrentIndex(skip);
1940         setSkip(skip);
1941
1942         textLayoutModule->twoColumnCB->setChecked(
1943                 params.columns == 2);
1944
1945         // break listings_params to multiple lines
1946         string lstparams =
1947                 InsetListingsParams(params.listings_params).separatedParams();
1948         textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
1949
1950         if (!params.options.empty()) {
1951                 latexModule->optionsLE->setText(
1952                         toqstr(params.options));
1953         } else {
1954                 latexModule->optionsLE->setText(QString());
1955         }
1956
1957         floatModule->set(params.float_placement);
1958
1959         // Fonts
1960         updateFontsize(documentClass().opt_fontsize(),
1961                         params.fontsize);
1962
1963         int n = findToken(tex_fonts_roman, params.fontsRoman);
1964         if (n >= 0) {
1965                 fontModule->fontsRomanCO->setCurrentIndex(n);
1966                 romanChanged(n);
1967         }
1968
1969         n = findToken(tex_fonts_sans, params.fontsSans);
1970         if (n >= 0)     {
1971                 fontModule->fontsSansCO->setCurrentIndex(n);
1972                 sansChanged(n);
1973         }
1974
1975         n = findToken(tex_fonts_monospaced, params.fontsTypewriter);
1976         if (n >= 0) {
1977                 fontModule->fontsTypewriterCO->setCurrentIndex(n);
1978                 ttChanged(n);
1979         }
1980
1981         fontModule->fontScCB->setChecked(params.fontsSC);
1982         fontModule->fontOsfCB->setChecked(params.fontsOSF);
1983         fontModule->scaleSansSB->setValue(params.fontsSansScale);
1984         fontModule->scaleTypewriterSB->setValue(params.fontsTypewriterScale);
1985         n = findToken(GuiDocument::fontfamilies, params.fontsDefaultFamily);
1986         if (n >= 0)
1987                 fontModule->fontsDefaultCO->setCurrentIndex(n);
1988
1989         // paper
1990         int const psize = params.papersize;
1991         pageLayoutModule->papersizeCO->setCurrentIndex(psize);
1992         setCustomPapersize(psize);
1993
1994         bool const landscape =
1995                 params.orientation == ORIENTATION_LANDSCAPE;
1996         pageLayoutModule->landscapeRB->setChecked(landscape);
1997         pageLayoutModule->portraitRB->setChecked(!landscape);
1998
1999         pageLayoutModule->facingPagesCB->setChecked(
2000                 params.sides == TwoSides);
2001
2002
2003         lengthToWidgets(pageLayoutModule->paperwidthLE,
2004                 pageLayoutModule->paperwidthUnitCO, params.paperwidth, defaultUnit);
2005
2006         lengthToWidgets(pageLayoutModule->paperheightLE,
2007                 pageLayoutModule->paperheightUnitCO, params.paperheight, defaultUnit);
2008
2009         // margins
2010         Ui::MarginsUi * m = marginsModule;
2011
2012         setMargins(!params.use_geometry);
2013
2014         lengthToWidgets(m->topLE, m->topUnit,
2015                 params.topmargin, defaultUnit);
2016
2017         lengthToWidgets(m->bottomLE, m->bottomUnit,
2018                 params.bottommargin, defaultUnit);
2019
2020         lengthToWidgets(m->innerLE, m->innerUnit,
2021                 params.leftmargin, defaultUnit);
2022
2023         lengthToWidgets(m->outerLE, m->outerUnit,
2024                 params.rightmargin, defaultUnit);
2025
2026         lengthToWidgets(m->headheightLE, m->headheightUnit,
2027                 params.headheight, defaultUnit);
2028
2029         lengthToWidgets(m->headsepLE, m->headsepUnit,
2030                 params.headsep, defaultUnit);
2031
2032         lengthToWidgets(m->footskipLE, m->footskipUnit,
2033                 params.footskip, defaultUnit);
2034
2035         lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2036                 params.columnsep, defaultUnit);
2037
2038         branchesModule->update(params);
2039
2040         // PDF support
2041         PDFOptions const & pdf = params.pdfoptions();
2042         pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2043         pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2044         pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2045         pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2046         pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2047
2048         pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2049         pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2050         pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2051
2052         pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2053
2054         pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2055         pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2056         pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2057         pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2058         pdfSupportModule->backrefCB->setChecked(pdf.backref);
2059         pdfSupportModule->pagebackrefCB->setChecked(pdf.pagebackref);
2060         pdfSupportModule->fullscreenCB->setChecked
2061                 (pdf.pagemode == pdf.pagemode_fullscreen);
2062
2063         pdfSupportModule->optionsLE->setText(
2064                 toqstr(pdf.quoted_options));
2065
2066         setExtraEmbeddedFileList();
2067 }
2068
2069
2070 void GuiDocument::applyView()
2071 {
2072         apply(params());
2073 }
2074
2075
2076 void GuiDocument::saveDocDefault()
2077 {
2078         // we have to apply the params first
2079         applyView();
2080         saveAsDefault();
2081 }
2082
2083
2084 void GuiDocument::updateAvailableModules()
2085 {
2086         modules_av_model_.clear();
2087         vector<modInfoStruct> const modInfoList = getModuleInfo();
2088         int const mSize = modInfoList.size();
2089         for (int i = 0; i != mSize; ++i) {
2090                 modInfoStruct const & modInfo = modInfoList[i];
2091                 modules_av_model_.insertRow(i, qt_(modInfo.name), modInfo.id);
2092         }
2093 }
2094
2095
2096 void GuiDocument::updateSelectedModules()
2097 {
2098         // and selected ones, too
2099         modules_sel_model_.clear();
2100         vector<modInfoStruct> const selModList = getSelectedModules();
2101         int const sSize = selModList.size();
2102         for (int i = 0; i != sSize; ++i) {
2103                 modInfoStruct const & modInfo = selModList[i];
2104                 modules_sel_model_.insertRow(i, qt_(modInfo.name), modInfo.id);
2105         }
2106 }
2107
2108
2109 void GuiDocument::updateContents()
2110 {
2111         if (id() == current_id_)
2112                 return;
2113
2114         updateAvailableModules();
2115         updateSelectedModules();
2116
2117         //FIXME It'd be nice to make sure here that the selected
2118         //modules are consistent: That required modules are actually
2119         //selected, and that we don't have conflicts. If so, we could
2120         //at least pop up a warning.
2121         updateParams(bp_);
2122         current_id_ = id();
2123 }
2124
2125
2126 void GuiDocument::forceUpdate()
2127 {
2128         // reset to force dialog update
2129         current_id_ = 0;
2130         updateContents();
2131 }
2132
2133
2134 void GuiDocument::useClassDefaults()
2135 {
2136         if (applyPB->isEnabled()) {
2137                 int const ret = Alert::prompt(_("Unapplied changes"),
2138                                 _("Some changes in the dialog were not yet applied.\n"
2139                                   "If you do not apply now, they will be lost after this action."),
2140                                 1, 1, _("&Apply"), _("&Dismiss"));
2141                 if (ret == 0)
2142                         applyView();
2143         }
2144
2145         int idx = latexModule->classCO->currentIndex();
2146         string const classname = classes_model_.getIDString(idx);
2147         if (!bp_.setBaseClass(classname)) {
2148                 Alert::error(_("Error"), _("Unable to set document class."));
2149                 return;
2150         }
2151         bp_.useClassDefaults();
2152         forceUpdate();
2153 }
2154
2155
2156 void GuiDocument::setLayoutComboByIDString(std::string const & idString)
2157 {
2158         int idx = classes_model_.findIDString(idString);
2159         if (idx < 0)
2160                 Alert::warning(_("Can't set layout!"),
2161                         bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2162         else
2163                 latexModule->classCO->setCurrentIndex(idx);
2164 }
2165
2166
2167 bool GuiDocument::isValid()
2168 {
2169         return validate_listings_params().empty()
2170                 && (textLayoutModule->skipCO->currentIndex() != 3
2171                         || !textLayoutModule->skipLE->text().isEmpty());
2172 }
2173
2174
2175 char const * const GuiDocument::fontfamilies[5] = {
2176         "default", "rmdefault", "sfdefault", "ttdefault", ""
2177 };
2178
2179
2180 char const * GuiDocument::fontfamilies_gui[5] = {
2181         N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2182 };
2183
2184
2185 bool GuiDocument::initialiseParams(string const &)
2186 {
2187         bp_ = buffer().params();
2188         loadModuleInfo();
2189         return true;
2190 }
2191
2192
2193 void GuiDocument::clearParams()
2194 {
2195         bp_ = BufferParams();
2196 }
2197
2198
2199 BufferId GuiDocument::id() const
2200 {
2201         return &buffer();
2202 }
2203
2204
2205 vector<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2206 {
2207         return moduleNames_;
2208 }
2209
2210
2211 vector<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2212 {
2213         vector<string> const & mods = params().getModules();
2214         vector<string>::const_iterator it =  mods.begin();
2215         vector<string>::const_iterator end = mods.end();
2216         vector<modInfoStruct> mInfo;
2217         for (; it != end; ++it) {
2218                 modInfoStruct m;
2219                 m.id = *it;
2220                 LyXModule * mod = moduleList[*it];
2221                 if (mod)
2222                         m.name = mod->getName();
2223                 else
2224                         m.name = *it + " (Not Found)";
2225                 mInfo.push_back(m);
2226         }
2227         return mInfo;
2228 }
2229
2230
2231 DocumentClass const & GuiDocument::documentClass() const
2232 {
2233         return bp_.documentClass();
2234 }
2235
2236
2237 static void dispatch_bufferparams(Dialog const & dialog,
2238         BufferParams const & bp, kb_action lfun)
2239 {
2240         ostringstream ss;
2241         ss << "\\begin_header\n";
2242         bp.writeFile(ss);
2243         ss << "\\end_header\n";
2244         dialog.dispatch(FuncRequest(lfun, ss.str()));
2245 }
2246
2247
2248 void GuiDocument::dispatchParams()
2249 {
2250         // This must come first so that a language change is correctly noticed
2251         setLanguage();
2252
2253         // Apply the BufferParams. Note that this will set the base class
2254         // and then update the buffer's layout.
2255         dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2256
2257         // Generate the colours requested by each new branch.
2258         BranchList & branchlist = params().branchlist();
2259         if (!branchlist.empty()) {
2260                 BranchList::const_iterator it = branchlist.begin();
2261                 BranchList::const_iterator const end = branchlist.end();
2262                 for (; it != end; ++it) {
2263                         docstring const & current_branch = it->getBranch();
2264                         Branch const * branch = branchlist.find(current_branch);
2265                         string const x11hexname = X11hexname(branch->getColor());
2266                         // display the new color
2267                         docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2268                         dispatch(FuncRequest(LFUN_SET_COLOR, str));
2269                 }
2270
2271                 // Open insets of selected branches, close deselected ones
2272                 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2273                         "assign branch"));
2274         }
2275         // FIXME: If we used an LFUN, we would not need those two lines:
2276         bufferview()->processUpdateFlags(Update::Force | Update::FitCursor);
2277 }
2278
2279
2280 void GuiDocument::setLanguage() const
2281 {
2282         Language const * const newL = bp_.language;
2283         if (buffer().params().language == newL)
2284                 return;
2285
2286         string const & lang_name = newL->lang();
2287         dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2288 }
2289
2290
2291 void GuiDocument::saveAsDefault() const
2292 {
2293         dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2294 }
2295
2296
2297 bool GuiDocument::isFontAvailable(string const & font) const
2298 {
2299         if (font == "default" || font == "cmr"
2300             || font == "cmss" || font == "cmtt")
2301                 // these are standard
2302                 return true;
2303         if (font == "lmodern" || font == "lmss" || font == "lmtt")
2304                 return LaTeXFeatures::isAvailable("lmodern");
2305         if (font == "times" || font == "palatino"
2306                  || font == "helvet" || font == "courier")
2307                 return LaTeXFeatures::isAvailable("psnfss");
2308         if (font == "cmbr" || font == "cmtl")
2309                 return LaTeXFeatures::isAvailable("cmbright");
2310         if (font == "utopia")
2311                 return LaTeXFeatures::isAvailable("utopia")
2312                         || LaTeXFeatures::isAvailable("fourier");
2313         if (font == "beraserif" || font == "berasans"
2314                 || font == "beramono")
2315                 return LaTeXFeatures::isAvailable("bera");
2316         return LaTeXFeatures::isAvailable(font);
2317 }
2318
2319
2320 bool GuiDocument::providesOSF(string const & font) const
2321 {
2322         if (font == "cmr")
2323                 return isFontAvailable("eco");
2324         if (font == "palatino")
2325                 return isFontAvailable("mathpazo");
2326         return false;
2327 }
2328
2329
2330 bool GuiDocument::providesSC(string const & font) const
2331 {
2332         if (font == "palatino")
2333                 return isFontAvailable("mathpazo");
2334         if (font == "utopia")
2335                 return isFontAvailable("fourier");
2336         return false;
2337 }
2338
2339
2340 bool GuiDocument::providesScale(string const & font) const
2341 {
2342         return font == "helvet" || font == "luximono"
2343                 || font == "berasans"  || font == "beramono";
2344 }
2345
2346
2347 void GuiDocument::loadModuleInfo()
2348 {
2349         moduleNames_.clear();
2350         LyXModuleList::const_iterator it  = moduleList.begin();
2351         LyXModuleList::const_iterator end = moduleList.end();
2352         for (; it != end; ++it) {
2353                 modInfoStruct m;
2354                 m.id = it->getID();
2355                 m.name = it->getName();
2356                 moduleNames_.push_back(m);
2357         }
2358 }
2359
2360
2361 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2362
2363
2364 } // namespace frontend
2365 } // namespace lyx
2366
2367 #include "GuiDocument_moc.cpp"