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()));
949 updateUnknownBranches();
952 preambleModule = new PreambleModule;
953 connect(preambleModule, SIGNAL(changed()),
954 this, SLOT(change_adaptor()));
957 bulletsModule = new BulletsModule;
958 connect(bulletsModule, SIGNAL(changed()),
959 this, SLOT(change_adaptor()));
962 modulesModule = new UiWidget<Ui::ModulesUi>;
965 new ModuleSelectionManager(modulesModule->availableLV,
966 modulesModule->selectedLV,
967 modulesModule->addPB, modulesModule->deletePB,
968 modulesModule->upPB, modulesModule->downPB,
969 availableModel(), selectedModel(), this);
970 connect(selectionManager, SIGNAL(updateHook()),
971 this, SLOT(updateModuleInfo()));
972 connect(selectionManager, SIGNAL(updateHook()),
973 this, SLOT(change_adaptor()));
974 connect(selectionManager, SIGNAL(selectionChanged()),
975 this, SLOT(modulesChanged()));
978 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
980 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
981 this, SLOT(change_adaptor()));
982 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
983 this, SLOT(change_adaptor()));
984 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
985 this, SLOT(change_adaptor()));
986 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
987 this, SLOT(change_adaptor()));
988 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
989 this, SLOT(change_adaptor()));
990 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
991 this, SLOT(change_adaptor()));
992 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
993 this, SLOT(change_adaptor()));
994 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
995 this, SLOT(change_adaptor()));
996 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
997 this, SLOT(change_adaptor()));
998 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
999 this, SLOT(change_adaptor()));
1000 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1001 this, SLOT(change_adaptor()));
1002 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1003 this, SLOT(change_adaptor()));
1004 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1005 this, SLOT(change_adaptor()));
1006 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1007 this, SLOT(change_adaptor()));
1008 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1009 this, SLOT(change_adaptor()));
1010 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1011 this, SLOT(change_adaptor()));
1013 for (int i = 0; backref_opts[i][0]; ++i)
1014 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1017 floatModule = new FloatPlacement;
1018 connect(floatModule, SIGNAL(changed()),
1019 this, SLOT(change_adaptor()));
1021 docPS->addPanel(latexModule, qt_("Document Class"));
1022 docPS->addPanel(modulesModule, qt_("Modules"));
1023 docPS->addPanel(fontModule, qt_("Fonts"));
1024 docPS->addPanel(textLayoutModule, qt_("Text Layout"));
1025 docPS->addPanel(pageLayoutModule, qt_("Page Layout"));
1026 docPS->addPanel(marginsModule, qt_("Page Margins"));
1027 docPS->addPanel(langModule, qt_("Language"));
1028 docPS->addPanel(numberingModule, qt_("Numbering & TOC"));
1029 docPS->addPanel(biblioModule, qt_("Bibliography"));
1030 docPS->addPanel(indicesModule, qt_("Indexes"));
1031 docPS->addPanel(pdfSupportModule, qt_("PDF Properties"));
1032 docPS->addPanel(mathsModule, qt_("Math Options"));
1033 docPS->addPanel(floatModule, qt_("Float Placement"));
1034 docPS->addPanel(bulletsModule, qt_("Bullets"));
1035 docPS->addPanel(branchesModule, qt_("Branches"));
1036 docPS->addPanel(outputModule, qt_("Output"));
1037 docPS->addPanel(preambleModule, qt_("LaTeX Preamble"));
1038 docPS->setCurrentPanel(qt_("Document Class"));
1039 // FIXME: hack to work around resizing bug in Qt >= 4.2
1040 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1041 #if QT_VERSION >= 0x040200
1042 docPS->updateGeometry();
1047 void GuiDocument::showPreamble()
1049 docPS->setCurrentPanel(qt_("LaTeX Preamble"));
1053 void GuiDocument::saveDefaultClicked()
1059 void GuiDocument::useDefaultsClicked()
1065 void GuiDocument::change_adaptor()
1071 QString GuiDocument::validateListingsParameters()
1073 // use a cache here to avoid repeated validation
1074 // of the same parameters
1075 static string param_cache;
1076 static QString msg_cache;
1078 if (textLayoutModule->bypassCB->isChecked())
1081 string params = fromqstr(textLayoutModule->listingsED->toPlainText());
1082 if (params != param_cache) {
1083 param_cache = params;
1084 msg_cache = toqstr(InsetListingsParams(params).validate());
1090 void GuiDocument::setListingsMessage()
1092 static bool isOK = true;
1093 QString msg = validateListingsParameters();
1094 if (msg.isEmpty()) {
1098 // listingsTB->setTextColor("black");
1099 textLayoutModule->listingsTB->setPlainText(
1100 qt_("Input listings parameters on the right. "
1101 "Enter ? for a list of parameters."));
1104 // listingsTB->setTextColor("red");
1105 textLayoutModule->listingsTB->setPlainText(msg);
1110 void GuiDocument::setLSpacing(int item)
1112 textLayoutModule->lspacingLE->setEnabled(item == 3);
1116 void GuiDocument::setSkip(int item)
1118 bool const enable = (item == 3);
1119 textLayoutModule->skipLE->setEnabled(enable);
1120 textLayoutModule->skipLengthCO->setEnabled(enable);
1124 void GuiDocument::enableSkip(bool skip)
1126 textLayoutModule->skipCO->setEnabled(skip);
1127 textLayoutModule->skipLE->setEnabled(skip);
1128 textLayoutModule->skipLengthCO->setEnabled(skip);
1130 setSkip(textLayoutModule->skipCO->currentIndex());
1134 void GuiDocument::portraitChanged()
1136 setMargins(pageLayoutModule->papersizeCO->currentIndex());
1140 void GuiDocument::setMargins(bool custom)
1142 bool const extern_geometry =
1143 documentClass().provides("geometry");
1144 marginsModule->marginCB->setEnabled(!extern_geometry);
1145 if (extern_geometry) {
1146 marginsModule->marginCB->setChecked(false);
1147 setCustomMargins(true);
1150 marginsModule->marginCB->setChecked(custom);
1151 setCustomMargins(custom);
1155 void GuiDocument::setCustomPapersize(int papersize)
1157 bool const custom = (papersize == 1);
1159 pageLayoutModule->paperwidthL->setEnabled(custom);
1160 pageLayoutModule->paperwidthLE->setEnabled(custom);
1161 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1162 pageLayoutModule->paperheightL->setEnabled(custom);
1163 pageLayoutModule->paperheightLE->setEnabled(custom);
1164 pageLayoutModule->paperheightLE->setFocus();
1165 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1169 void GuiDocument::setColSep()
1171 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1175 void GuiDocument::setCustomMargins(bool custom)
1177 marginsModule->topL->setEnabled(!custom);
1178 marginsModule->topLE->setEnabled(!custom);
1179 marginsModule->topUnit->setEnabled(!custom);
1181 marginsModule->bottomL->setEnabled(!custom);
1182 marginsModule->bottomLE->setEnabled(!custom);
1183 marginsModule->bottomUnit->setEnabled(!custom);
1185 marginsModule->innerL->setEnabled(!custom);
1186 marginsModule->innerLE->setEnabled(!custom);
1187 marginsModule->innerUnit->setEnabled(!custom);
1189 marginsModule->outerL->setEnabled(!custom);
1190 marginsModule->outerLE->setEnabled(!custom);
1191 marginsModule->outerUnit->setEnabled(!custom);
1193 marginsModule->headheightL->setEnabled(!custom);
1194 marginsModule->headheightLE->setEnabled(!custom);
1195 marginsModule->headheightUnit->setEnabled(!custom);
1197 marginsModule->headsepL->setEnabled(!custom);
1198 marginsModule->headsepLE->setEnabled(!custom);
1199 marginsModule->headsepUnit->setEnabled(!custom);
1201 marginsModule->footskipL->setEnabled(!custom);
1202 marginsModule->footskipLE->setEnabled(!custom);
1203 marginsModule->footskipUnit->setEnabled(!custom);
1205 bool const enableColSep = !custom &&
1206 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1207 marginsModule->columnsepL->setEnabled(enableColSep);
1208 marginsModule->columnsepLE->setEnabled(enableColSep);
1209 marginsModule->columnsepUnit->setEnabled(enableColSep);
1212 void GuiDocument::changeBackgroundColor()
1214 QColor const & newColor = QColorDialog::getColor(
1215 rgb2qcolor(set_backgroundcolor), asQWidget());
1216 if (!newColor.isValid())
1218 // set the button color
1219 pageLayoutModule->backgroundPB->setStyleSheet(
1220 colorButtonStyleSheet(newColor));
1222 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1227 void GuiDocument::deleteBackgroundColor()
1229 // set the button color back to white
1230 pageLayoutModule->backgroundPB->setStyleSheet(
1231 colorButtonStyleSheet(QColor(Qt::white)));
1232 // save white as the set color
1233 set_backgroundcolor = rgbFromHexName("#ffffff");
1238 void GuiDocument::xetexChanged(bool xetex)
1241 updateDefaultFormat();
1242 langModule->encodingCO->setEnabled(!xetex &&
1243 !langModule->defaultencodingRB->isChecked());
1244 langModule->defaultencodingRB->setEnabled(!xetex);
1245 langModule->otherencodingRB->setEnabled(!xetex);
1247 fontModule->fontsDefaultCO->setEnabled(!xetex);
1248 fontModule->fontsDefaultLA->setEnabled(!xetex);
1249 fontModule->cjkFontLE->setEnabled(!xetex);
1250 fontModule->cjkFontLA->setEnabled(!xetex);
1253 font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1254 bool scaleable = providesScale(font);
1255 fontModule->scaleSansSB->setEnabled(scaleable);
1256 fontModule->scaleSansLA->setEnabled(scaleable);
1258 font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1259 scaleable = providesScale(font);
1260 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1261 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1263 font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1264 fontModule->fontScCB->setEnabled(providesSC(font));
1265 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1269 void GuiDocument::updateFontsize(string const & items, string const & sel)
1271 fontModule->fontsizeCO->clear();
1272 fontModule->fontsizeCO->addItem(qt_("Default"));
1274 for (int n = 0; !token(items,'|',n).empty(); ++n)
1275 fontModule->fontsizeCO->
1276 addItem(toqstr(token(items,'|',n)));
1278 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1279 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1280 fontModule->fontsizeCO->setCurrentIndex(n);
1287 void GuiDocument::updateFontlist()
1289 fontModule->fontsRomanCO->clear();
1290 fontModule->fontsSansCO->clear();
1291 fontModule->fontsTypewriterCO->clear();
1293 // With XeTeX, we have access to all system fonts, but not the LaTeX fonts
1294 if (outputModule->xetexCB->isChecked()) {
1295 fontModule->fontsRomanCO->addItem(qt_("Default"));
1296 fontModule->fontsSansCO->addItem(qt_("Default"));
1297 fontModule->fontsTypewriterCO->addItem(qt_("Default"));
1299 QFontDatabase fontdb;
1300 QStringList families(fontdb.families());
1301 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
1302 fontModule->fontsRomanCO->addItem(*it);
1303 fontModule->fontsSansCO->addItem(*it);
1304 fontModule->fontsTypewriterCO->addItem(*it);
1309 for (int n = 0; tex_fonts_roman[n][0]; ++n) {
1310 QString font = qt_(tex_fonts_roman_gui[n]);
1311 if (!isFontAvailable(tex_fonts_roman[n]))
1312 font += qt_(" (not installed)");
1313 fontModule->fontsRomanCO->addItem(font);
1315 for (int n = 0; tex_fonts_sans[n][0]; ++n) {
1316 QString font = qt_(tex_fonts_sans_gui[n]);
1317 if (!isFontAvailable(tex_fonts_sans[n]))
1318 font += qt_(" (not installed)");
1319 fontModule->fontsSansCO->addItem(font);
1321 for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
1322 QString font = qt_(tex_fonts_monospaced_gui[n]);
1323 if (!isFontAvailable(tex_fonts_monospaced[n]))
1324 font += qt_(" (not installed)");
1325 fontModule->fontsTypewriterCO->addItem(font);
1330 void GuiDocument::romanChanged(int item)
1332 if (outputModule->xetexCB->isChecked())
1334 string const font = tex_fonts_roman[item];
1335 fontModule->fontScCB->setEnabled(providesSC(font));
1336 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1340 void GuiDocument::sansChanged(int item)
1342 if (outputModule->xetexCB->isChecked())
1344 string const font = tex_fonts_sans[item];
1345 bool scaleable = providesScale(font);
1346 fontModule->scaleSansSB->setEnabled(scaleable);
1347 fontModule->scaleSansLA->setEnabled(scaleable);
1351 void GuiDocument::ttChanged(int item)
1353 if (outputModule->xetexCB->isChecked())
1355 string const font = tex_fonts_monospaced[item];
1356 bool scaleable = providesScale(font);
1357 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1358 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1362 void GuiDocument::updatePagestyle(string const & items, string const & sel)
1365 pageLayoutModule->pagestyleCO->clear();
1366 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
1368 for (int n = 0; !token(items, '|', n).empty(); ++n) {
1369 string style = token(items, '|', n);
1370 QString style_gui = qt_(style);
1371 pagestyles.push_back(pair<string, QString>(style, style_gui));
1372 pageLayoutModule->pagestyleCO->addItem(style_gui);
1375 if (sel == "default") {
1376 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
1382 for (size_t i = 0; i < pagestyles.size(); ++i)
1383 if (pagestyles[i].first == sel)
1384 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
1387 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
1391 void GuiDocument::browseLayout()
1393 QString const label1 = qt_("Layouts|#o#O");
1394 QString const dir1 = toqstr(lyxrc.document_path);
1395 QStringList const filter(qt_("LyX Layout (*.layout)"));
1396 QString file = browseRelFile(QString(), bufferFilepath(),
1397 qt_("Local layout file"), filter, false,
1400 if (!file.endsWith(".layout"))
1403 FileName layoutFile = support::makeAbsPath(fromqstr(file),
1404 fromqstr(bufferFilepath()));
1406 int const ret = Alert::prompt(_("Local layout file"),
1407 _("The layout file you have selected is a local layout\n"
1408 "file, not one in the system or user directory. Your\n"
1409 "document may not work with this layout if you do not\n"
1410 "keep the layout file in the document directory."),
1411 1, 1, _("&Set Layout"), _("&Cancel"));
1415 // load the layout file
1416 LayoutFileList & bcl = LayoutFileList::get();
1417 string classname = layoutFile.onlyFileName();
1418 // this will update an existing layout if that layout has been loaded before.
1419 LayoutFileIndex name = bcl.addLocalLayout(
1420 classname.substr(0, classname.size() - 7),
1421 layoutFile.onlyPath().absFilename());
1424 Alert::error(_("Error"),
1425 _("Unable to read local layout file."));
1429 // do not trigger classChanged if there is no change.
1430 if (latexModule->classCO->currentText() == toqstr(name))
1434 int idx = latexModule->classCO->findText(toqstr(name));
1436 classes_model_.insertRow(0, toqstr(name), name);
1437 latexModule->classCO->setCurrentIndex(0);
1439 latexModule->classCO->setCurrentIndex(idx);
1445 void GuiDocument::browseMaster()
1447 QString const title = qt_("Select master document");
1448 QString const dir1 = toqstr(lyxrc.document_path);
1449 QString const old = latexModule->childDocLE->text();
1450 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
1451 QStringList const filter(qt_("LyX Files (*.lyx)"));
1452 QString file = browseRelFile(old, docpath, title, filter, false,
1453 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
1455 latexModule->childDocLE->setText(file);
1459 void GuiDocument::classChanged()
1461 int idx = latexModule->classCO->currentIndex();
1464 string const classname = classes_model_.getIDString(idx);
1466 // check whether the selected modules have changed.
1467 bool modules_changed = false;
1468 unsigned int const srows = selectedModel()->rowCount();
1469 if (srows != bp_.getModules().size())
1470 modules_changed = true;
1472 list<string>::const_iterator mit = bp_.getModules().begin();
1473 list<string>::const_iterator men = bp_.getModules().end();
1474 for (unsigned int i = 0; i < srows && mit != men; ++i, ++mit)
1475 if (selectedModel()->getIDString(i) != *mit) {
1476 modules_changed = true;
1481 if (modules_changed || lyxrc.auto_reset_options) {
1482 if (applyPB->isEnabled()) {
1483 int const ret = Alert::prompt(_("Unapplied changes"),
1484 _("Some changes in the dialog were not yet applied.\n"
1485 "If you do not apply now, they will be lost after this action."),
1486 1, 1, _("&Apply"), _("&Dismiss"));
1492 // We load the TextClass as soon as it is selected. This is
1493 // necessary so that other options in the dialog can be updated
1494 // according to the new class. Note, however, that, if you use
1495 // the scroll wheel when sitting on the combo box, we'll load a
1496 // lot of TextClass objects very quickly....
1497 if (!bp_.setBaseClass(classname)) {
1498 Alert::error(_("Error"), _("Unable to set document class."));
1501 if (lyxrc.auto_reset_options)
1502 bp_.useClassDefaults();
1504 // With the introduction of modules came a distinction between the base
1505 // class and the document class. The former corresponds to the main layout
1506 // file; the latter is that plus the modules (or the document-specific layout,
1507 // or whatever else there could be). Our parameters come from the document
1508 // class. So when we set the base class, we also need to recreate the document
1509 // class. Otherwise, we still have the old one.
1510 bp_.makeDocumentClass();
1515 void GuiDocument::bibtexChanged(int n)
1517 biblioModule->bibtexOptionsED->setEnabled(n != 0);
1523 // This is an insanely complicated attempt to make this sort of thing
1524 // work with RTL languages.
1525 docstring formatStrVec(vector<string> const & v, docstring const & s)
1527 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
1531 return from_utf8(v[0]);
1532 if (v.size() == 2) {
1533 docstring retval = _("%1$s and %2$s");
1534 retval = subst(retval, _("and"), s);
1535 return bformat(retval, from_utf8(v[0]), from_utf8(v[1]));
1537 // The idea here is to format all but the last two items...
1538 int const vSize = v.size();
1539 docstring t2 = _("%1$s, %2$s");
1540 docstring retval = from_utf8(v[0]);
1541 for (int i = 1; i < vSize - 2; ++i)
1542 retval = bformat(t2, retval, from_utf8(v[i]));
1543 //...and then to plug them, and the last two, into this schema
1544 docstring t = _("%1$s, %2$s, and %3$s");
1545 t = subst(t, _("and"), s);
1546 return bformat(t, retval, from_utf8(v[vSize - 2]), from_utf8(v[vSize - 1]));
1549 vector<string> idsToNames(vector<string> const & idList)
1551 vector<string> retval;
1552 vector<string>::const_iterator it = idList.begin();
1553 vector<string>::const_iterator end = idList.end();
1554 for (; it != end; ++it) {
1555 LyXModule const * const mod = moduleList[*it];
1557 retval.push_back(*it + " (Unavailable)");
1559 retval.push_back(mod->getName());
1566 void GuiDocument::modulesToParams(BufferParams & bp)
1568 // update list of loaded modules
1569 bp.clearLayoutModules();
1570 int const srows = modules_sel_model_.rowCount();
1571 for (int i = 0; i < srows; ++i)
1572 bp.addLayoutModule(modules_sel_model_.getIDString(i));
1574 // update the list of removed modules
1575 bp.clearRemovedModules();
1576 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
1577 list<string>::const_iterator rit = reqmods.begin();
1578 list<string>::const_iterator ren = reqmods.end();
1580 // check each of the default modules
1581 for (; rit != ren; rit++) {
1582 list<string>::const_iterator mit = bp.getModules().begin();
1583 list<string>::const_iterator men = bp.getModules().end();
1585 for (; mit != men; mit++) {
1592 // the module isn't present so must have been removed by the user
1593 bp.addRemovedModule(*rit);
1598 void GuiDocument::modulesChanged()
1600 modulesToParams(bp_);
1601 bp_.makeDocumentClass();
1606 void GuiDocument::updateModuleInfo()
1608 selectionManager->update();
1610 //Module description
1611 bool const focus_on_selected = selectionManager->selectedFocused();
1612 QListView const * const lv =
1613 focus_on_selected ? modulesModule->selectedLV : modulesModule->availableLV;
1614 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
1615 modulesModule->infoML->document()->clear();
1618 QModelIndex const & idx = lv->selectionModel()->currentIndex();
1619 GuiIdListModel const & id_model =
1620 focus_on_selected ? modules_sel_model_ : modules_av_model_;
1621 string const modName = id_model.getIDString(idx.row());
1622 docstring desc = getModuleDescription(modName);
1624 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
1625 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
1628 desc += _("Module provided by document class.");
1631 vector<string> pkglist = getPackageList(modName);
1632 docstring pkgdesc = formatStrVec(pkglist, _("and"));
1633 if (!pkgdesc.empty()) {
1636 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
1639 pkglist = getRequiredList(modName);
1640 if (!pkglist.empty()) {
1641 vector<string> const reqdescs = idsToNames(pkglist);
1642 pkgdesc = formatStrVec(reqdescs, _("or"));
1645 desc += bformat(_("Module required: %1$s."), pkgdesc);
1648 pkglist = getExcludedList(modName);
1649 if (!pkglist.empty()) {
1650 vector<string> const reqdescs = idsToNames(pkglist);
1651 pkgdesc = formatStrVec(reqdescs, _( "and"));
1654 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
1657 if (!isModuleAvailable(modName)) {
1660 desc += _("WARNING: Some required packages are unavailable!");
1663 modulesModule->infoML->document()->setPlainText(toqstr(desc));
1667 void GuiDocument::updateNumbering()
1669 DocumentClass const & tclass = documentClass();
1671 numberingModule->tocTW->setUpdatesEnabled(false);
1672 numberingModule->tocTW->clear();
1674 int const depth = numberingModule->depthSL->value();
1675 int const toc = numberingModule->tocSL->value();
1676 QString const no = qt_("No");
1677 QString const yes = qt_("Yes");
1678 QTreeWidgetItem * item = 0;
1680 DocumentClass::const_iterator lit = tclass.begin();
1681 DocumentClass::const_iterator len = tclass.end();
1682 for (; lit != len; ++lit) {
1683 int const toclevel = lit->toclevel;
1684 if (toclevel != Layout::NOT_IN_TOC && lit->labeltype == LABEL_COUNTER) {
1685 item = new QTreeWidgetItem(numberingModule->tocTW);
1686 item->setText(0, toqstr(translateIfPossible(lit->name())));
1687 item->setText(1, (toclevel <= depth) ? yes : no);
1688 item->setText(2, (toclevel <= toc) ? yes : no);
1692 numberingModule->tocTW->setUpdatesEnabled(true);
1693 numberingModule->tocTW->update();
1697 void GuiDocument::updateDefaultFormat()
1699 // make a copy in order to consider unapplied changes
1700 Buffer * tmpbuf = const_cast<Buffer *>(&buffer());
1701 tmpbuf->params().useXetex = outputModule->xetexCB->isChecked();
1702 int idx = latexModule->classCO->currentIndex();
1704 string const classname = classes_model_.getIDString(idx);
1705 tmpbuf->params().setBaseClass(classname);
1706 tmpbuf->params().makeDocumentClass();
1708 outputModule->defaultFormatCO->blockSignals(true);
1709 outputModule->defaultFormatCO->clear();
1710 outputModule->defaultFormatCO->addItem(qt_("Default"),
1711 QVariant(QString("default")));
1712 typedef vector<Format const *> Formats;
1713 Formats formats = tmpbuf->exportableFormats(true);
1714 Formats::const_iterator cit = formats.begin();
1715 Formats::const_iterator end = formats.end();
1716 for (; cit != end; ++cit)
1717 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
1718 QVariant(toqstr((*cit)->name())));
1719 outputModule->defaultFormatCO->blockSignals(false);
1723 void GuiDocument::applyView()
1726 preambleModule->apply(bp_);
1729 bp_.setCiteEngine(ENGINE_BASIC);
1731 if (biblioModule->citeNatbibRB->isChecked()) {
1732 bool const use_numerical_citations =
1733 biblioModule->citeStyleCO->currentIndex();
1734 if (use_numerical_citations)
1735 bp_.setCiteEngine(ENGINE_NATBIB_NUMERICAL);
1737 bp_.setCiteEngine(ENGINE_NATBIB_AUTHORYEAR);
1739 } else if (biblioModule->citeJurabibRB->isChecked())
1740 bp_.setCiteEngine(ENGINE_JURABIB);
1743 biblioModule->bibtopicCB->isChecked();
1745 string const bibtex_command =
1746 fromqstr(biblioModule->bibtexCO->itemData(
1747 biblioModule->bibtexCO->currentIndex()).toString());
1748 string const bibtex_options =
1749 fromqstr(biblioModule->bibtexOptionsED->text());
1750 if (bibtex_command == "default" || bibtex_options.empty())
1751 bp_.bibtex_command = bibtex_command;
1753 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
1756 indicesModule->apply(bp_);
1758 // language & quotes
1759 if (langModule->defaultencodingRB->isChecked()) {
1760 bp_.inputenc = "auto";
1762 int i = langModule->encodingCO->currentIndex();
1764 bp_.inputenc = "default";
1766 QString const enc_gui =
1767 langModule->encodingCO->currentText();
1768 Encodings::const_iterator it = encodings.begin();
1769 Encodings::const_iterator const end = encodings.end();
1771 for (; it != end; ++it) {
1772 if (qt_(it->guiName()) == enc_gui) {
1773 bp_.inputenc = it->latexName();
1779 // should not happen
1780 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
1781 bp_.inputenc = "default";
1786 InsetQuotes::QuoteLanguage lga = InsetQuotes::EnglishQuotes;
1787 switch (langModule->quoteStyleCO->currentIndex()) {
1789 lga = InsetQuotes::EnglishQuotes;
1792 lga = InsetQuotes::SwedishQuotes;
1795 lga = InsetQuotes::GermanQuotes;
1798 lga = InsetQuotes::PolishQuotes;
1801 lga = InsetQuotes::FrenchQuotes;
1804 lga = InsetQuotes::DanishQuotes;
1807 bp_.quotes_language = lga;
1809 QString const lang = langModule->languageCO->itemData(
1810 langModule->languageCO->currentIndex()).toString();
1811 bp_.language = languages.getLanguage(fromqstr(lang));
1814 if (bp_.documentClass().hasTocLevels()) {
1815 bp_.tocdepth = numberingModule->tocSL->value();
1816 bp_.secnumdepth = numberingModule->depthSL->value();
1820 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
1821 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
1822 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
1823 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
1826 bp_.graphicsDriver =
1827 tex_graphics[latexModule->psdriverCO->currentIndex()];
1830 int idx = latexModule->classCO->currentIndex();
1832 string const classname = classes_model_.getIDString(idx);
1833 bp_.setBaseClass(classname);
1837 modulesToParams(bp_);
1839 if (mathsModule->amsautoCB->isChecked()) {
1840 bp_.use_amsmath = BufferParams::package_auto;
1842 if (mathsModule->amsCB->isChecked())
1843 bp_.use_amsmath = BufferParams::package_on;
1845 bp_.use_amsmath = BufferParams::package_off;
1848 if (mathsModule->esintautoCB->isChecked())
1849 bp_.use_esint = BufferParams::package_auto;
1851 if (mathsModule->esintCB->isChecked())
1852 bp_.use_esint = BufferParams::package_on;
1854 bp_.use_esint = BufferParams::package_off;
1857 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
1858 bp_.pagestyle = "default";
1860 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
1861 for (size_t i = 0; i != pagestyles.size(); ++i)
1862 if (pagestyles[i].second == style_gui)
1863 bp_.pagestyle = pagestyles[i].first;
1866 switch (textLayoutModule->lspacingCO->currentIndex()) {
1868 bp_.spacing().set(Spacing::Single);
1871 bp_.spacing().set(Spacing::Onehalf);
1874 bp_.spacing().set(Spacing::Double);
1877 bp_.spacing().set(Spacing::Other,
1878 fromqstr(textLayoutModule->lspacingLE->text()));
1882 if (textLayoutModule->twoColumnCB->isChecked())
1887 // text should have passed validation
1888 bp_.listings_params =
1889 InsetListingsParams(fromqstr(textLayoutModule->listingsED->toPlainText())).params();
1891 if (textLayoutModule->indentRB->isChecked())
1892 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
1894 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
1896 switch (textLayoutModule->skipCO->currentIndex()) {
1898 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
1901 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1904 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
1909 widgetsToLength(textLayoutModule->skipLE,
1910 textLayoutModule->skipLengthCO)
1916 // DocumentDefskipCB assures that this never happens
1917 // so Assert then !!! - jbl
1918 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
1923 fromqstr(latexModule->optionsLE->text());
1925 bp_.use_default_options =
1926 latexModule->defaultOptionsCB->isChecked();
1928 if (latexModule->childDocGB->isChecked())
1930 fromqstr(latexModule->childDocLE->text());
1932 bp_.master = string();
1934 bp_.float_placement = floatModule->get();
1937 bp_.defaultOutputFormat = fromqstr(outputModule->defaultFormatCO->itemData(
1938 outputModule->defaultFormatCO->currentIndex()).toString());
1940 bool const xetex = outputModule->xetexCB->isChecked();
1941 bp_.useXetex = xetex;
1945 if (fontModule->fontsRomanCO->currentIndex() == 0)
1946 bp_.fontsRoman = "default";
1949 fromqstr(fontModule->fontsRomanCO->currentText());
1951 if (fontModule->fontsSansCO->currentIndex() == 0)
1952 bp_.fontsSans = "default";
1955 fromqstr(fontModule->fontsSansCO->currentText());
1957 if (fontModule->fontsTypewriterCO->currentIndex() == 0)
1958 bp_.fontsTypewriter = "default";
1960 bp_.fontsTypewriter =
1961 fromqstr(fontModule->fontsTypewriterCO->currentText());
1964 tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
1967 tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
1969 bp_.fontsTypewriter =
1970 tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
1974 fromqstr(fontModule->cjkFontLE->text());
1976 bp_.fontsSansScale = fontModule->scaleSansSB->value();
1978 bp_.fontsTypewriterScale = fontModule->scaleTypewriterSB->value();
1980 bp_.fontsSC = fontModule->fontScCB->isChecked();
1982 bp_.fontsOSF = fontModule->fontOsfCB->isChecked();
1985 bp_.fontsDefaultFamily = "default";
1987 bp_.fontsDefaultFamily = GuiDocument::fontfamilies[
1988 fontModule->fontsDefaultCO->currentIndex()];
1990 if (fontModule->fontsizeCO->currentIndex() == 0)
1991 bp_.fontsize = "default";
1994 fromqstr(fontModule->fontsizeCO->currentText());
1997 bp_.papersize = PAPER_SIZE(
1998 pageLayoutModule->papersizeCO->currentIndex());
2000 // custom, A3, B3 and B4 paper sizes need geometry
2001 int psize = pageLayoutModule->papersizeCO->currentIndex();
2002 bool geom_papersize = (psize == 1 || psize == 5 || psize == 8 || psize == 9);
2004 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2005 pageLayoutModule->paperwidthUnitCO);
2007 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2008 pageLayoutModule->paperheightUnitCO);
2010 if (pageLayoutModule->facingPagesCB->isChecked())
2011 bp_.sides = TwoSides;
2013 bp_.sides = OneSide;
2015 if (pageLayoutModule->landscapeRB->isChecked())
2016 bp_.orientation = ORIENTATION_LANDSCAPE;
2018 bp_.orientation = ORIENTATION_PORTRAIT;
2020 bp_.backgroundcolor = set_backgroundcolor;
2023 bp_.use_geometry = !marginsModule->marginCB->isChecked()
2026 Ui::MarginsUi const * m = marginsModule;
2028 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2029 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2030 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2031 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2032 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2033 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2034 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2035 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2037 branchesModule->apply(bp_);
2040 PDFOptions & pdf = bp_.pdfoptions();
2041 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2042 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2043 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2044 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2045 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2047 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2048 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2049 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2050 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2052 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2053 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2054 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2055 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2057 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2058 if (pdfSupportModule->fullscreenCB->isChecked())
2059 pdf.pagemode = pdf.pagemode_fullscreen;
2061 pdf.pagemode.clear();
2062 pdf.quoted_options = pdf.quoted_options_check(
2063 fromqstr(pdfSupportModule->optionsLE->text()));
2067 void GuiDocument::paramsToDialog()
2069 // set the default unit
2070 Length::UNIT const defaultUnit = Length::defaultUnit();
2073 preambleModule->update(bp_, id());
2076 biblioModule->citeDefaultRB->setChecked(
2077 bp_.citeEngine() == ENGINE_BASIC);
2079 biblioModule->citeNatbibRB->setChecked(
2080 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL ||
2081 bp_.citeEngine() == ENGINE_NATBIB_AUTHORYEAR);
2083 biblioModule->citeStyleCO->setCurrentIndex(
2084 bp_.citeEngine() == ENGINE_NATBIB_NUMERICAL);
2086 biblioModule->citeJurabibRB->setChecked(
2087 bp_.citeEngine() == ENGINE_JURABIB);
2089 biblioModule->bibtopicCB->setChecked(
2094 split(bp_.bibtex_command, command, ' ');
2096 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
2098 biblioModule->bibtexCO->setCurrentIndex(bpos);
2099 biblioModule->bibtexOptionsED->setText(toqstr(options).trimmed());
2101 biblioModule->bibtexCO->setCurrentIndex(0);
2102 biblioModule->bibtexOptionsED->clear();
2104 biblioModule->bibtexOptionsED->setEnabled(
2105 biblioModule->bibtexCO->currentIndex() != 0);
2108 indicesModule->update(bp_);
2110 // language & quotes
2111 int const pos = langModule->languageCO->findData(toqstr(
2112 bp_.language->lang()));
2113 langModule->languageCO->setCurrentIndex(pos);
2115 langModule->quoteStyleCO->setCurrentIndex(
2116 bp_.quotes_language);
2118 bool default_enc = true;
2119 if (bp_.inputenc != "auto") {
2120 default_enc = false;
2121 if (bp_.inputenc == "default") {
2122 langModule->encodingCO->setCurrentIndex(0);
2125 Encodings::const_iterator it = encodings.begin();
2126 Encodings::const_iterator const end = encodings.end();
2127 for (; it != end; ++it) {
2128 if (it->latexName() == bp_.inputenc) {
2129 enc_gui = it->guiName();
2133 int const i = langModule->encodingCO->findText(
2136 langModule->encodingCO->setCurrentIndex(i);
2138 // unknown encoding. Set to default.
2142 langModule->defaultencodingRB->setChecked(default_enc);
2143 langModule->otherencodingRB->setChecked(!default_enc);
2146 int const min_toclevel = documentClass().min_toclevel();
2147 int const max_toclevel = documentClass().max_toclevel();
2148 if (documentClass().hasTocLevels()) {
2149 numberingModule->setEnabled(true);
2150 numberingModule->depthSL->setMinimum(min_toclevel - 1);
2151 numberingModule->depthSL->setMaximum(max_toclevel);
2152 numberingModule->depthSL->setValue(bp_.secnumdepth);
2153 numberingModule->tocSL->setMaximum(min_toclevel - 1);
2154 numberingModule->tocSL->setMaximum(max_toclevel);
2155 numberingModule->tocSL->setValue(bp_.tocdepth);
2158 numberingModule->setEnabled(false);
2159 numberingModule->tocTW->clear();
2163 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
2164 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
2165 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
2166 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
2167 bulletsModule->init();
2170 int nitem = findToken(tex_graphics, bp_.graphicsDriver);
2172 latexModule->psdriverCO->setCurrentIndex(nitem);
2175 mathsModule->amsCB->setChecked(
2176 bp_.use_amsmath == BufferParams::package_on);
2177 mathsModule->amsautoCB->setChecked(
2178 bp_.use_amsmath == BufferParams::package_auto);
2180 mathsModule->esintCB->setChecked(
2181 bp_.use_esint == BufferParams::package_on);
2182 mathsModule->esintautoCB->setChecked(
2183 bp_.use_esint == BufferParams::package_auto);
2185 switch (bp_.spacing().getSpace()) {
2186 case Spacing::Other: nitem = 3; break;
2187 case Spacing::Double: nitem = 2; break;
2188 case Spacing::Onehalf: nitem = 1; break;
2189 case Spacing::Default: case Spacing::Single: nitem = 0; break;
2193 string const & layoutID = bp_.baseClassID();
2194 setLayoutComboByIDString(layoutID);
2196 updatePagestyle(documentClass().opt_pagestyle(),
2199 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
2200 if (bp_.spacing().getSpace() == Spacing::Other) {
2201 textLayoutModule->lspacingLE->setText(
2202 toqstr(bp_.spacing().getValueAsString()));
2206 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation)
2207 textLayoutModule->indentRB->setChecked(true);
2209 textLayoutModule->skipRB->setChecked(true);
2212 switch (bp_.getDefSkip().kind()) {
2213 case VSpace::SMALLSKIP:
2216 case VSpace::MEDSKIP:
2219 case VSpace::BIGSKIP:
2222 case VSpace::LENGTH:
2225 string const length = bp_.getDefSkip().asLyXCommand();
2226 lengthToWidgets(textLayoutModule->skipLE,
2227 textLayoutModule->skipLengthCO,
2228 length, defaultUnit);
2235 textLayoutModule->skipCO->setCurrentIndex(skip);
2238 textLayoutModule->twoColumnCB->setChecked(
2241 // break listings_params to multiple lines
2243 InsetListingsParams(bp_.listings_params).separatedParams();
2244 textLayoutModule->listingsED->setPlainText(toqstr(lstparams));
2246 if (!bp_.options.empty()) {
2247 latexModule->optionsLE->setText(
2248 toqstr(bp_.options));
2250 latexModule->optionsLE->setText(QString());
2254 latexModule->defaultOptionsCB->setChecked(
2255 bp_.use_default_options);
2256 updateSelectedModules();
2257 selectionManager->updateProvidedModules(
2258 bp_.baseClass()->providedModules());
2259 selectionManager->updateExcludedModules(
2260 bp_.baseClass()->excludedModules());
2262 if (!documentClass().options().empty()) {
2263 latexModule->defaultOptionsLE->setText(
2264 toqstr(documentClass().options()));
2266 latexModule->defaultOptionsLE->setText(
2267 toqstr(_("[No options predefined]")));
2270 latexModule->defaultOptionsLE->setEnabled(
2271 bp_.use_default_options
2272 && !documentClass().options().empty());
2274 latexModule->defaultOptionsCB->setEnabled(
2275 !documentClass().options().empty());
2277 if (!bp_.master.empty()) {
2278 latexModule->childDocGB->setChecked(true);
2279 latexModule->childDocLE->setText(
2280 toqstr(bp_.master));
2282 latexModule->childDocLE->setText(QString());
2283 latexModule->childDocGB->setChecked(false);
2286 floatModule->set(bp_.float_placement);
2289 // update combobox with formats
2290 updateDefaultFormat();
2291 int index = outputModule->defaultFormatCO->findData(toqstr(
2292 bp_.defaultOutputFormat));
2293 // set to default if format is not found
2296 outputModule->defaultFormatCO->setCurrentIndex(index);
2297 outputModule->xetexCB->setEnabled(bp_.baseClass()->outputType() == lyx::LATEX);
2298 outputModule->xetexCB->setChecked(
2299 bp_.baseClass()->outputType() == lyx::LATEX && bp_.useXetex);
2302 updateFontsize(documentClass().opt_fontsize(),
2306 for (int i = 0; i < fontModule->fontsRomanCO->count(); ++i) {
2307 if (fontModule->fontsRomanCO->itemText(i) == toqstr(bp_.fontsRoman)) {
2308 fontModule->fontsRomanCO->setCurrentIndex(i);
2313 for (int i = 0; i < fontModule->fontsSansCO->count(); ++i) {
2314 if (fontModule->fontsSansCO->itemText(i) == toqstr(bp_.fontsSans)) {
2315 fontModule->fontsSansCO->setCurrentIndex(i);
2319 for (int i = 0; i < fontModule->fontsTypewriterCO->count(); ++i) {
2320 if (fontModule->fontsTypewriterCO->itemText(i) ==
2321 toqstr(bp_.fontsTypewriter)) {
2322 fontModule->fontsTypewriterCO->setCurrentIndex(i);
2327 int n = findToken(tex_fonts_roman, bp_.fontsRoman);
2329 fontModule->fontsRomanCO->setCurrentIndex(n);
2333 n = findToken(tex_fonts_sans, bp_.fontsSans);
2335 fontModule->fontsSansCO->setCurrentIndex(n);
2339 n = findToken(tex_fonts_monospaced, bp_.fontsTypewriter);
2341 fontModule->fontsTypewriterCO->setCurrentIndex(n);
2346 if (!bp_.fontsCJK.empty())
2347 fontModule->cjkFontLE->setText(
2348 toqstr(bp_.fontsCJK));
2350 fontModule->cjkFontLE->setText(QString());
2352 fontModule->fontScCB->setChecked(bp_.fontsSC);
2353 fontModule->fontOsfCB->setChecked(bp_.fontsOSF);
2354 fontModule->scaleSansSB->setValue(bp_.fontsSansScale);
2355 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale);
2357 int nn = findToken(GuiDocument::fontfamilies, bp_.fontsDefaultFamily);
2359 fontModule->fontsDefaultCO->setCurrentIndex(nn);
2362 bool const extern_geometry =
2363 documentClass().provides("geometry");
2364 int const psize = bp_.papersize;
2365 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
2366 setCustomPapersize(!extern_geometry && psize);
2367 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
2369 bool const landscape =
2370 bp_.orientation == ORIENTATION_LANDSCAPE;
2371 pageLayoutModule->landscapeRB->setChecked(landscape);
2372 pageLayoutModule->portraitRB->setChecked(!landscape);
2373 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
2374 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
2376 pageLayoutModule->facingPagesCB->setChecked(
2377 bp_.sides == TwoSides);
2379 pageLayoutModule->backgroundPB->setStyleSheet(
2380 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
2381 set_backgroundcolor = bp_.backgroundcolor;
2383 lengthToWidgets(pageLayoutModule->paperwidthLE,
2384 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, defaultUnit);
2385 lengthToWidgets(pageLayoutModule->paperheightLE,
2386 pageLayoutModule->paperheightUnitCO, bp_.paperheight, defaultUnit);
2389 Ui::MarginsUi * m = marginsModule;
2391 setMargins(!bp_.use_geometry);
2393 lengthToWidgets(m->topLE, m->topUnit,
2394 bp_.topmargin, defaultUnit);
2396 lengthToWidgets(m->bottomLE, m->bottomUnit,
2397 bp_.bottommargin, defaultUnit);
2399 lengthToWidgets(m->innerLE, m->innerUnit,
2400 bp_.leftmargin, defaultUnit);
2402 lengthToWidgets(m->outerLE, m->outerUnit,
2403 bp_.rightmargin, defaultUnit);
2405 lengthToWidgets(m->headheightLE, m->headheightUnit,
2406 bp_.headheight, defaultUnit);
2408 lengthToWidgets(m->headsepLE, m->headsepUnit,
2409 bp_.headsep, defaultUnit);
2411 lengthToWidgets(m->footskipLE, m->footskipUnit,
2412 bp_.footskip, defaultUnit);
2414 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
2415 bp_.columnsep, defaultUnit);
2418 updateUnknownBranches();
2419 branchesModule->update(bp_);
2422 PDFOptions const & pdf = bp_.pdfoptions();
2423 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
2424 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
2425 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
2426 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
2427 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
2429 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
2430 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
2431 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
2433 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
2435 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
2436 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
2437 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
2438 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
2440 nn = findToken(backref_opts, pdf.backref);
2442 pdfSupportModule->backrefCO->setCurrentIndex(nn);
2444 pdfSupportModule->fullscreenCB->setChecked
2445 (pdf.pagemode == pdf.pagemode_fullscreen);
2447 pdfSupportModule->optionsLE->setText(
2448 toqstr(pdf.quoted_options));
2450 // Make sure that the bc is in the INITIAL state
2451 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
2456 void GuiDocument::saveDocDefault()
2458 // we have to apply the params first
2464 void GuiDocument::updateAvailableModules()
2466 modules_av_model_.clear();
2467 list<modInfoStruct> const & modInfoList = getModuleInfo();
2468 list<modInfoStruct>::const_iterator mit = modInfoList.begin();
2469 list<modInfoStruct>::const_iterator men = modInfoList.end();
2470 for (int i = 0; mit != men; ++mit, ++i)
2471 modules_av_model_.insertRow(i, mit->name, mit->id,
2476 void GuiDocument::updateSelectedModules()
2478 modules_sel_model_.clear();
2479 list<modInfoStruct> const selModList = getSelectedModules();
2480 list<modInfoStruct>::const_iterator mit = selModList.begin();
2481 list<modInfoStruct>::const_iterator men = selModList.end();
2482 for (int i = 0; mit != men; ++mit, ++i)
2483 modules_sel_model_.insertRow(i, mit->name, mit->id,
2488 void GuiDocument::updateContents()
2490 // Nothing to do here as the document settings is not cursor dependant.
2495 void GuiDocument::useClassDefaults()
2497 if (applyPB->isEnabled()) {
2498 int const ret = Alert::prompt(_("Unapplied changes"),
2499 _("Some changes in the dialog were not yet applied.\n"
2500 "If you do not apply now, they will be lost after this action."),
2501 1, 1, _("&Apply"), _("&Dismiss"));
2506 int idx = latexModule->classCO->currentIndex();
2507 string const classname = classes_model_.getIDString(idx);
2508 if (!bp_.setBaseClass(classname)) {
2509 Alert::error(_("Error"), _("Unable to set document class."));
2512 bp_.useClassDefaults();
2517 void GuiDocument::setLayoutComboByIDString(string const & idString)
2519 int idx = classes_model_.findIDString(idString);
2521 Alert::warning(_("Can't set layout!"),
2522 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
2524 latexModule->classCO->setCurrentIndex(idx);
2528 bool GuiDocument::isValid()
2530 return validateListingsParameters().isEmpty()
2531 && (textLayoutModule->skipCO->currentIndex() != 3
2532 || !textLayoutModule->skipLE->text().isEmpty());
2536 char const * const GuiDocument::fontfamilies[5] = {
2537 "default", "rmdefault", "sfdefault", "ttdefault", ""
2541 char const * GuiDocument::fontfamilies_gui[5] = {
2542 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
2546 bool GuiDocument::initialiseParams(string const &)
2548 BufferView const * view = bufferview();
2550 bp_ = BufferParams();
2554 bp_ = view->buffer().params();
2556 updateAvailableModules();
2557 //FIXME It'd be nice to make sure here that the selected
2558 //modules are consistent: That required modules are actually
2559 //selected, and that we don't have conflicts. If so, we could
2560 //at least pop up a warning.
2566 void GuiDocument::clearParams()
2568 bp_ = BufferParams();
2572 BufferId GuiDocument::id() const
2574 BufferView const * const view = bufferview();
2575 return view? &view->buffer() : 0;
2579 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
2581 return moduleNames_;
2585 list<GuiDocument::modInfoStruct> const
2586 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
2588 LayoutModuleList::const_iterator it = mods.begin();
2589 LayoutModuleList::const_iterator end = mods.end();
2590 list<modInfoStruct> mInfo;
2591 for (; it != end; ++it) {
2594 LyXModule * mod = moduleList[*it];
2597 m.name = toqstr(translateIfPossible(from_utf8(mod->getName())));
2599 m.name = toqstr(*it) + toqstr(" (") + qt_("Not Found") + toqstr(")");
2606 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
2608 return makeModuleInfo(params().getModules());
2612 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
2614 return makeModuleInfo(params().baseClass()->providedModules());
2618 DocumentClass const & GuiDocument::documentClass() const
2620 return bp_.documentClass();
2624 static void dispatch_bufferparams(Dialog const & dialog,
2625 BufferParams const & bp, FuncCode lfun)
2628 ss << "\\begin_header\n";
2630 ss << "\\end_header\n";
2631 dialog.dispatch(FuncRequest(lfun, ss.str()));
2635 void GuiDocument::dispatchParams()
2637 // This must come first so that a language change is correctly noticed
2640 // Apply the BufferParams. Note that this will set the base class
2641 // and then update the buffer's layout.
2642 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY);
2644 if (!params().master.empty()) {
2645 FileName const master_file = support::makeAbsPath(params().master,
2646 support::onlyPath(buffer().absFileName()));
2647 if (isLyXFilename(master_file.absFilename())) {
2648 Buffer * master = checkAndLoadLyXFile(master_file);
2650 if (master->isChild(const_cast<Buffer *>(&buffer())))
2651 const_cast<Buffer &>(buffer()).setParent(master);
2653 Alert::warning(_("Assigned master does not include this file"),
2654 bformat(_("You must include this file in the document\n"
2655 "'%1$s' in order to use the master document\n"
2656 "feature."), from_utf8(params().master)));
2658 Alert::warning(_("Could not load master"),
2659 bformat(_("The master document '%1$s'\n"
2660 "could not be loaded."),
2661 from_utf8(params().master)));
2665 // Generate the colours requested by each new branch.
2666 BranchList & branchlist = params().branchlist();
2667 if (!branchlist.empty()) {
2668 BranchList::const_iterator it = branchlist.begin();
2669 BranchList::const_iterator const end = branchlist.end();
2670 for (; it != end; ++it) {
2671 docstring const & current_branch = it->branch();
2672 Branch const * branch = branchlist.find(current_branch);
2673 string const x11hexname = X11hexname(branch->color());
2674 // display the new color
2675 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
2676 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2679 // Open insets of selected branches, close deselected ones
2680 dispatch(FuncRequest(LFUN_ALL_INSETS_TOGGLE,
2683 // Generate the colours requested by indices.
2684 IndicesList & indiceslist = params().indiceslist();
2685 if (!indiceslist.empty()) {
2686 IndicesList::const_iterator it = indiceslist.begin();
2687 IndicesList::const_iterator const end = indiceslist.end();
2688 for (; it != end; ++it) {
2689 docstring const & current_index = it->index();
2690 Index const * index = indiceslist.find(current_index);
2691 string const x11hexname = X11hexname(index->color());
2692 // display the new color
2693 docstring const str = current_index + ' ' + from_ascii(x11hexname);
2694 dispatch(FuncRequest(LFUN_SET_COLOR, str));
2697 // FIXME: If we used an LFUN, we would not need those two lines:
2698 BufferView * bv = const_cast<BufferView *>(bufferview());
2699 bv->processUpdateFlags(Update::Force | Update::FitCursor);
2703 void GuiDocument::setLanguage() const
2705 Language const * const newL = bp_.language;
2706 if (buffer().params().language == newL)
2709 string const & lang_name = newL->lang();
2710 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
2714 void GuiDocument::saveAsDefault() const
2716 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT);
2720 bool GuiDocument::isFontAvailable(string const & font) const
2722 if (font == "default" || font == "cmr"
2723 || font == "cmss" || font == "cmtt")
2724 // these are standard
2726 if (font == "lmodern" || font == "lmss" || font == "lmtt")
2727 return LaTeXFeatures::isAvailable("lmodern");
2728 if (font == "times" || font == "palatino"
2729 || font == "helvet" || font == "courier")
2730 return LaTeXFeatures::isAvailable("psnfss");
2731 if (font == "cmbr" || font == "cmtl")
2732 return LaTeXFeatures::isAvailable("cmbright");
2733 if (font == "utopia")
2734 return LaTeXFeatures::isAvailable("utopia")
2735 || LaTeXFeatures::isAvailable("fourier");
2736 if (font == "beraserif" || font == "berasans"
2737 || font == "beramono")
2738 return LaTeXFeatures::isAvailable("bera");
2739 return LaTeXFeatures::isAvailable(font);
2743 bool GuiDocument::providesOSF(string const & font) const
2745 if (outputModule->xetexCB->isChecked())
2746 // FIXME: we should check if the fonts really
2747 // have OSF support. But how?
2750 return isFontAvailable("eco");
2751 if (font == "palatino")
2752 return isFontAvailable("mathpazo");
2757 bool GuiDocument::providesSC(string const & font) const
2759 if (outputModule->xetexCB->isChecked())
2761 if (font == "palatino")
2762 return isFontAvailable("mathpazo");
2763 if (font == "utopia")
2764 return isFontAvailable("fourier");
2769 bool GuiDocument::providesScale(string const & font) const
2771 if (outputModule->xetexCB->isChecked())
2773 return font == "helvet" || font == "luximono"
2774 || font == "berasans" || font == "beramono";
2778 void GuiDocument::loadModuleInfo()
2780 moduleNames_.clear();
2781 LyXModuleList::const_iterator it = moduleList.begin();
2782 LyXModuleList::const_iterator end = moduleList.end();
2783 for (; it != end; ++it) {
2787 m.name = toqstr(translateIfPossible(from_utf8(it->getName())));
2788 // this is supposed to give us the first sentence of the description
2791 toqstr(translateIfPossible(from_utf8(it->getDescription())));
2792 int const pos = desc.indexOf(".");
2794 desc.truncate(pos + 1);
2795 m.description = desc;
2796 moduleNames_.push_back(m);
2801 void GuiDocument::updateUnknownBranches()
2803 list<docstring> used_branches;
2804 buffer().getUsedBranches(used_branches);
2805 list<docstring>::const_iterator it = used_branches.begin();
2806 QStringList unknown_branches;
2807 for (; it != used_branches.end() ; ++it) {
2808 if (!buffer().params().branchlist().find(*it))
2809 unknown_branches.append(toqstr(*it));
2811 branchesModule->setUnknownBranches(unknown_branches);
2815 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
2818 } // namespace frontend
2821 #include "moc_GuiDocument.cpp"