2 * \file GuiDocument.cpp
3 * This file is part of LyX, the document processor.
4 * Licence details can be found in the file COPYING.
7 * \author Richard Heck (modules)
9 * Full author contact details are available in file CREDITS.
14 #include "GuiDocument.h"
16 #include "GuiApplication.h"
17 #include "GuiBranches.h"
18 #include "GuiIndices.h"
19 #include "GuiSelectionManager.h"
20 #include "LaTeXHighlighter.h"
21 #include "LengthCombo.h"
22 #include "PanelStack.h"
23 #include "Validator.h"
25 #include "LayoutFile.h"
26 #include "BranchList.h"
27 #include "buffer_funcs.h"
29 #include "BufferParams.h"
30 #include "BufferView.h"
32 #include "ColorCache.h"
34 #include "FloatPlacement.h"
36 #include "FuncRequest.h"
37 #include "IndicesList.h"
39 #include "LaTeXFeatures.h"
41 #include "LayoutModuleList.h"
43 #include "ModuleList.h"
44 #include "OutputParams.h"
45 #include "PDFOptions.h"
46 #include "qt_helpers.h"
49 #include "insets/InsetListingsParams.h"
51 #include "support/debug.h"
52 #include "support/FileName.h"
53 #include "support/filetools.h"
54 #include "support/gettext.h"
55 #include "support/lstrings.h"
57 #include "frontends/alert.h"
59 #include <QAbstractItemModel>
61 #include <QColorDialog>
62 #include <QCloseEvent>
63 #include <QFontDatabase>
65 #include <QTextCursor>
75 // a style sheet for buttons
76 // this is for example used for the background color setting button
77 static inline QString colorButtonStyleSheet(QColor const & bgColor)
79 if (bgColor.isValid()) {
80 QString rc = QLatin1String("background:");
89 using namespace lyx::support;
94 char const * const tex_graphics[] =
96 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
97 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
98 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
99 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
104 char const * const tex_graphics_gui[] =
106 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
107 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
108 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
109 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
110 "XeTeX", N_("None"), ""
114 char const * const tex_fonts_roman[] =
116 "default", "cmr", "lmodern", "ae", "times", "palatino",
117 "charter", "newcent", "bookman", "utopia", "beraserif",
118 "ccfonts", "chancery", ""
122 char const * tex_fonts_roman_gui[] =
124 N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
125 N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
126 N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
127 N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
132 char const * const tex_fonts_sans[] =
134 "default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
138 char const * tex_fonts_sans_gui[] =
140 N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
141 N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
145 char const * const tex_fonts_monospaced[] =
147 "default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
151 char const * tex_fonts_monospaced_gui[] =
153 N_("Default"), N_("Computer Modern Typewriter"),
154 N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
155 N_("LuxiMono"), N_("CM Typewriter Light"), ""
159 char const * backref_opts[] =
161 "false", "section", "slide", "page", ""
165 char const * backref_opts_gui[] =
167 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
171 vector<pair<string, QString> > pagestyles;
174 } // anonymous namespace
178 RGBColor set_backgroundcolor;
181 // used when sorting the textclass list.
182 class less_textclass_avail_desc
183 : public binary_function<string, string, int>
186 bool operator()(string const & lhs, string const & rhs) const
188 // Ordering criteria:
189 // 1. Availability of text class
190 // 2. Description (lexicographic)
191 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
192 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
193 int const rel = compare_no_case(
194 translateIfPossible(from_utf8(tc1.description())),
195 translateIfPossible(from_utf8(tc2.description())));
196 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
197 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && rel < 0);
206 vector<string> getRequiredList(string const & modName)
208 LyXModule const * const mod = moduleList[modName];
210 return vector<string>(); //empty such thing
211 return mod->getRequiredModules();
215 vector<string> getExcludedList(string const & modName)
217 LyXModule const * const mod = moduleList[modName];
219 return vector<string>(); //empty such thing
220 return mod->getExcludedModules();
224 docstring getModuleDescription(string const & modName)
226 LyXModule const * const mod = moduleList[modName];
228 return _("Module not found!");
230 return translateIfPossible(from_utf8(mod->getDescription()));
234 vector<string> getPackageList(string const & modName)
236 LyXModule const * const mod = moduleList[modName];
238 return vector<string>(); //empty such thing
239 return mod->getPackageList();
243 bool isModuleAvailable(string const & modName)
245 LyXModule * mod = moduleList[modName];
248 return mod->isAvailable();
251 } // anonymous namespace
254 /////////////////////////////////////////////////////////////////////
256 // ModuleSelectionManager
258 /////////////////////////////////////////////////////////////////////
260 /// SelectionManager for use with modules
261 class ModuleSelectionManager : public GuiSelectionManager
265 ModuleSelectionManager(
266 QListView * availableLV,
267 QListView * selectedLV,
271 QPushButton * downPB,
272 GuiIdListModel * availableModel,
273 GuiIdListModel * selectedModel,
274 GuiDocument const * container)
275 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
276 upPB, downPB, availableModel, selectedModel), container_(container)
279 void updateProvidedModules(LayoutModuleList const & pm)
280 { provided_modules_ = pm.list(); }
282 void updateExcludedModules(LayoutModuleList const & em)
283 { excluded_modules_ = em.list(); }
286 virtual void updateAddPB();
288 virtual void updateUpPB();
290 virtual void updateDownPB();
292 virtual void updateDelPB();
293 /// returns availableModel as a GuiIdListModel
294 GuiIdListModel * getAvailableModel()
296 return dynamic_cast<GuiIdListModel *>(availableModel);
298 /// returns selectedModel as a GuiIdListModel
299 GuiIdListModel * getSelectedModel()
301 return dynamic_cast<GuiIdListModel *>(selectedModel);
303 /// keeps a list of the modules the text class provides
304 std::list<std::string> provided_modules_;
306 std::list<std::string> excluded_modules_;
308 GuiDocument const * container_;
311 void ModuleSelectionManager::updateAddPB()
313 int const arows = availableModel->rowCount();
314 QModelIndexList const avail_sels =
315 availableLV->selectionModel()->selectedIndexes();
317 // disable if there aren't any modules (?), if none of them is chosen
318 // in the dialog, or if the chosen one is already selected for use.
319 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
320 addPB->setEnabled(false);
324 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
325 string const modname = getAvailableModel()->getIDString(idx.row());
328 container_->params().moduleCanBeAdded(modname);
329 addPB->setEnabled(enable);
333 void ModuleSelectionManager::updateDownPB()
335 int const srows = selectedModel->rowCount();
337 downPB->setEnabled(false);
340 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
341 int const curRow = curidx.row();
342 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
343 downPB->setEnabled(false);
347 // determine whether immediately succeding element requires this one
348 string const curmodname = getSelectedModel()->getIDString(curRow);
349 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
351 vector<string> reqs = getRequiredList(nextmodname);
353 // if it doesn't require anything....
355 downPB->setEnabled(true);
359 // Enable it if this module isn't required.
360 // FIXME This should perhaps be more flexible and check whether, even
361 // if the next one is required, there is also an earlier one that will do.
363 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
366 void ModuleSelectionManager::updateUpPB()
368 int const srows = selectedModel->rowCount();
370 upPB->setEnabled(false);
374 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
375 int curRow = curIdx.row();
376 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
377 upPB->setEnabled(false);
380 string const curmodname = getSelectedModel()->getIDString(curRow);
382 // determine whether immediately preceding element is required by this one
383 vector<string> reqs = getRequiredList(curmodname);
385 // if this one doesn't require anything....
387 upPB->setEnabled(true);
392 // Enable it if the preceding module isn't required.
393 // NOTE This is less flexible than it might be. We could check whether, even
394 // if the previous one is required, there is an earlier one that would do.
395 string const premod = getSelectedModel()->getIDString(curRow - 1);
396 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
399 void ModuleSelectionManager::updateDelPB()
401 int const srows = selectedModel->rowCount();
403 deletePB->setEnabled(false);
407 QModelIndex const & curidx =
408 selectedLV->selectionModel()->currentIndex();
409 int const curRow = curidx.row();
410 if (curRow < 0 || curRow >= srows) { // invalid index?
411 deletePB->setEnabled(false);
415 string const curmodname = getSelectedModel()->getIDString(curRow);
417 // We're looking here for a reason NOT to enable the button. If we
418 // find one, we disable it and return. If we don't, we'll end up at
419 // the end of the function, and then we enable it.
420 for (int i = curRow + 1; i < srows; ++i) {
421 string const thisMod = getSelectedModel()->getIDString(i);
422 vector<string> reqs = getRequiredList(thisMod);
423 //does this one require us?
424 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
428 // OK, so this module requires us
429 // is there an EARLIER module that also satisfies the require?
430 // NOTE We demand that it be earlier to keep the list of modules
431 // consistent with the rule that a module must be proceeded by a
432 // required module. There would be more flexible ways to proceed,
433 // but that would be a lot more complicated, and the logic here is
434 // already complicated. (That's why I've left the debugging code.)
435 // lyxerr << "Testing " << thisMod << std::endl;
436 bool foundone = false;
437 for (int j = 0; j < curRow; ++j) {
438 string const mod = getSelectedModel()->getIDString(j);
439 // lyxerr << "In loop: Testing " << mod << std::endl;
440 // do we satisfy the require?
441 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
442 // lyxerr << mod << " does the trick." << std::endl;
447 // did we find a module to satisfy the require?
449 // lyxerr << "No matching module found." << std::endl;
450 deletePB->setEnabled(false);
454 // lyxerr << "All's well that ends well." << std::endl;
455 deletePB->setEnabled(true);
459 /////////////////////////////////////////////////////////////////////
463 /////////////////////////////////////////////////////////////////////
465 PreambleModule::PreambleModule() : current_id_(0)
467 // This is not a memory leak. The object will be destroyed
469 (void) new LaTeXHighlighter(preambleTE->document());
470 setFocusProxy(preambleTE);
471 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
475 void PreambleModule::update(BufferParams const & params, BufferId id)
477 QString preamble = toqstr(params.preamble);
478 // Nothing to do if the params and preamble are unchanged.
479 if (id == current_id_
480 && preamble == preambleTE->document()->toPlainText())
483 QTextCursor cur = preambleTE->textCursor();
484 // Save the coords before switching to the new one.
485 preamble_coords_[current_id_] =
486 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
488 // Save the params address for further use.
490 preambleTE->document()->setPlainText(preamble);
491 Coords::const_iterator it = preamble_coords_.find(current_id_);
492 if (it == preamble_coords_.end())
493 // First time we open this one.
494 preamble_coords_[current_id_] = make_pair(0, 0);
496 // Restore saved coords.
497 QTextCursor cur = preambleTE->textCursor();
498 cur.setPosition(it->second.first);
499 preambleTE->setTextCursor(cur);
500 preambleTE->verticalScrollBar()->setValue(it->second.second);
505 void PreambleModule::apply(BufferParams & params)
507 params.preamble = fromqstr(preambleTE->document()->toPlainText());
511 void PreambleModule::closeEvent(QCloseEvent * e)
513 // Save the coords before closing.
514 QTextCursor cur = preambleTE->textCursor();
515 preamble_coords_[current_id_] =
516 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
521 /////////////////////////////////////////////////////////////////////
525 /////////////////////////////////////////////////////////////////////
528 GuiDocument::GuiDocument(GuiView & lv)
529 : GuiDialog(lv, "document", qt_("Document Settings"))
533 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
534 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
535 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
536 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
538 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
539 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
541 // Manage the restore, ok, apply, restore and cancel/close buttons
542 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
544 bc().setApply(applyPB);
545 bc().setCancel(closePB);
546 bc().setRestore(restorePB);
548 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
550 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
551 this, SLOT(change_adaptor()));
552 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
553 this, SLOT(setLSpacing(int)));
554 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
555 this, SLOT(change_adaptor()));
556 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
557 this, SLOT(change_adaptor()));
558 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
559 this, SLOT(change_adaptor()));
560 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
561 this, SLOT(change_adaptor()));
562 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
563 this, SLOT(change_adaptor()));
564 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
565 this, SLOT(change_adaptor()));
566 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
567 this, SLOT(setSkip(int)));
568 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
569 this, SLOT(enableSkip(bool)));
570 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
571 this, SLOT(change_adaptor()));
572 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
573 this, SLOT(setColSep()));
574 connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
575 this, SLOT(change_adaptor()));
576 connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
577 this, SLOT(change_adaptor()));
578 connect(textLayoutModule->bypassCB, SIGNAL(clicked()),
579 this, SLOT(setListingsMessage()));
580 connect(textLayoutModule->listingsED, SIGNAL(textChanged()),
581 this, SLOT(setListingsMessage()));
582 textLayoutModule->listingsTB->setPlainText(
583 qt_("Input listings parameters on the right. Enter ? for a list of parameters."));
584 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
585 textLayoutModule->lspacingLE));
586 textLayoutModule->skipLE->setValidator(unsignedLengthValidator(
587 textLayoutModule->skipLE));
589 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
590 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
591 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
592 textLayoutModule->skipCO->addItem(qt_("Length"));
593 // remove the %-items from the unit choice
594 textLayoutModule->skipLengthCO->noPercents();
595 textLayoutModule->lspacingCO->insertItem(
596 Spacing::Single, qt_("Single"));
597 textLayoutModule->lspacingCO->insertItem(
598 Spacing::Onehalf, qt_("OneHalf"));
599 textLayoutModule->lspacingCO->insertItem(
600 Spacing::Double, qt_("Double"));
601 textLayoutModule->lspacingCO->insertItem(
602 Spacing::Other, qt_("Custom"));
604 // initialize the length validator
605 bc().addCheckedLineEdit(textLayoutModule->skipLE);
608 outputModule = new UiWidget<Ui::OutputUi>;
610 connect(outputModule->xetexCB, SIGNAL(clicked()),
611 this, SLOT(change_adaptor()));
612 connect(outputModule->xetexCB, SIGNAL(toggled(bool)),
613 this, SLOT(xetexChanged(bool)));
614 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
615 this, SLOT(change_adaptor()));
618 fontModule = new UiWidget<Ui::FontUi>;
619 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
620 this, SLOT(change_adaptor()));
621 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
622 this, SLOT(romanChanged(int)));
623 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
624 this, SLOT(change_adaptor()));
625 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
626 this, SLOT(sansChanged(int)));
627 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
628 this, SLOT(change_adaptor()));
629 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
630 this, SLOT(ttChanged(int)));
631 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
632 this, SLOT(change_adaptor()));
633 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
634 this, SLOT(change_adaptor()));
635 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
636 this, SLOT(change_adaptor()));
637 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
638 this, SLOT(change_adaptor()));
639 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
640 this, SLOT(change_adaptor()));
641 connect(fontModule->fontScCB, SIGNAL(clicked()),
642 this, SLOT(change_adaptor()));
643 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
644 this, SLOT(change_adaptor()));
648 fontModule->fontsizeCO->addItem(qt_("Default"));
649 fontModule->fontsizeCO->addItem(qt_("10"));
650 fontModule->fontsizeCO->addItem(qt_("11"));
651 fontModule->fontsizeCO->addItem(qt_("12"));
653 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
654 fontModule->fontsDefaultCO->addItem(
655 qt_(GuiDocument::fontfamilies_gui[n]));
658 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
660 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
661 this, SLOT(setCustomPapersize(int)));
662 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
663 this, SLOT(setCustomPapersize(int)));
664 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
665 this, SLOT(portraitChanged()));
666 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
667 this, SLOT(change_adaptor()));
668 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
669 this, SLOT(change_adaptor()));
670 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
671 this, SLOT(change_adaptor()));
672 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
673 this, SLOT(change_adaptor()));
674 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
675 this, SLOT(change_adaptor()));
676 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
677 this, SLOT(change_adaptor()));
678 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
679 this, SLOT(change_adaptor()));
680 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
681 this, SLOT(change_adaptor()));
682 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
683 this, SLOT(change_adaptor()));
684 connect(pageLayoutModule->backgroundPB, SIGNAL(clicked()),
685 this, SLOT(changeBackgroundColor()));
686 connect(pageLayoutModule->delbackgroundTB, SIGNAL(clicked()),
687 this, SLOT(deleteBackgroundColor()));
689 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
690 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
691 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
692 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
693 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
694 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
695 pageLayoutModule->paperheightL);
696 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
697 pageLayoutModule->paperwidthL);
700 QComboBox * cb = pageLayoutModule->papersizeCO;
701 cb->addItem(qt_("Default"));
702 cb->addItem(qt_("Custom"));
703 cb->addItem(qt_("US letter"));
704 cb->addItem(qt_("US legal"));
705 cb->addItem(qt_("US executive"));
706 cb->addItem(qt_("A3"));
707 cb->addItem(qt_("A4"));
708 cb->addItem(qt_("A5"));
709 cb->addItem(qt_("B3"));
710 cb->addItem(qt_("B4"));
711 cb->addItem(qt_("B5"));
712 // remove the %-items from the unit choice
713 pageLayoutModule->paperwidthUnitCO->noPercents();
714 pageLayoutModule->paperheightUnitCO->noPercents();
715 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
716 pageLayoutModule->paperheightLE));
717 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
718 pageLayoutModule->paperwidthLE));
721 marginsModule = new UiWidget<Ui::MarginsUi>;
723 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
724 this, SLOT(setCustomMargins(bool)));
725 connect(marginsModule->marginCB, SIGNAL(clicked()),
726 this, SLOT(change_adaptor()));
727 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
728 this, SLOT(change_adaptor()));
729 connect(marginsModule->topUnit, SIGNAL(activated(int)),
730 this, SLOT(change_adaptor()));
731 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
732 this, SLOT(change_adaptor()));
733 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
734 this, SLOT(change_adaptor()));
735 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
736 this, SLOT(change_adaptor()));
737 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
738 this, SLOT(change_adaptor()));
739 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
740 this, SLOT(change_adaptor()));
741 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
742 this, SLOT(change_adaptor()));
743 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
744 this, SLOT(change_adaptor()));
745 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
746 this, SLOT(change_adaptor()));
747 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
748 this, SLOT(change_adaptor()));
749 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
750 this, SLOT(change_adaptor()));
751 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
752 this, SLOT(change_adaptor()));
753 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
754 this, SLOT(change_adaptor()));
755 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
756 this, SLOT(change_adaptor()));
757 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
758 this, SLOT(change_adaptor()));
759 marginsModule->topLE->setValidator(unsignedLengthValidator(
760 marginsModule->topLE));
761 marginsModule->bottomLE->setValidator(unsignedLengthValidator(
762 marginsModule->bottomLE));
763 marginsModule->innerLE->setValidator(unsignedLengthValidator(
764 marginsModule->innerLE));
765 marginsModule->outerLE->setValidator(unsignedLengthValidator(
766 marginsModule->outerLE));
767 marginsModule->headsepLE->setValidator(unsignedLengthValidator(
768 marginsModule->headsepLE));
769 marginsModule->headheightLE->setValidator(unsignedLengthValidator(
770 marginsModule->headheightLE));
771 marginsModule->footskipLE->setValidator(unsignedLengthValidator(
772 marginsModule->footskipLE));
773 marginsModule->columnsepLE->setValidator(unsignedLengthValidator(
774 marginsModule->columnsepLE));
776 bc().addCheckedLineEdit(marginsModule->topLE,
777 marginsModule->topL);
778 bc().addCheckedLineEdit(marginsModule->bottomLE,
779 marginsModule->bottomL);
780 bc().addCheckedLineEdit(marginsModule->innerLE,
781 marginsModule->innerL);
782 bc().addCheckedLineEdit(marginsModule->outerLE,
783 marginsModule->outerL);
784 bc().addCheckedLineEdit(marginsModule->headsepLE,
785 marginsModule->headsepL);
786 bc().addCheckedLineEdit(marginsModule->headheightLE,
787 marginsModule->headheightL);
788 bc().addCheckedLineEdit(marginsModule->footskipLE,
789 marginsModule->footskipL);
790 bc().addCheckedLineEdit(marginsModule->columnsepLE,
791 marginsModule->columnsepL);
794 langModule = new UiWidget<Ui::LanguageUi>;
796 connect(langModule->languageCO, SIGNAL(activated(int)),
797 this, SLOT(change_adaptor()));
798 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
799 this, SLOT(change_adaptor()));
800 connect(langModule->otherencodingRB, SIGNAL(clicked()),
801 this, SLOT(change_adaptor()));
802 connect(langModule->encodingCO, SIGNAL(activated(int)),
803 this, SLOT(change_adaptor()));
804 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
805 this, SLOT(change_adaptor()));
807 QAbstractItemModel * language_model = guiApp->languageModel();
808 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
809 language_model->sort(0);
810 langModule->languageCO->setModel(language_model);
812 // Always put the default encoding in the first position.
813 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
814 QStringList encodinglist;
815 Encodings::const_iterator it = encodings.begin();
816 Encodings::const_iterator const end = encodings.end();
817 for (; it != end; ++it)
818 encodinglist.append(qt_(it->guiName()));
820 langModule->encodingCO->addItems(encodinglist);
822 langModule->quoteStyleCO->addItem(qt_("``text''"));
823 langModule->quoteStyleCO->addItem(qt_("''text''"));
824 langModule->quoteStyleCO->addItem(qt_(",,text``"));
825 langModule->quoteStyleCO->addItem(qt_(",,text''"));
826 langModule->quoteStyleCO->addItem(qt_("<<text>>"));
827 langModule->quoteStyleCO->addItem(qt_(">>text<<"));
830 numberingModule = new UiWidget<Ui::NumberingUi>;
832 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
833 this, SLOT(change_adaptor()));
834 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
835 this, SLOT(change_adaptor()));
836 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
837 this, SLOT(updateNumbering()));
838 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
839 this, SLOT(updateNumbering()));
840 numberingModule->tocTW->setColumnCount(3);
841 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
842 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
843 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
846 biblioModule = new UiWidget<Ui::BiblioUi>;
847 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
848 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
849 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
850 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
852 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
853 this, SLOT(change_adaptor()));
854 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
855 this, SLOT(change_adaptor()));
856 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
857 this, SLOT(change_adaptor()));
858 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
859 this, SLOT(change_adaptor()));
860 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
861 this, SLOT(change_adaptor()));
862 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
863 this, SLOT(bibtexChanged(int)));
864 connect(biblioModule->bibtexOptionsED, SIGNAL(textChanged(QString)),
865 this, SLOT(change_adaptor()));
867 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
868 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
869 biblioModule->citeStyleCO->setCurrentIndex(0);
871 biblioModule->bibtexCO->clear();
873 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
874 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
875 it != lyxrc.bibtex_alternatives.end(); ++it) {
876 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
877 biblioModule->bibtexCO->addItem(command, command);
881 indicesModule = new GuiIndices;
882 connect(indicesModule, SIGNAL(changed()),
883 this, SLOT(change_adaptor()));
886 mathsModule = new UiWidget<Ui::MathsUi>;
887 connect(mathsModule->amsautoCB, SIGNAL(toggled(bool)),
888 mathsModule->amsCB, SLOT(setDisabled(bool)));
889 connect(mathsModule->esintautoCB, SIGNAL(toggled(bool)),
890 mathsModule->esintCB, SLOT(setDisabled(bool)));
892 connect(mathsModule->amsCB, SIGNAL(clicked()),
893 this, SLOT(change_adaptor()));
894 connect(mathsModule->amsautoCB, SIGNAL(clicked()),
895 this, SLOT(change_adaptor()));
896 connect(mathsModule->esintCB, SIGNAL(clicked()),
897 this, SLOT(change_adaptor()));
898 connect(mathsModule->esintautoCB, SIGNAL(clicked()),
899 this, SLOT(change_adaptor()));
901 latexModule = new UiWidget<Ui::LaTeXUi>;
903 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
904 this, SLOT(change_adaptor()));
905 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
906 this, SLOT(change_adaptor()));
907 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
908 this, SLOT(change_adaptor()));
909 connect(latexModule->classCO, SIGNAL(activated(int)),
910 this, SLOT(classChanged()));
911 connect(latexModule->classCO, SIGNAL(activated(int)),
912 this, SLOT(change_adaptor()));
913 connect(latexModule->layoutPB, SIGNAL(clicked()),
914 this, SLOT(browseLayout()));
915 connect(latexModule->layoutPB, SIGNAL(clicked()),
916 this, SLOT(change_adaptor()));
917 connect(latexModule->childDocGB, SIGNAL(clicked()),
918 this, SLOT(change_adaptor()));
919 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
920 this, SLOT(change_adaptor()));
921 connect(latexModule->childDocPB, SIGNAL(clicked()),
922 this, SLOT(browseMaster()));
924 // postscript drivers
925 for (int n = 0; tex_graphics[n][0]; ++n) {
926 QString enc = qt_(tex_graphics_gui[n]);
927 latexModule->psdriverCO->addItem(enc);
930 latexModule->classCO->setModel(&classes_model_);
931 LayoutFileList const & bcl = LayoutFileList::get();
932 vector<LayoutFileIndex> classList = bcl.classList();
933 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
935 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
936 vector<LayoutFileIndex>::const_iterator cen = classList.end();
937 for (int i = 0; cit != cen; ++cit, ++i) {
938 LayoutFile const & tc = bcl[*cit];
939 docstring item = (tc.isTeXClassAvailable()) ?
940 from_utf8(tc.description()) :
941 bformat(_("Unavailable: %1$s"), from_utf8(tc.description()));
942 classes_model_.insertRow(i, toqstr(item), *cit);
946 branchesModule = new GuiBranches;
947 connect(branchesModule, SIGNAL(changed()),
948 this, SLOT(change_adaptor()));
951 preambleModule = new PreambleModule;
952 connect(preambleModule, SIGNAL(changed()),
953 this, SLOT(change_adaptor()));
956 bulletsModule = new BulletsModule;
957 connect(bulletsModule, SIGNAL(changed()),
958 this, SLOT(change_adaptor()));
961 modulesModule = new UiWidget<Ui::ModulesUi>;
964 new ModuleSelectionManager(modulesModule->availableLV,
965 modulesModule->selectedLV,
966 modulesModule->addPB, modulesModule->deletePB,
967 modulesModule->upPB, modulesModule->downPB,
968 availableModel(), selectedModel(), this);
969 connect(selectionManager, SIGNAL(updateHook()),
970 this, SLOT(updateModuleInfo()));
971 connect(selectionManager, SIGNAL(updateHook()),
972 this, SLOT(change_adaptor()));
973 connect(selectionManager, SIGNAL(selectionChanged()),
974 this, SLOT(modulesChanged()));
977 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
979 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
980 this, SLOT(change_adaptor()));
981 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
982 this, SLOT(change_adaptor()));
983 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
984 this, SLOT(change_adaptor()));
985 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
986 this, SLOT(change_adaptor()));
987 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
988 this, SLOT(change_adaptor()));
989 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
990 this, SLOT(change_adaptor()));
991 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
992 this, SLOT(change_adaptor()));
993 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
994 this, SLOT(change_adaptor()));
995 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
996 this, SLOT(change_adaptor()));
997 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
998 this, SLOT(change_adaptor()));
999 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1000 this, SLOT(change_adaptor()));
1001 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1002 this, SLOT(change_adaptor()));
1003 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1004 this, SLOT(change_adaptor()));
1005 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1006 this, SLOT(change_adaptor()));
1007 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1008 this, SLOT(change_adaptor()));
1009 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1010 this, SLOT(change_adaptor()));
1012 for (int i = 0; backref_opts[i][0]; ++i)
1013 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1016 floatModule = new FloatPlacement;
1017 connect(floatModule, SIGNAL(changed()),
1018 this, SLOT(change_adaptor()));
1020 docPS->addPanel(latexModule, qt_("Document Class"));
1021 docPS->addPanel(modulesModule, qt_("Modules"));
1022 docPS->addPanel(fontModule, qt_("Fonts"));
1023 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1024 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1025 docPS->addPanel(marginsModule, qt_("Page Margins"));
1026 docPS->addPanel(langModule, qt_("Language"));
1027 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1028 docPS->addPanel(biblioModule, qt_("Bibliography"));
1029 docPS->addPanel(indicesModule, qt_("Indexes"));
1030 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1031 docPS->addPanel(mathsModule, qt_("Math Options"));
1032 docPS->addPanel(floatModule, qt_("Float Placement"));
1033 docPS->addPanel(bulletsModule, qt_("Bullets"));
1034 docPS->addPanel(branchesModule, qt_("Branches"));
1035 docPS->addPanel(outputModule, qt_("Output"));
1036 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1037 docPS->setCurrentPanel(qt_("Document Class"));
1038 // FIXME: hack to work around resizing bug in Qt >= 4.2
1039 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1040 #if QT_VERSION >= 0x040200
1041 docPS->updateGeometry();
1046 void GuiDocument::showPreamble()
1048 docPS->setCurrentPanel(qt_("LaTeX Preamble"));
1052 void GuiDocument::saveDefaultClicked()
1058 void GuiDocument::useDefaultsClicked()
1064 void GuiDocument::change_adaptor()
1070 QString GuiDocument::validateListingsParameters()
1072 // use a cache here to avoid repeated validation
1073 // of the same parameters
1074 static string param_cache;
1075 static QString msg_cache;
1077 if (textLayoutModule->bypassCB->isChecked())
1080 string params = fromqstr(textLayoutModule->listingsED->toPlainText());
1081 if (params != param_cache) {
1082 param_cache = params;
1083 msg_cache = toqstr(InsetListingsParams(params).validate());
1089 void GuiDocument::setListingsMessage()
1091 static bool isOK = true;
1092 QString msg = validateListingsParameters();
1093 if (msg.isEmpty()) {
1097 // listingsTB->setTextColor("black");
1098 textLayoutModule->listingsTB->setPlainText(
1099 qt_("Input listings parameters on the right. "
1100 "Enter ? for a list of parameters."));
1103 // listingsTB->setTextColor("red");
1104 textLayoutModule->listingsTB->setPlainText(msg);
1109 void GuiDocument::setLSpacing(int item)
1111 textLayoutModule->lspacingLE->setEnabled(item == 3);
1115 void GuiDocument::setSkip(int item)
1117 bool const enable = (item == 3);
1118 textLayoutModule->skipLE->setEnabled(enable);
1119 textLayoutModule->skipLengthCO->setEnabled(enable);
1123 void GuiDocument::enableSkip(bool skip)
1125 textLayoutModule->skipCO->setEnabled(skip);
1126 textLayoutModule->skipLE->setEnabled(skip);
1127 textLayoutModule->skipLengthCO->setEnabled(skip);
1129 setSkip(textLayoutModule->skipCO->currentIndex());
1133 void GuiDocument::portraitChanged()
1135 setMargins(pageLayoutModule->papersizeCO->currentIndex());
1139 void GuiDocument::setMargins(bool custom)
1141 bool const extern_geometry =
1142 documentClass().provides("geometry");
1143 marginsModule->marginCB->setEnabled(!extern_geometry);
1144 if (extern_geometry) {
1145 marginsModule->marginCB->setChecked(false);
1146 setCustomMargins(true);
1149 marginsModule->marginCB->setChecked(custom);
1150 setCustomMargins(custom);
1154 void GuiDocument::setCustomPapersize(int papersize)
1156 bool const custom = (papersize == 1);
1158 pageLayoutModule->paperwidthL->setEnabled(custom);
1159 pageLayoutModule->paperwidthLE->setEnabled(custom);
1160 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1161 pageLayoutModule->paperheightL->setEnabled(custom);
1162 pageLayoutModule->paperheightLE->setEnabled(custom);
1163 pageLayoutModule->paperheightLE->setFocus();
1164 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1168 void GuiDocument::setColSep()
1170 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1174 void GuiDocument::setCustomMargins(bool custom)
1176 marginsModule->topL->setEnabled(!custom);
1177 marginsModule->topLE->setEnabled(!custom);
1178 marginsModule->topUnit->setEnabled(!custom);
1180 marginsModule->bottomL->setEnabled(!custom);
1181 marginsModule->bottomLE->setEnabled(!custom);
1182 marginsModule->bottomUnit->setEnabled(!custom);
1184 marginsModule->innerL->setEnabled(!custom);
1185 marginsModule->innerLE->setEnabled(!custom);
1186 marginsModule->innerUnit->setEnabled(!custom);
1188 marginsModule->outerL->setEnabled(!custom);
1189 marginsModule->outerLE->setEnabled(!custom);
1190 marginsModule->outerUnit->setEnabled(!custom);
1192 marginsModule->headheightL->setEnabled(!custom);
1193 marginsModule->headheightLE->setEnabled(!custom);
1194 marginsModule->headheightUnit->setEnabled(!custom);
1196 marginsModule->headsepL->setEnabled(!custom);
1197 marginsModule->headsepLE->setEnabled(!custom);
1198 marginsModule->headsepUnit->setEnabled(!custom);
1200 marginsModule->footskipL->setEnabled(!custom);
1201 marginsModule->footskipLE->setEnabled(!custom);
1202 marginsModule->footskipUnit->setEnabled(!custom);
1204 bool const enableColSep = !custom &&
1205 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1206 marginsModule->columnsepL->setEnabled(enableColSep);
1207 marginsModule->columnsepLE->setEnabled(enableColSep);
1208 marginsModule->columnsepUnit->setEnabled(enableColSep);
1211 void GuiDocument::changeBackgroundColor()
1213 QColor const & newColor = QColorDialog::getColor(
1214 rgb2qcolor(set_backgroundcolor), asQWidget());
1215 if (!newColor.isValid())
1217 // set the button color
1218 pageLayoutModule->backgroundPB->setStyleSheet(
1219 colorButtonStyleSheet(newColor));
1221 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1226 void GuiDocument::deleteBackgroundColor()
1228 // set the button color back to white
1229 pageLayoutModule->backgroundPB->setStyleSheet(
1230 colorButtonStyleSheet(QColor(Qt::white)));
1231 // save white as the set color
1232 set_backgroundcolor = rgbFromHexName("#ffffff");
1237 void GuiDocument::xetexChanged(bool xetex)
1240 updateDefaultFormat();
1241 langModule->encodingCO->setEnabled(!xetex &&
1242 !langModule->defaultencodingRB->isChecked());
1243 langModule->defaultencodingRB->setEnabled(!xetex);
1244 langModule->otherencodingRB->setEnabled(!xetex);
1246 fontModule->fontsDefaultCO->setEnabled(!xetex);
1247 fontModule->fontsDefaultLA->setEnabled(!xetex);
1248 fontModule->cjkFontLE->setEnabled(!xetex);
1249 fontModule->cjkFontLA->setEnabled(!xetex);
1252 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1253 bool scaleable = providesScale(font);
1254 fontModule->scaleSansSB->setEnabled(scaleable);
1255 fontModule->scaleSansLA->setEnabled(scaleable);
1257 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1258 scaleable = providesScale(font);
1259 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1260 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1262 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1263 fontModule->fontScCB->setEnabled(providesSC(font));
1264 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1268 void GuiDocument::updateFontsize(string const & items, string const & sel)
1270 fontModule->fontsizeCO->clear();
1271 fontModule->fontsizeCO->addItem(qt_("Default"));
1273 for (int n = 0; !token(items,'|',n).empty(); ++n)
1274 fontModule->fontsizeCO->
1275 addItem(toqstr(token(items,'|',n)));
1277 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1278 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1279 fontModule->fontsizeCO->setCurrentIndex(n);
1286 void GuiDocument::updateFontlist()
1288 fontModule->fontsRomanCO->clear();
1289 fontModule->fontsSansCO->clear();
1290 fontModule->fontsTypewriterCO->clear();
1292 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1293 if (outputModule->xetexCB->isChecked()) {
1294 fontModule->fontsRomanCO->addItem(qt_("Default"));
1295 fontModule->fontsSansCO->addItem(qt_("Default"));
1296 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1298 QFontDatabase fontdb;
1299 QStringList families(fontdb.families());
1300 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1301 fontModule->fontsRomanCO->addItem(*it);
1302 fontModule->fontsSansCO->addItem(*it);
1303 fontModule->fontsTypewriterCO->addItem(*it);
1308 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1309 QString font = qt_(tex_fonts_roman_gui[n]);
1310 if (!isFontAvailable(tex_fonts_roman[n]))
1311 font += qt_(" (not installed)");
1312 fontModule->fontsRomanCO->addItem(font);
1314 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1315 QString font = qt_(tex_fonts_sans_gui[n]);
1316 if (!isFontAvailable(tex_fonts_sans[n]))
1317 font += qt_(" (not installed)");
1318 fontModule->fontsSansCO->addItem(font);
1320 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1321 QString font = qt_(tex_fonts_monospaced_gui[n]);
1322 if (!isFontAvailable(tex_fonts_monospaced[n]))
1323 font += qt_(" (not installed)");
1324 fontModule->fontsTypewriterCO->addItem(font);
1329 void GuiDocument::romanChanged(int item)
1331 if (outputModule->xetexCB->isChecked())
1333 string const font = tex_fonts_roman[item];
1334 fontModule->fontScCB->setEnabled(providesSC(font));
1335 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1339 void GuiDocument::sansChanged(int item)
1341 if (outputModule->xetexCB->isChecked())
1343 string const font = tex_fonts_sans[item];
1344 bool scaleable = providesScale(font);
1345 fontModule->scaleSansSB->setEnabled(scaleable);
1346 fontModule->scaleSansLA->setEnabled(scaleable);
1350 void GuiDocument::ttChanged(int item)
1352 if (outputModule->xetexCB->isChecked())
1354 string const font = tex_fonts_monospaced[item];
1355 bool scaleable = providesScale(font);
1356 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1357 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1361 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1364 pageLayoutModule->pagestyleCO->clear();
1365 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1367 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1368 string style = token(items, '|', n);
1369 QString style_gui = qt_(style);
1370 pagestyles.push_back(pair<string, QString>(style, style_gui));
1371 pageLayoutModule->pagestyleCO->addItem(style_gui);
1374 if (sel == "default") {
1375 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1381 for (size_t i = 0; i < pagestyles.size(); ++i)
1382 if (pagestyles[i].first == sel)
1383 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1386 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1390 void GuiDocument::browseLayout()
1392 QString const label1 = qt_("Layouts|#o#O");
1393 QString const dir1 = toqstr(lyxrc.document_path);
1394 QStringList const filter(qt_("LyX Layout (*.layout)"));
1395 QString file = browseRelFile(QString(), bufferFilepath(),
1396 qt_("Local layout file"), filter, false,
1399 if (!file.endsWith(".layout"))
1402 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1403 fromqstr(bufferFilepath()));
1405 int const ret = Alert::prompt(_("Local layout file"),
1406 _("The layout file you have selected is a local layout\n"
1407 "file, not one in the system or user directory. Your\n"
1408 "document may not work with this layout if you do not\n"
1409 "keep the layout file in the document directory."),
1410 1, 1, _("&Set Layout"), _("&Cancel"));
1414 // load the layout file
1415 LayoutFileList & bcl = LayoutFileList::get();
1416 string classname = layoutFile.onlyFileName();
1417 // this will update an existing layout if that layout has been loaded before.
1418 LayoutFileIndex name = bcl.addLocalLayout(
1419 classname.substr(0, classname.size() - 7),
1420 layoutFile.onlyPath().absFilename());
1423 Alert::error(_("Error"),
1424 _("Unable to read local layout file."));
1428 // do not trigger classChanged if there is no change.
1429 if (latexModule->classCO->currentText() == toqstr(name))
1433 int idx = latexModule->classCO->findText(toqstr(name));
1435 classes_model_.insertRow(0, toqstr(name), name);
1436 latexModule->classCO->setCurrentIndex(0);
1438 latexModule->classCO->setCurrentIndex(idx);
1444 void GuiDocument::browseMaster()
1446 QString const title = qt_("Select master document");
1447 QString const dir1 = toqstr(lyxrc.document_path);
1448 QString const old = latexModule->childDocLE->text();
1449 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1450 QStringList const filter(qt_("LyX Files (*.lyx)"));
1451 QString file = browseRelFile(old, docpath, title, filter, false,
1452 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1454 latexModule->childDocLE->setText(file);
1458 void GuiDocument::classChanged()
1460 int idx = latexModule->classCO->currentIndex();
1463 string const classname = classes_model_.getIDString(idx);
1465 // check whether the selected modules have changed.
1466 bool modules_changed = false;
1467 unsigned int const srows = selectedModel()->rowCount();
1468 if (srows != bp_.getModules().size())
1469 modules_changed = true;
1471 list<string>::const_iterator mit = bp_.getModules().begin();
1472 list<string>::const_iterator men = bp_.getModules().end();
1473 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1474 if (selectedModel()->getIDString(i) != *mit) {
1475 modules_changed = true;
1480 if (modules_changed || lyxrc.auto_reset_options) {
1481 if (applyPB->isEnabled()) {
1482 int const ret = Alert::prompt(_("Unapplied changes"),
1483 _("Some changes in the dialog were not yet applied.\n"
1484 "If you do not apply now, they will be lost after this action."),
1485 1, 1, _("&Apply"), _("&Dismiss"));
1491 // We load the TextClass as soon as it is selected. This is
1492 // necessary so that other options in the dialog can be updated
1493 // according to the new class. Note, however, that, if you use
1494 // the scroll wheel when sitting on the combo box, we'll load a
1495 // lot of TextClass objects very quickly....
1496 if (!bp_.setBaseClass(classname)) {
1497 Alert::error(_("Error"), _("Unable to set document class."));
1500 if (lyxrc.auto_reset_options)
1501 bp_.useClassDefaults();
1503 // With the introduction of modules came a distinction between the base
1504 // class and the document class. The former corresponds to the main layout
1505 // file; the latter is that plus the modules (or the document-specific layout,
1506 // or whatever else there could be). Our parameters come from the document
1507 // class. So when we set the base class, we also need to recreate the document
1508 // class. Otherwise, we still have the old one.
1509 bp_.makeDocumentClass();
1514 void GuiDocument::bibtexChanged(int n)
1516 biblioModule->bibtexOptionsED->setEnabled(n != 0);
1522 // This is an insanely complicated attempt to make this sort of thing
1523 // work with RTL languages.
1524 docstring formatStrVec(vector<string> const & v, docstring const & s)
1526 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1530 return from_utf8(v[0]);
1531 if (v.size() == 2) {
1532 docstring retval = _("%1$s and %2$s");
1533 retval = subst(retval, _("and"), s);
1534 return bformat(retval, from_utf8(v[0]), from_utf8(v[1]));
1536 // The idea here is to format all but the last two items...
1537 int const vSize = v.size();
1538 docstring t2 = _("%1$s, %2$s");
1539 docstring retval = from_utf8(v[0]);
1540 for (int i = 1; i < vSize - 2; ++i)
1541 retval = bformat(t2, retval, from_utf8(v[i]));
1542 //...and then to plug them, and the last two, into this schema
1543 docstring t = _("%1$s, %2$s, and %3$s");
1544 t = subst(t, _("and"), s);
1545 return bformat(t, retval, from_utf8(v[vSize - 2]), from_utf8(v[vSize - 1]));
1548 vector<string> idsToNames(vector<string> const & idList)
1550 vector<string> retval;
1551 vector<string>::const_iterator it = idList.begin();
1552 vector<string>::const_iterator end = idList.end();
1553 for (; it != end; ++it) {
1554 LyXModule const * const mod = moduleList[*it];
1556 retval.push_back(*it + " (Unavailable)");
1558 retval.push_back(mod->getName());
1565 void GuiDocument::modulesToParams(BufferParams & bp)
1567 // update list of loaded modules
1568 bp.clearLayoutModules();
1569 int const srows = modules_sel_model_.rowCount();
1570 for (int i = 0; i < srows; ++i)
1571 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1573 // update the list of removed modules
1574 bp.clearRemovedModules();
1575 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1576 list<string>::const_iterator rit = reqmods.begin();
1577 list<string>::const_iterator ren = reqmods.end();
1579 // check each of the default modules
1580 for (; rit != ren; rit++) {
1581 list<string>::const_iterator mit = bp.getModules().begin();
1582 list<string>::const_iterator men = bp.getModules().end();
1584 for (; mit != men; mit++) {
1591 // the module isn't present so must have been removed by the user
1592 bp.addRemovedModule(*rit);
1597 void GuiDocument::modulesChanged()
1599 modulesToParams(bp_);
1600 bp_.makeDocumentClass();
1605 void GuiDocument::updateModuleInfo()
1607 selectionManager->update();
1609 //Module description
1610 bool const focus_on_selected = selectionManager->selectedFocused();
1611 QListView const * const lv =
1612 focus_on_selected ? modulesModule->selectedLV : modulesModule->availableLV;
1613 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1614 modulesModule->infoML->document()->clear();
1617 QModelIndex const & idx = lv->selectionModel()->currentIndex();
1618 GuiIdListModel const & id_model =
1619 focus_on_selected ? modules_sel_model_ : modules_av_model_;
1620 string const modName = id_model.getIDString(idx.row());
1621 docstring desc = getModuleDescription(modName);
1623 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
1624 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
1627 desc += _("Module provided by document class.");
1630 vector<string> pkglist = getPackageList(modName);
1631 docstring pkgdesc = formatStrVec(pkglist, _("and"));
1632 if (!pkgdesc.empty()) {
1635 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1638 pkglist = getRequiredList(modName);
1639 if (!pkglist.empty()) {
1640 vector<string> const reqdescs = idsToNames(pkglist);
1641 pkgdesc = formatStrVec(reqdescs, _("or"));
1644 desc += bformat(_("Module required: %1$s."), pkgdesc);
1647 pkglist = getExcludedList(modName);
1648 if (!pkglist.empty()) {
1649 vector<string> const reqdescs = idsToNames(pkglist);
1650 pkgdesc = formatStrVec(reqdescs, _( "and"));
1653 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1656 if (!isModuleAvailable(modName)) {
1659 desc += _("WARNING: Some required packages are unavailable!");
1662 modulesModule->infoML->document()->setPlainText(toqstr(desc));
1666 void GuiDocument::updateNumbering()
1668 DocumentClass const & tclass = documentClass();
1670 numberingModule->tocTW->setUpdatesEnabled(false);
1671 numberingModule->tocTW->clear();
1673 int const depth = numberingModule->depthSL->value();
1674 int const toc = numberingModule->tocSL->value();
1675 QString const no = qt_("No");
1676 QString const yes = qt_("Yes");
1677 QTreeWidgetItem * item = 0;
1679 DocumentClass::const_iterator lit = tclass.begin();
1680 DocumentClass::const_iterator len = tclass.end();
1681 for (; lit != len; ++lit) {
1682 int const toclevel = lit->toclevel;
1683 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1684 item = new QTreeWidgetItem(numberingModule->tocTW);
1685 item->setText(0, toqstr(translateIfPossible(lit->name())));
1686 item->setText(1, (toclevel <= depth) ? yes : no);
1687 item->setText(2, (toclevel <= toc) ? yes : no);
1691 numberingModule->tocTW->setUpdatesEnabled(true);
1692 numberingModule->tocTW->update();
1696 void GuiDocument::updateDefaultFormat()
1698 // make a copy in order to consider unapplied changes
1699 Buffer * tmpbuf = const_cast<Buffer *>(&buffer());
1700 tmpbuf->params().useXetex = outputModule->xetexCB->isChecked();
1701 int idx = latexModule->classCO->currentIndex();
1703 string const classname = classes_model_.getIDString(idx);
1704 tmpbuf->params().setBaseClass(classname);
1705 tmpbuf->params().makeDocumentClass();
1707 outputModule->defaultFormatCO->blockSignals(true);
1708 outputModule->defaultFormatCO->clear();
1709 outputModule->defaultFormatCO->addItem(qt_("Default"),
1710 QVariant(QString("default")));
1711 typedef vector<Format const *> Formats;
1712 Formats formats = tmpbuf->exportableFormats(true);
1713 Formats::const_iterator cit = formats.begin();
1714 Formats::const_iterator end = formats.end();
1715 for (; cit != end; ++cit)
1716 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
1717 QVariant(toqstr((*cit)->name())));
1718 outputModule->defaultFormatCO->blockSignals(false);
1722 void GuiDocument::applyView()
1725 preambleModule->apply(bp_);
1728 bp_.setCiteEngine(ENGINE_BASIC);
1730 if (biblioModule->citeNatbibRB->isChecked()) {
1731 bool const use_numerical_citations =
1732 biblioModule->citeStyleCO->currentIndex();
1733 if (use_numerical_citations)
1734 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
1736 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
1738 } else if (biblioModule->citeJurabibRB->isChecked())
1739 bp_.setCiteEngine(ENGINE_JURABIB);
1742 biblioModule->bibtopicCB->isChecked();
1744 string const bibtex_command =
1745 fromqstr(biblioModule->bibtexCO->itemData(
1746 biblioModule->bibtexCO->currentIndex()).toString());
1747 string const bibtex_options =
1748 fromqstr(biblioModule->bibtexOptionsED->text());
1749 if (bibtex_command == "default" || bibtex_options.empty())
1750 bp_.bibtex_command = bibtex_command;
1752 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
1755 indicesModule->apply(bp_);
1757 // language & quotes
1758 if (langModule->defaultencodingRB->isChecked()) {
1759 bp_.inputenc = "auto";
1761 int i = langModule->encodingCO->currentIndex();
1763 bp_.inputenc = "default";
1765 QString const enc_gui =
1766 langModule->encodingCO->currentText();
1767 Encodings::const_iterator it = encodings.begin();
1768 Encodings::const_iterator const end = encodings.end();
1770 for (; it != end; ++it) {
1771 if (qt_(it->guiName()) == enc_gui) {
1772 bp_.inputenc = it->latexName();
1778 // should not happen
1779 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
1780 bp_.inputenc = "default";
1785 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1786 switch (langModule->quoteStyleCO->currentIndex()) {
1788 lga = InsetQuotes::EnglishQuotes;
1791 lga = InsetQuotes::SwedishQuotes;
1794 lga = InsetQuotes::GermanQuotes;
1797 lga = InsetQuotes::PolishQuotes;
1800 lga = InsetQuotes::FrenchQuotes;
1803 lga = InsetQuotes::DanishQuotes;
1806 bp_.quotes_language = lga;
1808 QString const lang = langModule->languageCO->itemData(
1809 langModule->languageCO->currentIndex()).toString();
1810 bp_.language = languages.getLanguage(fromqstr(lang));
1813 if (bp_.documentClass().hasTocLevels()) {
1814 bp_.tocdepth = numberingModule->tocSL->value();
1815 bp_.secnumdepth = numberingModule->depthSL->value();
1819 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
1820 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
1821 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
1822 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
1825 bp_.graphicsDriver =
1826 tex_graphics[latexModule->psdriverCO->currentIndex()];
1829 int idx = latexModule->classCO->currentIndex();
1831 string const classname = classes_model_.getIDString(idx);
1832 bp_.setBaseClass(classname);
1836 modulesToParams(bp_);
1838 if (mathsModule->amsautoCB->isChecked()) {
1839 bp_.use_amsmath = BufferParams::package_auto;
1841 if (mathsModule->amsCB->isChecked())
1842 bp_.use_amsmath = BufferParams::package_on;
1844 bp_.use_amsmath = BufferParams::package_off;
1847 if (mathsModule->esintautoCB->isChecked())
1848 bp_.use_esint = BufferParams::package_auto;
1850 if (mathsModule->esintCB->isChecked())
1851 bp_.use_esint = BufferParams::package_on;
1853 bp_.use_esint = BufferParams::package_off;
1856 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1857 bp_.pagestyle = "default";
1859 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
1860 for (size_t i = 0; i != pagestyles.size(); ++i)
1861 if (pagestyles[i].second == style_gui)
1862 bp_.pagestyle = pagestyles[i].first;
1865 switch (textLayoutModule->lspacingCO->currentIndex()) {
1867 bp_.spacing().set(Spacing::Single);
1870 bp_.spacing().set(Spacing::Onehalf);
1873 bp_.spacing().set(Spacing::Double);
1876 bp_.spacing().set(Spacing::Other,
1877 fromqstr(textLayoutModule->lspacingLE->text()));
1881 if (textLayoutModule->twoColumnCB->isChecked())
1886 // text should have passed validation
1887 bp_.listings_params =
1888 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1890 if (textLayoutModule->indentRB->isChecked())
1891 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
1893 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
1895 switch (textLayoutModule->skipCO->currentIndex()) {
1897 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
1900 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1903 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
1908 widgetsToLength(textLayoutModule->skipLE,
1909 textLayoutModule->skipLengthCO)
1915 // DocumentDefskipCB assures that this never happens
1916 // so Assert then !!! - jbl
1917 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1922 fromqstr(latexModule->optionsLE->text());
1924 bp_.use_default_options =
1925 latexModule->defaultOptionsCB->isChecked();
1927 if (latexModule->childDocGB->isChecked())
1929 fromqstr(latexModule->childDocLE->text());
1931 bp_.master = string();
1933 bp_.float_placement = floatModule->get();
1936 bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
1937 outputModule->defaultFormatCO->currentIndex()).toString());
1939 bool const xetex = outputModule->xetexCB->isChecked();
1940 bp_.useXetex = xetex;
1944 if (fontModule->fontsRomanCO->currentIndex() == 0)
1945 bp_.fontsRoman = "default";
1948 fromqstr(fontModule->fontsRomanCO->currentText());
1950 if (fontModule->fontsSansCO->currentIndex() == 0)
1951 bp_.fontsSans = "default";
1954 fromqstr(fontModule->fontsSansCO->currentText());
1956 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
1957 bp_.fontsTypewriter = "default";
1959 bp_.fontsTypewriter =
1960 fromqstr(fontModule->fontsTypewriterCO->currentText());
1963 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1966 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1968 bp_.fontsTypewriter =
1969 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1973 fromqstr(fontModule->cjkFontLE->text());
1975 bp_.fontsSansScale = fontModule->scaleSansSB->value();
1977 bp_.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1979 bp_.fontsSC = fontModule->fontScCB->isChecked();
1981 bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
1984 bp_.fontsDefaultFamily = "default";
1986 bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
1987 fontModule->fontsDefaultCO->currentIndex()];
1989 if (fontModule->fontsizeCO->currentIndex() == 0)
1990 bp_.fontsize = "default";
1993 fromqstr(fontModule->fontsizeCO->currentText());
1996 bp_.papersize = PAPER_SIZE(
1997 pageLayoutModule->papersizeCO->currentIndex());
1999 // custom, A3, B3 and B4 paper sizes need geometry
2000 int psize = pageLayoutModule->papersizeCO->currentIndex();
2001 bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
2003 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2004 pageLayoutModule->paperwidthUnitCO);
2006 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2007 pageLayoutModule->paperheightUnitCO);
2009 if (pageLayoutModule->facingPagesCB->isChecked())
2010 bp_.sides = TwoSides;
2012 bp_.sides = OneSide;
2014 if (pageLayoutModule->landscapeRB->isChecked())
2015 bp_.orientation = ORIENTATION_LANDSCAPE;
2017 bp_.orientation = ORIENTATION_PORTRAIT;
2019 bp_.backgroundcolor = set_backgroundcolor;
2022 bp_.use_geometry = !marginsModule->marginCB->isChecked()
2025 Ui::MarginsUi const * m = marginsModule;
2027 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2028 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2029 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2030 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2031 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2032 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2033 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2034 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2036 branchesModule->apply(bp_);
2039 PDFOptions & pdf = bp_.pdfoptions();
2040 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2041 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2042 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2043 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2044 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2046 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2047 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2048 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2049 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2051 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2052 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2053 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2054 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2056 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2057 if (pdfSupportModule->fullscreenCB->isChecked())
2058 pdf.pagemode = pdf.pagemode_fullscreen;
2060 pdf.pagemode.clear();
2061 pdf.quoted_options = pdf.quoted_options_check(
2062 fromqstr(pdfSupportModule->optionsLE->text()));
2066 void GuiDocument::paramsToDialog()
2068 // set the default unit
2069 Length::UNIT const defaultUnit = Length::defaultUnit();
2072 preambleModule->update(bp_, id());
2075 biblioModule->citeDefaultRB->setChecked(
2076 bp_.citeEngine() == ENGINE_BASIC);
2078 biblioModule->citeNatbibRB->setChecked(
2079 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2080 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2082 biblioModule->citeStyleCO->setCurrentIndex(
2083 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2085 biblioModule->citeJurabibRB->setChecked(
2086 bp_.citeEngine() == ENGINE_JURABIB);
2088 biblioModule->bibtopicCB->setChecked(
2093 split(bp_.bibtex_command, command, ' ');
2095 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2097 biblioModule->bibtexCO->setCurrentIndex(bpos);
2098 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2100 biblioModule->bibtexCO->setCurrentIndex(0);
2101 biblioModule->bibtexOptionsED->clear();
2103 biblioModule->bibtexOptionsED->setEnabled(
2104 biblioModule->bibtexCO->currentIndex() != 0);
2107 indicesModule->update(bp_);
2109 // language & quotes
2110 int const pos = langModule->languageCO->findData(toqstr(
2111 bp_.language->lang()));
2112 langModule->languageCO->setCurrentIndex(pos);
2114 langModule->quoteStyleCO->setCurrentIndex(
2115 bp_.quotes_language);
2117 bool default_enc = true;
2118 if (bp_.inputenc != "auto") {
2119 default_enc = false;
2120 if (bp_.inputenc == "default") {
2121 langModule->encodingCO->setCurrentIndex(0);
2124 Encodings::const_iterator it = encodings.begin();
2125 Encodings::const_iterator const end = encodings.end();
2126 for (; it != end; ++it) {
2127 if (it->latexName() == bp_.inputenc) {
2128 enc_gui = it->guiName();
2132 int const i = langModule->encodingCO->findText(
2135 langModule->encodingCO->setCurrentIndex(i);
2137 // unknown encoding. Set to default.
2141 langModule->defaultencodingRB->setChecked(default_enc);
2142 langModule->otherencodingRB->setChecked(!default_enc);
2145 int const min_toclevel = documentClass().min_toclevel();
2146 int const max_toclevel = documentClass().max_toclevel();
2147 if (documentClass().hasTocLevels()) {
2148 numberingModule->setEnabled(true);
2149 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2150 numberingModule->depthSL->setMaximum(max_toclevel);
2151 numberingModule->depthSL->setValue(bp_.secnumdepth);
2152 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2153 numberingModule->tocSL->setMaximum(max_toclevel);
2154 numberingModule->tocSL->setValue(bp_.tocdepth);
2157 numberingModule->setEnabled(false);
2158 numberingModule->tocTW->clear();
2162 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2163 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2164 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2165 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2166 bulletsModule->init();
2169 int nitem = findToken(tex_graphics, bp_.graphicsDriver);
2171 latexModule->psdriverCO->setCurrentIndex(nitem);
2174 mathsModule->amsCB->setChecked(
2175 bp_.use_amsmath == BufferParams::package_on);
2176 mathsModule->amsautoCB->setChecked(
2177 bp_.use_amsmath == BufferParams::package_auto);
2179 mathsModule->esintCB->setChecked(
2180 bp_.use_esint == BufferParams::package_on);
2181 mathsModule->esintautoCB->setChecked(
2182 bp_.use_esint == BufferParams::package_auto);
2184 switch (bp_.spacing().getSpace()) {
2185 case Spacing::Other: nitem = 3; break;
2186 case Spacing::Double: nitem = 2; break;
2187 case Spacing::Onehalf: nitem = 1; break;
2188 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2192 string const & layoutID = bp_.baseClassID();
2193 setLayoutComboByIDString(layoutID);
2195 updatePagestyle(documentClass().opt_pagestyle(),
2198 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2199 if (bp_.spacing().getSpace() == Spacing::Other) {
2200 textLayoutModule->lspacingLE->setText(
2201 toqstr(bp_.spacing().getValueAsString()));
2205 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation)
2206 textLayoutModule->indentRB->setChecked(true);
2208 textLayoutModule->skipRB->setChecked(true);
2211 switch (bp_.getDefSkip().kind()) {
2212 case VSpace::SMALLSKIP:
2215 case VSpace::MEDSKIP:
2218 case VSpace::BIGSKIP:
2221 case VSpace::LENGTH:
2224 string const length = bp_.getDefSkip().asLyXCommand();
2225 lengthToWidgets(textLayoutModule->skipLE,
2226 textLayoutModule->skipLengthCO,
2227 length, defaultUnit);
2234 textLayoutModule->skipCO->setCurrentIndex(skip);
2237 textLayoutModule->twoColumnCB->setChecked(
2240 // break listings_params to multiple lines
2242 InsetListingsParams(bp_.listings_params).separatedParams();
2243 textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
2245 if (!bp_.options.empty()) {
2246 latexModule->optionsLE->setText(
2247 toqstr(bp_.options));
2249 latexModule->optionsLE->setText(QString());
2253 latexModule->defaultOptionsCB->setChecked(
2254 bp_.use_default_options);
2255 updateSelectedModules();
2256 selectionManager->updateProvidedModules(
2257 bp_.baseClass()->providedModules());
2258 selectionManager->updateExcludedModules(
2259 bp_.baseClass()->excludedModules());
2261 if (!documentClass().options().empty()) {
2262 latexModule->defaultOptionsLE->setText(
2263 toqstr(documentClass().options()));
2265 latexModule->defaultOptionsLE->setText(
2266 toqstr(_("[No options predefined]")));
2269 latexModule->defaultOptionsLE->setEnabled(
2270 bp_.use_default_options
2271 && !documentClass().options().empty());
2273 latexModule->defaultOptionsCB->setEnabled(
2274 !documentClass().options().empty());
2276 if (!bp_.master.empty()) {
2277 latexModule->childDocGB->setChecked(true);
2278 latexModule->childDocLE->setText(
2279 toqstr(bp_.master));
2281 latexModule->childDocLE->setText(QString());
2282 latexModule->childDocGB->setChecked(false);
2285 floatModule->set(bp_.float_placement);
2288 // update combobox with formats
2289 updateDefaultFormat();
2290 int index = outputModule->defaultFormatCO->findData(toqstr(
2291 bp_.defaultOutputFormat));
2292 // set to default if format is not found
2295 outputModule->defaultFormatCO->setCurrentIndex(index);
2296 outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2297 outputModule->xetexCB->setChecked(
2298 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2301 updateFontsize(documentClass().opt_fontsize(),
2305 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2306 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2307 fontModule->fontsRomanCO->setCurrentIndex(i);
2312 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2313 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2314 fontModule->fontsSansCO->setCurrentIndex(i);
2318 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2319 if (fontModule->fontsTypewriterCO->itemText(i) ==
2320 toqstr(bp_.fontsTypewriter)) {
2321 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2326 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2328 fontModule->fontsRomanCO->setCurrentIndex(n);
2332 n = findToken(tex_fonts_sans, bp_.fontsSans);
2334 fontModule->fontsSansCO->setCurrentIndex(n);
2338 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2340 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2345 if (!bp_.fontsCJK.empty())
2346 fontModule->cjkFontLE->setText(
2347 toqstr(bp_.fontsCJK));
2349 fontModule->cjkFontLE->setText(QString());
2351 fontModule->fontScCB->setChecked(bp_.fontsSC);
2352 fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2353 fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2354 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2356 int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2358 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2361 bool const extern_geometry =
2362 documentClass().provides("geometry");
2363 int const psize = bp_.papersize;
2364 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2365 setCustomPapersize(!extern_geometry && psize);
2366 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2368 bool const landscape =
2369 bp_.orientation == ORIENTATION_LANDSCAPE;
2370 pageLayoutModule->landscapeRB->setChecked(landscape);
2371 pageLayoutModule->portraitRB->setChecked(!landscape);
2372 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2373 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2375 pageLayoutModule->facingPagesCB->setChecked(
2376 bp_.sides == TwoSides);
2378 pageLayoutModule->backgroundPB->setStyleSheet(
2379 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2380 set_backgroundcolor = bp_.backgroundcolor;
2382 lengthToWidgets(pageLayoutModule->paperwidthLE,
2383 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2384 lengthToWidgets(pageLayoutModule->paperheightLE,
2385 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2388 Ui::MarginsUi * m = marginsModule;
2390 setMargins(!bp_.use_geometry);
2392 lengthToWidgets(m->topLE, m->topUnit,
2393 bp_.topmargin, defaultUnit);
2395 lengthToWidgets(m->bottomLE, m->bottomUnit,
2396 bp_.bottommargin, defaultUnit);
2398 lengthToWidgets(m->innerLE, m->innerUnit,
2399 bp_.leftmargin, defaultUnit);
2401 lengthToWidgets(m->outerLE, m->outerUnit,
2402 bp_.rightmargin, defaultUnit);
2404 lengthToWidgets(m->headheightLE, m->headheightUnit,
2405 bp_.headheight, defaultUnit);
2407 lengthToWidgets(m->headsepLE, m->headsepUnit,
2408 bp_.headsep, defaultUnit);
2410 lengthToWidgets(m->footskipLE, m->footskipUnit,
2411 bp_.footskip, defaultUnit);
2413 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2414 bp_.columnsep, defaultUnit);
2416 branchesModule->update(bp_);
2419 PDFOptions const & pdf = bp_.pdfoptions();
2420 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2421 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2422 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2423 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2424 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2426 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2427 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2428 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2430 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2432 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2433 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2434 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2435 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2437 nn = findToken(backref_opts, pdf.backref);
2439 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2441 pdfSupportModule->fullscreenCB->setChecked
2442 (pdf.pagemode == pdf.pagemode_fullscreen);
2444 pdfSupportModule->optionsLE->setText(
2445 toqstr(pdf.quoted_options));
2447 // Make sure that the bc is in the INITIAL state
2448 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2453 void GuiDocument::saveDocDefault()
2455 // we have to apply the params first
2461 void GuiDocument::updateAvailableModules()
2463 modules_av_model_.clear();
2464 list<modInfoStruct> const & modInfoList = getModuleInfo();
2465 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2466 list<modInfoStruct>::const_iterator men = modInfoList.end();
2467 for (int i = 0; mit != men; ++mit, ++i)
2468 modules_av_model_.insertRow(i, mit->name, mit->id,
2473 void GuiDocument::updateSelectedModules()
2475 modules_sel_model_.clear();
2476 list<modInfoStruct> const selModList = getSelectedModules();
2477 list<modInfoStruct>::const_iterator mit = selModList.begin();
2478 list<modInfoStruct>::const_iterator men = selModList.end();
2479 for (int i = 0; mit != men; ++mit, ++i)
2480 modules_sel_model_.insertRow(i, mit->name, mit->id,
2485 void GuiDocument::updateContents()
2487 // Nothing to do here as the document settings is not cursor dependant.
2492 void GuiDocument::useClassDefaults()
2494 if (applyPB->isEnabled()) {
2495 int const ret = Alert::prompt(_("Unapplied changes"),
2496 _("Some changes in the dialog were not yet applied.\n"
2497 "If you do not apply now, they will be lost after this action."),
2498 1, 1, _("&Apply"), _("&Dismiss"));
2503 int idx = latexModule->classCO->currentIndex();
2504 string const classname = classes_model_.getIDString(idx);
2505 if (!bp_.setBaseClass(classname)) {
2506 Alert::error(_("Error"), _("Unable to set document class."));
2509 bp_.useClassDefaults();
2514 void GuiDocument::setLayoutComboByIDString(string const & idString)
2516 int idx = classes_model_.findIDString(idString);
2518 Alert::warning(_("Can't set layout!"),
2519 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2521 latexModule->classCO->setCurrentIndex(idx);
2525 bool GuiDocument::isValid()
2527 return validateListingsParameters().isEmpty()
2528 && (textLayoutModule->skipCO->currentIndex() != 3
2529 || !textLayoutModule->skipLE->text().isEmpty());
2533 char const * const GuiDocument::fontfamilies[5] = {
2534 "default", "rmdefault", "sfdefault", "ttdefault", ""
2538 char const * GuiDocument::fontfamilies_gui[5] = {
2539 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2543 bool GuiDocument::initialiseParams(string const &)
2545 BufferView const * view = bufferview();
2547 bp_ = BufferParams();
2551 bp_ = view->buffer().params();
2553 updateAvailableModules();
2554 //FIXME It'd be nice to make sure here that the selected
2555 //modules are consistent: That required modules are actually
2556 //selected, and that we don't have conflicts. If so, we could
2557 //at least pop up a warning.
2563 void GuiDocument::clearParams()
2565 bp_ = BufferParams();
2569 BufferId GuiDocument::id() const
2571 BufferView const * const view = bufferview();
2572 return view? &view->buffer() : 0;
2576 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2578 return moduleNames_;
2582 list<GuiDocument::modInfoStruct> const
2583 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2585 LayoutModuleList::const_iterator it = mods.begin();
2586 LayoutModuleList::const_iterator end = mods.end();
2587 list<modInfoStruct> mInfo;
2588 for (; it != end; ++it) {
2591 LyXModule * mod = moduleList[*it];
2594 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2596 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2603 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2605 return makeModuleInfo(params().getModules());
2609 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2611 return makeModuleInfo(params().baseClass()->providedModules());
2615 DocumentClass const & GuiDocument::documentClass() const
2617 return bp_.documentClass();
2621 static void dispatch_bufferparams(Dialog const & dialog,
2622 BufferParams const & bp, FuncCode lfun)
2625 ss << "\\begin_header\n";
2627 ss << "\\end_header\n";
2628 dialog.dispatch(FuncRequest(lfun, ss.str()));
2632 void GuiDocument::dispatchParams()
2634 // This must come first so that a language change is correctly noticed
2637 // Apply the BufferParams. Note that this will set the base class
2638 // and then update the buffer's layout.
2639 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2641 if (!params().master.empty()) {
2642 FileName const master_file = support::makeAbsPath(params().master,
2643 support::onlyPath(buffer().absFileName()));
2644 if (isLyXFilename(master_file.absFilename())) {
2645 Buffer * master = checkAndLoadLyXFile(master_file);
2647 if (master->isChild(const_cast<Buffer *>(&buffer())))
2648 const_cast<Buffer &>(buffer()).setParent(master);
2650 Alert::warning(_("Assigned master does not include this file"),
2651 bformat(_("You must include this file in the document\n"
2652 "'%1$s' in order to use the master document\n"
2653 "feature."), from_utf8(params().master)));
2655 Alert::warning(_("Could not load master"),
2656 bformat(_("The master document '%1$s'\n"
2657 "could not be loaded."),
2658 from_utf8(params().master)));
2662 // Generate the colours requested by each new branch.
2663 BranchList & branchlist = params().branchlist();
2664 if (!branchlist.empty()) {
2665 BranchList::const_iterator it = branchlist.begin();
2666 BranchList::const_iterator const end = branchlist.end();
2667 for (; it != end; ++it) {
2668 docstring const & current_branch = it->branch();
2669 Branch const * branch = branchlist.find(current_branch);
2670 string const x11hexname = X11hexname(branch->color());
2671 // display the new color
2672 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2673 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2676 // Open insets of selected branches, close deselected ones
2677 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2680 // Generate the colours requested by indices.
2681 IndicesList & indiceslist = params().indiceslist();
2682 if (!indiceslist.empty()) {
2683 IndicesList::const_iterator it = indiceslist.begin();
2684 IndicesList::const_iterator const end = indiceslist.end();
2685 for (; it != end; ++it) {
2686 docstring const & current_index = it->index();
2687 Index const * index = indiceslist.find(current_index);
2688 string const x11hexname = X11hexname(index->color());
2689 // display the new color
2690 docstring const str = current_index + ' ' + from_ascii(x11hexname);
2691 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2694 // FIXME: If we used an LFUN, we would not need those two lines:
2695 BufferView * bv = const_cast<BufferView *>(bufferview());
2696 bv->processUpdateFlags(Update::Force | Update::FitCursor);
2700 void GuiDocument::setLanguage() const
2702 Language const * const newL = bp_.language;
2703 if (buffer().params().language == newL)
2706 string const & lang_name = newL->lang();
2707 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2711 void GuiDocument::saveAsDefault() const
2713 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2717 bool GuiDocument::isFontAvailable(string const & font) const
2719 if (font == "default" || font == "cmr"
2720 || font == "cmss" || font == "cmtt")
2721 // these are standard
2723 if (font == "lmodern" || font == "lmss" || font == "lmtt")
2724 return LaTeXFeatures::isAvailable("lmodern");
2725 if (font == "times" || font == "palatino"
2726 || font == "helvet" || font == "courier")
2727 return LaTeXFeatures::isAvailable("psnfss");
2728 if (font == "cmbr" || font == "cmtl")
2729 return LaTeXFeatures::isAvailable("cmbright");
2730 if (font == "utopia")
2731 return LaTeXFeatures::isAvailable("utopia")
2732 || LaTeXFeatures::isAvailable("fourier");
2733 if (font == "beraserif" || font == "berasans"
2734 || font == "beramono")
2735 return LaTeXFeatures::isAvailable("bera");
2736 return LaTeXFeatures::isAvailable(font);
2740 bool GuiDocument::providesOSF(string const & font) const
2742 if (outputModule->xetexCB->isChecked())
2743 // FIXME: we should check if the fonts really
2744 // have OSF support. But how?
2747 return isFontAvailable("eco");
2748 if (font == "palatino")
2749 return isFontAvailable("mathpazo");
2754 bool GuiDocument::providesSC(string const & font) const
2756 if (outputModule->xetexCB->isChecked())
2758 if (font == "palatino")
2759 return isFontAvailable("mathpazo");
2760 if (font == "utopia")
2761 return isFontAvailable("fourier");
2766 bool GuiDocument::providesScale(string const & font) const
2768 if (outputModule->xetexCB->isChecked())
2770 return font == "helvet" || font == "luximono"
2771 || font == "berasans" || font == "beramono";
2775 void GuiDocument::loadModuleInfo()
2777 moduleNames_.clear();
2778 LyXModuleList::const_iterator it = moduleList.begin();
2779 LyXModuleList::const_iterator end = moduleList.end();
2780 for (; it != end; ++it) {
2784 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
2785 // this is supposed to give us the first sentence of the description
2788 toqstr(translateIfPossible(from_utf8(it->getDescription())));
2789 int const pos = desc.indexOf(".");
2791 desc.truncate(pos + 1);
2792 m.description = desc;
2793 moduleNames_.push_back(m);
2798 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2801 } // namespace frontend
2804 #include "moc_GuiDocument.cpp"