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 (vector<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 if (bibtex_command == "default")
1748 bp_.bibtex_command = bibtex_command;
1750 bp_.bibtex_command = bibtex_command + " "
1751 + fromqstr(biblioModule->bibtexOptionsED->text());
1754 indicesModule->apply(bp_);
1756 // language & quotes
1757 if (langModule->defaultencodingRB->isChecked()) {
1758 bp_.inputenc = "auto";
1760 int i = langModule->encodingCO->currentIndex();
1762 bp_.inputenc = "default";
1764 QString const enc_gui =
1765 langModule->encodingCO->currentText();
1766 Encodings::const_iterator it = encodings.begin();
1767 Encodings::const_iterator const end = encodings.end();
1769 for (; it != end; ++it) {
1770 if (qt_(it->guiName()) == enc_gui) {
1771 bp_.inputenc = it->latexName();
1777 // should not happen
1778 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
1779 bp_.inputenc = "default";
1784 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1785 switch (langModule->quoteStyleCO->currentIndex()) {
1787 lga = InsetQuotes::EnglishQuotes;
1790 lga = InsetQuotes::SwedishQuotes;
1793 lga = InsetQuotes::GermanQuotes;
1796 lga = InsetQuotes::PolishQuotes;
1799 lga = InsetQuotes::FrenchQuotes;
1802 lga = InsetQuotes::DanishQuotes;
1805 bp_.quotes_language = lga;
1807 QString const lang = langModule->languageCO->itemData(
1808 langModule->languageCO->currentIndex()).toString();
1809 bp_.language = languages.getLanguage(fromqstr(lang));
1812 if (bp_.documentClass().hasTocLevels()) {
1813 bp_.tocdepth = numberingModule->tocSL->value();
1814 bp_.secnumdepth = numberingModule->depthSL->value();
1818 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
1819 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
1820 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
1821 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
1824 bp_.graphicsDriver =
1825 tex_graphics[latexModule->psdriverCO->currentIndex()];
1828 int idx = latexModule->classCO->currentIndex();
1830 string const classname = classes_model_.getIDString(idx);
1831 bp_.setBaseClass(classname);
1835 modulesToParams(bp_);
1837 if (mathsModule->amsautoCB->isChecked()) {
1838 bp_.use_amsmath = BufferParams::package_auto;
1840 if (mathsModule->amsCB->isChecked())
1841 bp_.use_amsmath = BufferParams::package_on;
1843 bp_.use_amsmath = BufferParams::package_off;
1846 if (mathsModule->esintautoCB->isChecked())
1847 bp_.use_esint = BufferParams::package_auto;
1849 if (mathsModule->esintCB->isChecked())
1850 bp_.use_esint = BufferParams::package_on;
1852 bp_.use_esint = BufferParams::package_off;
1855 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1856 bp_.pagestyle = "default";
1858 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
1859 for (size_t i = 0; i != pagestyles.size(); ++i)
1860 if (pagestyles[i].second == style_gui)
1861 bp_.pagestyle = pagestyles[i].first;
1864 switch (textLayoutModule->lspacingCO->currentIndex()) {
1866 bp_.spacing().set(Spacing::Single);
1869 bp_.spacing().set(Spacing::Onehalf);
1872 bp_.spacing().set(Spacing::Double);
1875 bp_.spacing().set(Spacing::Other,
1876 fromqstr(textLayoutModule->lspacingLE->text()));
1880 if (textLayoutModule->twoColumnCB->isChecked())
1885 // text should have passed validation
1886 bp_.listings_params =
1887 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1889 if (textLayoutModule->indentRB->isChecked())
1890 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
1892 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
1894 switch (textLayoutModule->skipCO->currentIndex()) {
1896 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
1899 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1902 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
1907 widgetsToLength(textLayoutModule->skipLE,
1908 textLayoutModule->skipLengthCO)
1914 // DocumentDefskipCB assures that this never happens
1915 // so Assert then !!! - jbl
1916 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1921 fromqstr(latexModule->optionsLE->text());
1923 bp_.use_default_options =
1924 latexModule->defaultOptionsCB->isChecked();
1926 if (latexModule->childDocGB->isChecked())
1928 fromqstr(latexModule->childDocLE->text());
1930 bp_.master = string();
1932 bp_.float_placement = floatModule->get();
1935 bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
1936 outputModule->defaultFormatCO->currentIndex()).toString());
1938 bool const xetex = outputModule->xetexCB->isChecked();
1939 bp_.useXetex = xetex;
1943 if (fontModule->fontsRomanCO->currentIndex() == 0)
1944 bp_.fontsRoman = "default";
1947 fromqstr(fontModule->fontsRomanCO->currentText());
1949 if (fontModule->fontsSansCO->currentIndex() == 0)
1950 bp_.fontsSans = "default";
1953 fromqstr(fontModule->fontsSansCO->currentText());
1955 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
1956 bp_.fontsTypewriter = "default";
1958 bp_.fontsTypewriter =
1959 fromqstr(fontModule->fontsTypewriterCO->currentText());
1962 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1965 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1967 bp_.fontsTypewriter =
1968 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1972 fromqstr(fontModule->cjkFontLE->text());
1974 bp_.fontsSansScale = fontModule->scaleSansSB->value();
1976 bp_.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1978 bp_.fontsSC = fontModule->fontScCB->isChecked();
1980 bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
1983 bp_.fontsDefaultFamily = "default";
1985 bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
1986 fontModule->fontsDefaultCO->currentIndex()];
1988 if (fontModule->fontsizeCO->currentIndex() == 0)
1989 bp_.fontsize = "default";
1992 fromqstr(fontModule->fontsizeCO->currentText());
1995 bp_.papersize = PAPER_SIZE(
1996 pageLayoutModule->papersizeCO->currentIndex());
1998 // custom, A3, B3 and B4 paper sizes need geometry
1999 int psize = pageLayoutModule->papersizeCO->currentIndex();
2000 bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
2002 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2003 pageLayoutModule->paperwidthUnitCO);
2005 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2006 pageLayoutModule->paperheightUnitCO);
2008 if (pageLayoutModule->facingPagesCB->isChecked())
2009 bp_.sides = TwoSides;
2011 bp_.sides = OneSide;
2013 if (pageLayoutModule->landscapeRB->isChecked())
2014 bp_.orientation = ORIENTATION_LANDSCAPE;
2016 bp_.orientation = ORIENTATION_PORTRAIT;
2018 bp_.backgroundcolor = set_backgroundcolor;
2021 bp_.use_geometry = !marginsModule->marginCB->isChecked()
2024 Ui::MarginsUi const * m = marginsModule;
2026 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2027 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2028 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2029 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2030 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2031 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2032 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2033 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2035 branchesModule->apply(bp_);
2038 PDFOptions & pdf = bp_.pdfoptions();
2039 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2040 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2041 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2042 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2043 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2045 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2046 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2047 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2048 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2050 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2051 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2052 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2053 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2055 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2056 if (pdfSupportModule->fullscreenCB->isChecked())
2057 pdf.pagemode = pdf.pagemode_fullscreen;
2059 pdf.pagemode.clear();
2060 pdf.quoted_options = pdf.quoted_options_check(
2061 fromqstr(pdfSupportModule->optionsLE->text()));
2065 void GuiDocument::paramsToDialog()
2067 // set the default unit
2068 Length::UNIT const defaultUnit = Length::defaultUnit();
2071 preambleModule->update(bp_, id());
2074 biblioModule->citeDefaultRB->setChecked(
2075 bp_.citeEngine() == ENGINE_BASIC);
2077 biblioModule->citeNatbibRB->setChecked(
2078 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2079 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2081 biblioModule->citeStyleCO->setCurrentIndex(
2082 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2084 biblioModule->citeJurabibRB->setChecked(
2085 bp_.citeEngine() == ENGINE_JURABIB);
2087 biblioModule->bibtopicCB->setChecked(
2092 split(bp_.bibtex_command, command, ' ');
2094 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2096 biblioModule->bibtexCO->setCurrentIndex(bpos);
2097 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2099 biblioModule->bibtexCO->setCurrentIndex(0);
2100 biblioModule->bibtexOptionsED->clear();
2102 biblioModule->bibtexOptionsED->setEnabled(
2103 biblioModule->bibtexCO->currentIndex() != 0);
2106 indicesModule->update(bp_);
2108 // language & quotes
2109 int const pos = langModule->languageCO->findData(toqstr(
2110 bp_.language->lang()));
2111 langModule->languageCO->setCurrentIndex(pos);
2113 langModule->quoteStyleCO->setCurrentIndex(
2114 bp_.quotes_language);
2116 bool default_enc = true;
2117 if (bp_.inputenc != "auto") {
2118 default_enc = false;
2119 if (bp_.inputenc == "default") {
2120 langModule->encodingCO->setCurrentIndex(0);
2123 Encodings::const_iterator it = encodings.begin();
2124 Encodings::const_iterator const end = encodings.end();
2125 for (; it != end; ++it) {
2126 if (it->latexName() == bp_.inputenc) {
2127 enc_gui = it->guiName();
2131 int const i = langModule->encodingCO->findText(
2134 langModule->encodingCO->setCurrentIndex(i);
2136 // unknown encoding. Set to default.
2140 langModule->defaultencodingRB->setChecked(default_enc);
2141 langModule->otherencodingRB->setChecked(!default_enc);
2144 int const min_toclevel = documentClass().min_toclevel();
2145 int const max_toclevel = documentClass().max_toclevel();
2146 if (documentClass().hasTocLevels()) {
2147 numberingModule->setEnabled(true);
2148 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2149 numberingModule->depthSL->setMaximum(max_toclevel);
2150 numberingModule->depthSL->setValue(bp_.secnumdepth);
2151 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2152 numberingModule->tocSL->setMaximum(max_toclevel);
2153 numberingModule->tocSL->setValue(bp_.tocdepth);
2156 numberingModule->setEnabled(false);
2157 numberingModule->tocTW->clear();
2161 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2162 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2163 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2164 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2165 bulletsModule->init();
2168 int nitem = findToken(tex_graphics, bp_.graphicsDriver);
2170 latexModule->psdriverCO->setCurrentIndex(nitem);
2173 mathsModule->amsCB->setChecked(
2174 bp_.use_amsmath == BufferParams::package_on);
2175 mathsModule->amsautoCB->setChecked(
2176 bp_.use_amsmath == BufferParams::package_auto);
2178 mathsModule->esintCB->setChecked(
2179 bp_.use_esint == BufferParams::package_on);
2180 mathsModule->esintautoCB->setChecked(
2181 bp_.use_esint == BufferParams::package_auto);
2183 switch (bp_.spacing().getSpace()) {
2184 case Spacing::Other: nitem = 3; break;
2185 case Spacing::Double: nitem = 2; break;
2186 case Spacing::Onehalf: nitem = 1; break;
2187 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2191 string const & layoutID = bp_.baseClassID();
2192 setLayoutComboByIDString(layoutID);
2194 updatePagestyle(documentClass().opt_pagestyle(),
2197 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2198 if (bp_.spacing().getSpace() == Spacing::Other) {
2199 textLayoutModule->lspacingLE->setText(
2200 toqstr(bp_.spacing().getValueAsString()));
2204 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation)
2205 textLayoutModule->indentRB->setChecked(true);
2207 textLayoutModule->skipRB->setChecked(true);
2210 switch (bp_.getDefSkip().kind()) {
2211 case VSpace::SMALLSKIP:
2214 case VSpace::MEDSKIP:
2217 case VSpace::BIGSKIP:
2220 case VSpace::LENGTH:
2223 string const length = bp_.getDefSkip().asLyXCommand();
2224 lengthToWidgets(textLayoutModule->skipLE,
2225 textLayoutModule->skipLengthCO,
2226 length, defaultUnit);
2233 textLayoutModule->skipCO->setCurrentIndex(skip);
2236 textLayoutModule->twoColumnCB->setChecked(
2239 // break listings_params to multiple lines
2241 InsetListingsParams(bp_.listings_params).separatedParams();
2242 textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
2244 if (!bp_.options.empty()) {
2245 latexModule->optionsLE->setText(
2246 toqstr(bp_.options));
2248 latexModule->optionsLE->setText(QString());
2252 latexModule->defaultOptionsCB->setChecked(
2253 bp_.use_default_options);
2254 updateSelectedModules();
2255 selectionManager->updateProvidedModules(
2256 bp_.baseClass()->providedModules());
2257 selectionManager->updateExcludedModules(
2258 bp_.baseClass()->excludedModules());
2260 if (!documentClass().options().empty()) {
2261 latexModule->defaultOptionsLE->setText(
2262 toqstr(documentClass().options()));
2264 latexModule->defaultOptionsLE->setText(
2265 toqstr(_("[No options predefined]")));
2268 latexModule->defaultOptionsLE->setEnabled(
2269 bp_.use_default_options
2270 && !documentClass().options().empty());
2272 latexModule->defaultOptionsCB->setEnabled(
2273 !documentClass().options().empty());
2275 if (!bp_.master.empty()) {
2276 latexModule->childDocGB->setChecked(true);
2277 latexModule->childDocLE->setText(
2278 toqstr(bp_.master));
2280 latexModule->childDocLE->setText(QString());
2281 latexModule->childDocGB->setChecked(false);
2284 floatModule->set(bp_.float_placement);
2287 // update combobox with formats
2288 updateDefaultFormat();
2289 int index = outputModule->defaultFormatCO->findData(toqstr(
2290 bp_.defaultOutputFormat));
2291 // set to default if format is not found
2294 outputModule->defaultFormatCO->setCurrentIndex(index);
2295 outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2296 outputModule->xetexCB->setChecked(
2297 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2300 updateFontsize(documentClass().opt_fontsize(),
2304 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2305 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2306 fontModule->fontsRomanCO->setCurrentIndex(i);
2311 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2312 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2313 fontModule->fontsSansCO->setCurrentIndex(i);
2317 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2318 if (fontModule->fontsTypewriterCO->itemText(i) ==
2319 toqstr(bp_.fontsTypewriter)) {
2320 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2325 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2327 fontModule->fontsRomanCO->setCurrentIndex(n);
2331 n = findToken(tex_fonts_sans, bp_.fontsSans);
2333 fontModule->fontsSansCO->setCurrentIndex(n);
2337 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2339 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2344 if (!bp_.fontsCJK.empty())
2345 fontModule->cjkFontLE->setText(
2346 toqstr(bp_.fontsCJK));
2348 fontModule->cjkFontLE->setText(QString());
2350 fontModule->fontScCB->setChecked(bp_.fontsSC);
2351 fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2352 fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2353 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2355 int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2357 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2360 bool const extern_geometry =
2361 documentClass().provides("geometry");
2362 int const psize = bp_.papersize;
2363 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2364 setCustomPapersize(!extern_geometry && psize);
2365 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2367 bool const landscape =
2368 bp_.orientation == ORIENTATION_LANDSCAPE;
2369 pageLayoutModule->landscapeRB->setChecked(landscape);
2370 pageLayoutModule->portraitRB->setChecked(!landscape);
2371 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2372 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2374 pageLayoutModule->facingPagesCB->setChecked(
2375 bp_.sides == TwoSides);
2377 pageLayoutModule->backgroundPB->setStyleSheet(
2378 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2379 set_backgroundcolor = bp_.backgroundcolor;
2381 lengthToWidgets(pageLayoutModule->paperwidthLE,
2382 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2383 lengthToWidgets(pageLayoutModule->paperheightLE,
2384 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2387 Ui::MarginsUi * m = marginsModule;
2389 setMargins(!bp_.use_geometry);
2391 lengthToWidgets(m->topLE, m->topUnit,
2392 bp_.topmargin, defaultUnit);
2394 lengthToWidgets(m->bottomLE, m->bottomUnit,
2395 bp_.bottommargin, defaultUnit);
2397 lengthToWidgets(m->innerLE, m->innerUnit,
2398 bp_.leftmargin, defaultUnit);
2400 lengthToWidgets(m->outerLE, m->outerUnit,
2401 bp_.rightmargin, defaultUnit);
2403 lengthToWidgets(m->headheightLE, m->headheightUnit,
2404 bp_.headheight, defaultUnit);
2406 lengthToWidgets(m->headsepLE, m->headsepUnit,
2407 bp_.headsep, defaultUnit);
2409 lengthToWidgets(m->footskipLE, m->footskipUnit,
2410 bp_.footskip, defaultUnit);
2412 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2413 bp_.columnsep, defaultUnit);
2415 branchesModule->update(bp_);
2418 PDFOptions const & pdf = bp_.pdfoptions();
2419 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2420 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2421 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2422 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2423 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2425 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2426 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2427 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2429 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2431 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2432 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2433 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2434 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2436 nn = findToken(backref_opts, pdf.backref);
2438 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2440 pdfSupportModule->fullscreenCB->setChecked
2441 (pdf.pagemode == pdf.pagemode_fullscreen);
2443 pdfSupportModule->optionsLE->setText(
2444 toqstr(pdf.quoted_options));
2446 // Make sure that the bc is in the INITIAL state
2447 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2452 void GuiDocument::saveDocDefault()
2454 // we have to apply the params first
2460 void GuiDocument::updateAvailableModules()
2462 modules_av_model_.clear();
2463 list<modInfoStruct> const & modInfoList = getModuleInfo();
2464 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2465 list<modInfoStruct>::const_iterator men = modInfoList.end();
2466 for (int i = 0; mit != men; ++mit, ++i)
2467 modules_av_model_.insertRow(i, mit->name, mit->id,
2472 void GuiDocument::updateSelectedModules()
2474 modules_sel_model_.clear();
2475 list<modInfoStruct> const selModList = getSelectedModules();
2476 list<modInfoStruct>::const_iterator mit = selModList.begin();
2477 list<modInfoStruct>::const_iterator men = selModList.end();
2478 for (int i = 0; mit != men; ++mit, ++i)
2479 modules_sel_model_.insertRow(i, mit->name, mit->id,
2484 void GuiDocument::updateContents()
2486 // Nothing to do here as the document settings is not cursor dependant.
2491 void GuiDocument::useClassDefaults()
2493 if (applyPB->isEnabled()) {
2494 int const ret = Alert::prompt(_("Unapplied changes"),
2495 _("Some changes in the dialog were not yet applied.\n"
2496 "If you do not apply now, they will be lost after this action."),
2497 1, 1, _("&Apply"), _("&Dismiss"));
2502 int idx = latexModule->classCO->currentIndex();
2503 string const classname = classes_model_.getIDString(idx);
2504 if (!bp_.setBaseClass(classname)) {
2505 Alert::error(_("Error"), _("Unable to set document class."));
2508 bp_.useClassDefaults();
2513 void GuiDocument::setLayoutComboByIDString(string const & idString)
2515 int idx = classes_model_.findIDString(idString);
2517 Alert::warning(_("Can't set layout!"),
2518 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2520 latexModule->classCO->setCurrentIndex(idx);
2524 bool GuiDocument::isValid()
2526 return validateListingsParameters().isEmpty()
2527 && (textLayoutModule->skipCO->currentIndex() != 3
2528 || !textLayoutModule->skipLE->text().isEmpty());
2532 char const * const GuiDocument::fontfamilies[5] = {
2533 "default", "rmdefault", "sfdefault", "ttdefault", ""
2537 char const * GuiDocument::fontfamilies_gui[5] = {
2538 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2542 bool GuiDocument::initialiseParams(string const &)
2544 BufferView const * view = bufferview();
2546 bp_ = BufferParams();
2550 bp_ = view->buffer().params();
2552 updateAvailableModules();
2553 //FIXME It'd be nice to make sure here that the selected
2554 //modules are consistent: That required modules are actually
2555 //selected, and that we don't have conflicts. If so, we could
2556 //at least pop up a warning.
2562 void GuiDocument::clearParams()
2564 bp_ = BufferParams();
2568 BufferId GuiDocument::id() const
2570 BufferView const * const view = bufferview();
2571 return view? &view->buffer() : 0;
2575 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2577 return moduleNames_;
2581 list<GuiDocument::modInfoStruct> const
2582 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2584 LayoutModuleList::const_iterator it = mods.begin();
2585 LayoutModuleList::const_iterator end = mods.end();
2586 list<modInfoStruct> mInfo;
2587 for (; it != end; ++it) {
2590 LyXModule * mod = moduleList[*it];
2593 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2595 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2602 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2604 return makeModuleInfo(params().getModules());
2608 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2610 return makeModuleInfo(params().baseClass()->providedModules());
2614 DocumentClass const & GuiDocument::documentClass() const
2616 return bp_.documentClass();
2620 static void dispatch_bufferparams(Dialog const & dialog,
2621 BufferParams const & bp, FuncCode lfun)
2624 ss << "\\begin_header\n";
2626 ss << "\\end_header\n";
2627 dialog.dispatch(FuncRequest(lfun, ss.str()));
2631 void GuiDocument::dispatchParams()
2633 // This must come first so that a language change is correctly noticed
2636 // Apply the BufferParams. Note that this will set the base class
2637 // and then update the buffer's layout.
2638 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2640 if (!params().master.empty()) {
2641 FileName const master_file = support::makeAbsPath(params().master,
2642 support::onlyPath(buffer().absFileName()));
2643 if (isLyXFilename(master_file.absFilename())) {
2644 Buffer * master = checkAndLoadLyXFile(master_file);
2646 if (master->isChild(const_cast<Buffer *>(&buffer())))
2647 const_cast<Buffer &>(buffer()).setParent(master);
2649 Alert::warning(_("Assigned master does not include this file"),
2650 bformat(_("You must include this file in the document\n"
2651 "'%1$s' in order to use the master document\n"
2652 "feature."), from_utf8(params().master)));
2654 Alert::warning(_("Could not load master"),
2655 bformat(_("The master document '%1$s'\n"
2656 "could not be loaded."),
2657 from_utf8(params().master)));
2661 // Generate the colours requested by each new branch.
2662 BranchList & branchlist = params().branchlist();
2663 if (!branchlist.empty()) {
2664 BranchList::const_iterator it = branchlist.begin();
2665 BranchList::const_iterator const end = branchlist.end();
2666 for (; it != end; ++it) {
2667 docstring const & current_branch = it->branch();
2668 Branch const * branch = branchlist.find(current_branch);
2669 string const x11hexname = X11hexname(branch->color());
2670 // display the new color
2671 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2672 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2675 // Open insets of selected branches, close deselected ones
2676 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2679 // Generate the colours requested by indices.
2680 IndicesList & indiceslist = params().indiceslist();
2681 if (!indiceslist.empty()) {
2682 IndicesList::const_iterator it = indiceslist.begin();
2683 IndicesList::const_iterator const end = indiceslist.end();
2684 for (; it != end; ++it) {
2685 docstring const & current_index = it->index();
2686 Index const * index = indiceslist.find(current_index);
2687 string const x11hexname = X11hexname(index->color());
2688 // display the new color
2689 docstring const str = current_index + ' ' + from_ascii(x11hexname);
2690 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2693 // FIXME: If we used an LFUN, we would not need those two lines:
2694 BufferView * bv = const_cast<BufferView *>(bufferview());
2695 bv->processUpdateFlags(Update::Force | Update::FitCursor);
2699 void GuiDocument::setLanguage() const
2701 Language const * const newL = bp_.language;
2702 if (buffer().params().language == newL)
2705 string const & lang_name = newL->lang();
2706 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2710 void GuiDocument::saveAsDefault() const
2712 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2716 bool GuiDocument::isFontAvailable(string const & font) const
2718 if (font == "default" || font == "cmr"
2719 || font == "cmss" || font == "cmtt")
2720 // these are standard
2722 if (font == "lmodern" || font == "lmss" || font == "lmtt")
2723 return LaTeXFeatures::isAvailable("lmodern");
2724 if (font == "times" || font == "palatino"
2725 || font == "helvet" || font == "courier")
2726 return LaTeXFeatures::isAvailable("psnfss");
2727 if (font == "cmbr" || font == "cmtl")
2728 return LaTeXFeatures::isAvailable("cmbright");
2729 if (font == "utopia")
2730 return LaTeXFeatures::isAvailable("utopia")
2731 || LaTeXFeatures::isAvailable("fourier");
2732 if (font == "beraserif" || font == "berasans"
2733 || font == "beramono")
2734 return LaTeXFeatures::isAvailable("bera");
2735 return LaTeXFeatures::isAvailable(font);
2739 bool GuiDocument::providesOSF(string const & font) const
2741 if (outputModule->xetexCB->isChecked())
2742 // FIXME: we should check if the fonts really
2743 // have OSF support. But how?
2746 return isFontAvailable("eco");
2747 if (font == "palatino")
2748 return isFontAvailable("mathpazo");
2753 bool GuiDocument::providesSC(string const & font) const
2755 if (outputModule->xetexCB->isChecked())
2757 if (font == "palatino")
2758 return isFontAvailable("mathpazo");
2759 if (font == "utopia")
2760 return isFontAvailable("fourier");
2765 bool GuiDocument::providesScale(string const & font) const
2767 if (outputModule->xetexCB->isChecked())
2769 return font == "helvet" || font == "luximono"
2770 || font == "berasans" || font == "beramono";
2774 void GuiDocument::loadModuleInfo()
2776 moduleNames_.clear();
2777 LyXModuleList::const_iterator it = moduleList.begin();
2778 LyXModuleList::const_iterator end = moduleList.end();
2779 for (; it != end; ++it) {
2783 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
2784 // this is supposed to give us the first sentence of the description
2787 toqstr(translateIfPossible(from_utf8(it->getDescription())));
2788 int const pos = desc.indexOf(".");
2790 desc.truncate(pos + 1);
2791 m.description = desc;
2792 moduleNames_.push_back(m);
2797 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2800 } // namespace frontend
2803 #include "moc_GuiDocument.cpp"