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 "CategorizedCombo.h"
17 #include "GuiApplication.h"
18 #include "GuiBranches.h"
19 #include "GuiIndices.h"
20 #include "GuiSelectionManager.h"
21 #include "LaTeXHighlighter.h"
22 #include "LengthCombo.h"
23 #include "PanelStack.h"
24 #include "Validator.h"
26 #include "LayoutFile.h"
27 #include "BranchList.h"
28 #include "buffer_funcs.h"
30 #include "BufferParams.h"
31 #include "BufferView.h"
32 #include "CiteEnginesList.h"
34 #include "ColorCache.h"
35 #include "Converter.h"
38 #include "FloatPlacement.h"
40 #include "FuncRequest.h"
41 #include "IndicesList.h"
43 #include "LaTeXFeatures.h"
44 #include "LaTeXFonts.h"
46 #include "LayoutEnums.h"
47 #include "LayoutModuleList.h"
49 #include "ModuleList.h"
50 #include "OutputParams.h"
51 #include "PDFOptions.h"
52 #include "qt_helpers.h"
54 #include "TextClass.h"
58 #include "insets/InsetListingsParams.h"
60 #include "support/debug.h"
61 #include "support/FileName.h"
62 #include "support/filetools.h"
63 #include "support/gettext.h"
64 #include "support/lassert.h"
65 #include "support/lstrings.h"
67 #include "frontends/alert.h"
69 #include <QAbstractItemModel>
70 #include <QHeaderView>
72 #include <QColorDialog>
73 #include <QCloseEvent>
74 #include <QFontDatabase>
76 #include <QTextBoundaryFinder>
77 #include <QTextCursor>
87 // a style sheet for buttons
88 // this is for example used for the background color setting button
89 static inline QString colorButtonStyleSheet(QColor const & bgColor)
91 if (bgColor.isValid()) {
92 QString rc = QLatin1String("background-color:");
101 using namespace lyx::support;
106 char const * const tex_graphics[] =
108 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
109 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
110 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
111 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
116 char const * const tex_graphics_gui[] =
118 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
119 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
120 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
121 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
122 "XeTeX", N_("None"), ""
126 char const * backref_opts[] =
128 "false", "section", "slide", "page", ""
132 char const * backref_opts_gui[] =
134 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
138 vector<string> engine_types_;
139 vector<pair<string, QString> > pagestyles;
141 QMap<QString, QString> rmfonts_;
142 QMap<QString, QString> sffonts_;
143 QMap<QString, QString> ttfonts_;
144 QMap<QString, QString> mathfonts_;
147 } // anonymous namespace
151 RGBColor set_backgroundcolor;
152 bool is_backgroundcolor;
153 RGBColor set_fontcolor;
155 RGBColor set_notefontcolor;
156 RGBColor set_boxbgcolor;
157 bool forced_fontspec_activation;
160 // used when sorting the textclass list.
161 class less_textclass_avail_desc
162 : public binary_function<string, string, int>
165 bool operator()(string const & lhs, string const & rhs) const
167 // Ordering criteria:
168 // 1. Availability of text class
169 // 2. Description (lexicographic)
170 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
171 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
172 int const order = compare_no_case(
173 translateIfPossible(from_utf8(tc1.description())),
174 translateIfPossible(from_utf8(tc2.description())));
175 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
176 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
185 vector<string> getRequiredList(string const & modName)
187 LyXModule const * const mod = theModuleList[modName];
189 return vector<string>(); //empty such thing
190 return mod->getRequiredModules();
194 vector<string> getExcludedList(string const & modName)
196 LyXModule const * const mod = theModuleList[modName];
198 return vector<string>(); //empty such thing
199 return mod->getExcludedModules();
203 docstring getModuleCategory(string const & modName)
205 LyXModule const * const mod = theModuleList[modName];
208 return from_utf8(mod->category());
212 docstring getModuleDescription(string const & modName)
214 LyXModule const * const mod = theModuleList[modName];
216 return _("Module not found!");
218 return translateIfPossible(from_utf8(mod->getDescription()));
222 vector<string> getPackageList(string const & modName)
224 LyXModule const * const mod = theModuleList[modName];
226 return vector<string>(); //empty such thing
227 return mod->getPackageList();
231 bool isModuleAvailable(string const & modName)
233 LyXModule const * const mod = theModuleList[modName];
236 return mod->isAvailable();
239 } // anonymous namespace
242 /////////////////////////////////////////////////////////////////////
244 // ModuleSelectionManager
246 /////////////////////////////////////////////////////////////////////
248 /// SelectionManager for use with modules
249 class ModuleSelectionManager : public GuiSelectionManager
253 ModuleSelectionManager(QObject * parent,
254 QTreeView * availableLV,
255 QListView * selectedLV,
259 QPushButton * downPB,
260 GuiIdListModel * availableModel,
261 GuiIdListModel * selectedModel,
262 GuiDocument const * container)
263 : GuiSelectionManager(parent, availableLV, selectedLV, addPB, delPB,
264 upPB, downPB, availableModel, selectedModel),
265 container_(container)
268 void updateProvidedModules(LayoutModuleList const & pm)
269 { provided_modules_ = pm.list(); }
271 void updateExcludedModules(LayoutModuleList const & em)
272 { excluded_modules_ = em.list(); }
275 virtual void updateAddPB();
277 virtual void updateUpPB();
279 virtual void updateDownPB();
281 virtual void updateDelPB();
282 /// returns availableModel as a GuiIdListModel
283 GuiIdListModel * getAvailableModel()
285 return dynamic_cast<GuiIdListModel *>(availableModel);
287 /// returns selectedModel as a GuiIdListModel
288 GuiIdListModel * getSelectedModel()
290 return dynamic_cast<GuiIdListModel *>(selectedModel);
292 /// keeps a list of the modules the text class provides
293 list<string> provided_modules_;
295 list<string> excluded_modules_;
297 GuiDocument const * container_;
300 void ModuleSelectionManager::updateAddPB()
302 int const arows = availableModel->rowCount();
303 QModelIndexList const avail_sels =
304 availableLV->selectionModel()->selectedIndexes();
306 // disable if there aren't any modules (?), if none of them is chosen
307 // in the dialog, or if the chosen one is already selected for use.
308 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
309 addPB->setEnabled(false);
313 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
314 string const modname = getAvailableModel()->getIDString(idx.row());
317 container_->params().layoutModuleCanBeAdded(modname);
318 addPB->setEnabled(enable);
322 void ModuleSelectionManager::updateDownPB()
324 int const srows = selectedModel->rowCount();
326 downPB->setEnabled(false);
329 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
330 int const curRow = curidx.row();
331 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
332 downPB->setEnabled(false);
336 // determine whether immediately succeding element requires this one
337 string const curmodname = getSelectedModel()->getIDString(curRow);
338 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
340 vector<string> reqs = getRequiredList(nextmodname);
342 // if it doesn't require anything....
344 downPB->setEnabled(true);
348 // Enable it if this module isn't required.
349 // FIXME This should perhaps be more flexible and check whether, even
350 // if the next one is required, there is also an earlier one that will do.
352 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
355 void ModuleSelectionManager::updateUpPB()
357 int const srows = selectedModel->rowCount();
359 upPB->setEnabled(false);
363 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
364 int curRow = curIdx.row();
365 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
366 upPB->setEnabled(false);
369 string const curmodname = getSelectedModel()->getIDString(curRow);
371 // determine whether immediately preceding element is required by this one
372 vector<string> reqs = getRequiredList(curmodname);
374 // if this one doesn't require anything....
376 upPB->setEnabled(true);
381 // Enable it if the preceding module isn't required.
382 // NOTE This is less flexible than it might be. We could check whether, even
383 // if the previous one is required, there is an earlier one that would do.
384 string const premod = getSelectedModel()->getIDString(curRow - 1);
385 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
388 void ModuleSelectionManager::updateDelPB()
390 int const srows = selectedModel->rowCount();
392 deletePB->setEnabled(false);
396 QModelIndex const & curidx =
397 selectedLV->selectionModel()->currentIndex();
398 int const curRow = curidx.row();
399 if (curRow < 0 || curRow >= srows) { // invalid index?
400 deletePB->setEnabled(false);
404 string const curmodname = getSelectedModel()->getIDString(curRow);
406 // We're looking here for a reason NOT to enable the button. If we
407 // find one, we disable it and return. If we don't, we'll end up at
408 // the end of the function, and then we enable it.
409 for (int i = curRow + 1; i < srows; ++i) {
410 string const thisMod = getSelectedModel()->getIDString(i);
411 vector<string> reqs = getRequiredList(thisMod);
412 //does this one require us?
413 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
417 // OK, so this module requires us
418 // is there an EARLIER module that also satisfies the require?
419 // NOTE We demand that it be earlier to keep the list of modules
420 // consistent with the rule that a module must be proceeded by a
421 // required module. There would be more flexible ways to proceed,
422 // but that would be a lot more complicated, and the logic here is
423 // already complicated. (That's why I've left the debugging code.)
424 // lyxerr << "Testing " << thisMod << endl;
425 bool foundone = false;
426 for (int j = 0; j < curRow; ++j) {
427 string const mod = getSelectedModel()->getIDString(j);
428 // lyxerr << "In loop: Testing " << mod << endl;
429 // do we satisfy the require?
430 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
431 // lyxerr << mod << " does the trick." << endl;
436 // did we find a module to satisfy the require?
438 // lyxerr << "No matching module found." << endl;
439 deletePB->setEnabled(false);
443 // lyxerr << "All's well that ends well." << endl;
444 deletePB->setEnabled(true);
448 /////////////////////////////////////////////////////////////////////
452 /////////////////////////////////////////////////////////////////////
454 PreambleModule::PreambleModule(QWidget * parent)
455 : UiWidget<Ui::PreambleUi>(parent), current_id_(0)
457 // This is not a memory leak. The object will be destroyed
459 // @ is letter in the LyX user preamble
460 (void) new LaTeXHighlighter(preambleTE->document(), true);
461 preambleTE->setFont(guiApp->typewriterSystemFont());
462 preambleTE->setWordWrapMode(QTextOption::NoWrap);
463 setFocusProxy(preambleTE);
464 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
468 void PreambleModule::update(BufferParams const & params, BufferId id)
470 QString preamble = toqstr(params.preamble);
471 // Nothing to do if the params and preamble are unchanged.
472 if (id == current_id_
473 && preamble == preambleTE->document()->toPlainText())
476 QTextCursor cur = preambleTE->textCursor();
477 // Save the coords before switching to the new one.
478 preamble_coords_[current_id_] =
479 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
481 // Save the params address for further use.
483 preambleTE->document()->setPlainText(preamble);
484 Coords::const_iterator it = preamble_coords_.find(current_id_);
485 if (it == preamble_coords_.end())
486 // First time we open this one.
487 preamble_coords_[current_id_] = make_pair(0, 0);
489 // Restore saved coords.
490 QTextCursor cur = preambleTE->textCursor();
491 cur.setPosition(it->second.first);
492 preambleTE->setTextCursor(cur);
493 preambleTE->verticalScrollBar()->setValue(it->second.second);
498 void PreambleModule::apply(BufferParams & params)
500 params.preamble = qstring_to_ucs4(preambleTE->document()->toPlainText());
504 void PreambleModule::closeEvent(QCloseEvent * e)
506 // Save the coords before closing.
507 QTextCursor cur = preambleTE->textCursor();
508 preamble_coords_[current_id_] =
509 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
514 /////////////////////////////////////////////////////////////////////
518 /////////////////////////////////////////////////////////////////////
521 LocalLayout::LocalLayout(QWidget * parent)
522 : UiWidget<Ui::LocalLayoutUi>(parent), current_id_(0), validated_(false)
524 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
525 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
526 connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
530 void LocalLayout::update(BufferParams const & params, BufferId id)
532 QString layout = toqstr(params.getLocalLayout(false));
533 // Nothing to do if the params and preamble are unchanged.
534 if (id == current_id_
535 && layout == locallayoutTE->document()->toPlainText())
538 // Save the params address for further use.
540 locallayoutTE->document()->setPlainText(layout);
545 void LocalLayout::apply(BufferParams & params)
547 docstring const layout =
548 qstring_to_ucs4(locallayoutTE->document()->toPlainText());
549 params.setLocalLayout(layout, false);
553 void LocalLayout::hideConvert()
555 convertPB->setEnabled(false);
556 convertLB->setText("");
562 void LocalLayout::textChanged()
564 static const QString message =
565 qt_("Press button to check validity...");
566 string const layout =
567 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
569 if (layout.empty()) {
571 validatePB->setEnabled(false);
572 validLB->setText("");
575 } else if (!validatePB->isEnabled()) {
576 // if that's already enabled, we shouldn't need to do anything.
578 validLB->setText(message);
579 validatePB->setEnabled(true);
586 void LocalLayout::convert() {
587 string const layout =
588 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
589 string const newlayout = TextClass::convert(layout);
590 if (!newlayout.empty())
591 locallayoutTE->setPlainText(toqstr(newlayout));
596 void LocalLayout::convertPressed() {
603 void LocalLayout::validate() {
605 static const QString vpar("<p style=\"font-weight: bold;\">%1</p>");
606 // Flashy red bold text
607 static const QString ivpar("<p style=\"color: #c00000; font-weight: bold; \">"
609 string const layout =
610 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
611 if (!layout.empty()) {
612 TextClass::ReturnValues const ret = TextClass::validate(layout);
613 validated_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
614 validatePB->setEnabled(false);
615 validLB->setText(validated_ ? vpar.arg(qt_("Layout is valid!"))
616 : ivpar.arg(qt_("Layout is invalid!")));
617 if (ret == TextClass::OK_OLDFORMAT) {
619 // Testing conversion to LYXFILE_LAYOUT_FORMAT at this point
621 if (TextClass::convert(layout).empty()) {
622 // Conversion failed. If LAYOUT_FORMAT > LYXFILE_LAYOUT_FORMAT,
623 // then maybe the layout is still valid, but its format is more
624 // recent than LYXFILE_LAYOUT_FORMAT. However, if LAYOUT_FORMAT
625 // == LYXFILE_LAYOUT_FORMAT then something is definitely wrong.
626 convertPB->setEnabled(false);
627 const QString text = (LAYOUT_FORMAT == LYXFILE_LAYOUT_FORMAT)
628 ? ivpar.arg(qt_("Conversion to current format impossible!"))
629 : vpar.arg(qt_("Conversion to current stable format "
631 convertLB->setText(text);
633 convertPB->setEnabled(true);
634 convertLB->setText(qt_("Convert to current format"));
645 void LocalLayout::validatePressed() {
651 /////////////////////////////////////////////////////////////////////
655 /////////////////////////////////////////////////////////////////////
658 GuiDocument::GuiDocument(GuiView & lv)
659 : GuiDialog(lv, "document", qt_("Document Settings")),
660 biblioChanged_(false), nonModuleChanged_(false)
664 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
665 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
666 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
667 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
669 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
670 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
672 // Manage the restore, ok, apply, restore and cancel/close buttons
673 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
675 bc().setApply(applyPB);
676 bc().setCancel(closePB);
677 bc().setRestore(restorePB);
681 textLayoutModule = new UiWidget<Ui::TextLayoutUi>(this);
682 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
683 this, SLOT(change_adaptor()));
684 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
685 this, SLOT(setLSpacing(int)));
686 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
687 this, SLOT(change_adaptor()));
689 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
690 this, SLOT(change_adaptor()));
691 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
692 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
693 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
694 this, SLOT(change_adaptor()));
695 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
696 this, SLOT(setIndent(int)));
697 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
698 this, SLOT(change_adaptor()));
699 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
700 this, SLOT(change_adaptor()));
702 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
703 this, SLOT(change_adaptor()));
704 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
705 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
706 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
707 this, SLOT(change_adaptor()));
708 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
709 this, SLOT(setSkip(int)));
710 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
711 this, SLOT(change_adaptor()));
712 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
713 this, SLOT(change_adaptor()));
715 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
716 this, SLOT(enableIndent(bool)));
717 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
718 this, SLOT(enableSkip(bool)));
720 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
721 this, SLOT(change_adaptor()));
722 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
723 this, SLOT(setColSep()));
724 connect(textLayoutModule->justCB, SIGNAL(clicked()),
725 this, SLOT(change_adaptor()));
727 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
728 textLayoutModule->lspacingLE));
729 textLayoutModule->indentLE->setValidator(new LengthValidator(
730 textLayoutModule->indentLE));
731 textLayoutModule->skipLE->setValidator(new LengthValidator(
732 textLayoutModule->skipLE));
734 textLayoutModule->indentCO->addItem(qt_("Default"));
735 textLayoutModule->indentCO->addItem(qt_("Custom"));
736 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
737 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
738 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
739 textLayoutModule->skipCO->addItem(qt_("Custom"));
740 textLayoutModule->lspacingCO->insertItem(
741 Spacing::Single, qt_("Single"));
742 textLayoutModule->lspacingCO->insertItem(
743 Spacing::Onehalf, qt_("OneHalf"));
744 textLayoutModule->lspacingCO->insertItem(
745 Spacing::Double, qt_("Double"));
746 textLayoutModule->lspacingCO->insertItem(
747 Spacing::Other, qt_("Custom"));
748 // initialize the length validator
749 bc().addCheckedLineEdit(textLayoutModule->indentLE);
750 bc().addCheckedLineEdit(textLayoutModule->skipLE);
753 // master/child handling
754 masterChildModule = new UiWidget<Ui::MasterChildUi>(this);
756 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
757 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
758 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
759 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
760 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
761 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
762 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
763 this, SLOT(change_adaptor()));
764 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
765 this, SLOT(change_adaptor()));
766 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
767 this, SLOT(change_adaptor()));
768 masterChildModule->childrenTW->setColumnCount(2);
769 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
770 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
771 masterChildModule->childrenTW->resizeColumnToContents(1);
772 masterChildModule->childrenTW->resizeColumnToContents(2);
776 outputModule = new UiWidget<Ui::OutputUi>(this);
778 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
779 this, SLOT(change_adaptor()));
780 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
781 this, SLOT(change_adaptor()));
782 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
783 this, SLOT(change_adaptor()));
784 connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
785 this, SLOT(change_adaptor()));
786 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
787 this, SLOT(change_adaptor()));
789 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
790 this, SLOT(change_adaptor()));
791 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
792 this, SLOT(change_adaptor()));
793 outputModule->synccustomCB->addItem("");
794 outputModule->synccustomCB->addItem("\\synctex=1");
795 outputModule->synccustomCB->addItem("\\synctex=-1");
796 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
798 outputModule->synccustomCB->setValidator(new NoNewLineValidator(
799 outputModule->synccustomCB));
801 connect(outputModule->saveTransientPropertiesCB, SIGNAL(clicked()),
802 this, SLOT(change_adaptor()));
805 fontModule = new FontModule(this);
806 connect(fontModule->osFontsCB, SIGNAL(clicked()),
807 this, SLOT(change_adaptor()));
808 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
809 this, SLOT(osFontsChanged(bool)));
810 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
811 this, SLOT(change_adaptor()));
812 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
813 this, SLOT(romanChanged(int)));
814 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
815 this, SLOT(change_adaptor()));
816 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
817 this, SLOT(sansChanged(int)));
818 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
819 this, SLOT(change_adaptor()));
820 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
821 this, SLOT(ttChanged(int)));
822 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
823 this, SLOT(change_adaptor()));
824 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
825 this, SLOT(mathFontChanged(int)));
826 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
827 this, SLOT(change_adaptor()));
828 connect(fontModule->fontencCO, SIGNAL(activated(int)),
829 this, SLOT(change_adaptor()));
830 connect(fontModule->fontencCO, SIGNAL(activated(int)),
831 this, SLOT(fontencChanged(int)));
832 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
833 this, SLOT(change_adaptor()));
834 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
835 this, SLOT(change_adaptor()));
836 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
837 this, SLOT(change_adaptor()));
838 connect(fontModule->microtypeCB, SIGNAL(clicked()),
839 this, SLOT(change_adaptor()));
840 connect(fontModule->dashesCB, SIGNAL(clicked()),
841 this, SLOT(change_adaptor()));
842 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
843 this, SLOT(change_adaptor()));
844 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
845 this, SLOT(change_adaptor()));
846 connect(fontModule->fontScCB, SIGNAL(clicked()),
847 this, SLOT(change_adaptor()));
848 connect(fontModule->fontScCB, SIGNAL(toggled(bool)),
849 this, SLOT(fontScToggled(bool)));
850 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
851 this, SLOT(change_adaptor()));
852 connect(fontModule->fontOsfCB, SIGNAL(toggled(bool)),
853 this, SLOT(fontOsfToggled(bool)));
855 fontModule->fontencLE->setValidator(new NoNewLineValidator(
856 fontModule->fontencLE));
857 fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
858 fontModule->cjkFontLE));
862 fontModule->fontsizeCO->addItem(qt_("Default"));
863 fontModule->fontsizeCO->addItem(qt_("10"));
864 fontModule->fontsizeCO->addItem(qt_("11"));
865 fontModule->fontsizeCO->addItem(qt_("12"));
867 fontModule->fontencCO->addItem(qt_("Default"), QString("global"));
868 fontModule->fontencCO->addItem(qt_("Custom"), QString("custom"));
869 fontModule->fontencCO->addItem(qt_("None (no fontenc)"), QString("default"));
871 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
872 fontModule->fontsDefaultCO->addItem(
873 qt_(GuiDocument::fontfamilies_gui[n]));
875 if (!LaTeXFeatures::isAvailable("fontspec"))
876 fontModule->osFontsCB->setToolTip(
877 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
878 "You need to install the package \"fontspec\" to use this feature"));
882 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>(this);
883 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
884 this, SLOT(papersizeChanged(int)));
885 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
886 this, SLOT(papersizeChanged(int)));
887 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
888 this, SLOT(change_adaptor()));
889 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
890 this, SLOT(change_adaptor()));
891 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
892 this, SLOT(change_adaptor()));
893 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
894 this, SLOT(change_adaptor()));
895 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
896 this, SLOT(change_adaptor()));
897 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
898 this, SLOT(change_adaptor()));
899 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
900 this, SLOT(change_adaptor()));
901 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
902 this, SLOT(change_adaptor()));
903 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
904 this, SLOT(change_adaptor()));
905 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
906 this, SLOT(change_adaptor()));
908 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
909 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
910 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
911 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
912 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
913 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
914 pageLayoutModule->paperheightL);
915 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
916 pageLayoutModule->paperwidthL);
918 QComboBox * cb = pageLayoutModule->papersizeCO;
919 cb->addItem(qt_("Default"));
920 cb->addItem(qt_("Custom"));
921 cb->addItem(qt_("US letter"));
922 cb->addItem(qt_("US legal"));
923 cb->addItem(qt_("US executive"));
924 cb->addItem(qt_("A0"));
925 cb->addItem(qt_("A1"));
926 cb->addItem(qt_("A2"));
927 cb->addItem(qt_("A3"));
928 cb->addItem(qt_("A4"));
929 cb->addItem(qt_("A5"));
930 cb->addItem(qt_("A6"));
931 cb->addItem(qt_("B0"));
932 cb->addItem(qt_("B1"));
933 cb->addItem(qt_("B2"));
934 cb->addItem(qt_("B3"));
935 cb->addItem(qt_("B4"));
936 cb->addItem(qt_("B5"));
937 cb->addItem(qt_("B6"));
938 cb->addItem(qt_("C0"));
939 cb->addItem(qt_("C1"));
940 cb->addItem(qt_("C2"));
941 cb->addItem(qt_("C3"));
942 cb->addItem(qt_("C4"));
943 cb->addItem(qt_("C5"));
944 cb->addItem(qt_("C6"));
945 cb->addItem(qt_("JIS B0"));
946 cb->addItem(qt_("JIS B1"));
947 cb->addItem(qt_("JIS B2"));
948 cb->addItem(qt_("JIS B3"));
949 cb->addItem(qt_("JIS B4"));
950 cb->addItem(qt_("JIS B5"));
951 cb->addItem(qt_("JIS B6"));
952 // remove the %-items from the unit choice
953 pageLayoutModule->paperwidthUnitCO->noPercents();
954 pageLayoutModule->paperheightUnitCO->noPercents();
955 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
956 pageLayoutModule->paperheightLE));
957 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
958 pageLayoutModule->paperwidthLE));
962 marginsModule = new UiWidget<Ui::MarginsUi>(this);
963 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
964 this, SLOT(setCustomMargins(bool)));
965 connect(marginsModule->marginCB, SIGNAL(clicked()),
966 this, SLOT(change_adaptor()));
967 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
968 this, SLOT(change_adaptor()));
969 connect(marginsModule->topUnit, SIGNAL(activated(int)),
970 this, SLOT(change_adaptor()));
971 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
972 this, SLOT(change_adaptor()));
973 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
974 this, SLOT(change_adaptor()));
975 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
976 this, SLOT(change_adaptor()));
977 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
978 this, SLOT(change_adaptor()));
979 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
980 this, SLOT(change_adaptor()));
981 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
982 this, SLOT(change_adaptor()));
983 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
984 this, SLOT(change_adaptor()));
985 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
986 this, SLOT(change_adaptor()));
987 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
988 this, SLOT(change_adaptor()));
989 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
990 this, SLOT(change_adaptor()));
991 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
992 this, SLOT(change_adaptor()));
993 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
994 this, SLOT(change_adaptor()));
995 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
996 this, SLOT(change_adaptor()));
997 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
998 this, SLOT(change_adaptor()));
999 marginsModule->topLE->setValidator(new LengthValidator(
1000 marginsModule->topLE));
1001 marginsModule->bottomLE->setValidator(new LengthValidator(
1002 marginsModule->bottomLE));
1003 marginsModule->innerLE->setValidator(new LengthValidator(
1004 marginsModule->innerLE));
1005 marginsModule->outerLE->setValidator(new LengthValidator(
1006 marginsModule->outerLE));
1007 marginsModule->headsepLE->setValidator(new LengthValidator(
1008 marginsModule->headsepLE));
1009 marginsModule->headheightLE->setValidator(new LengthValidator(
1010 marginsModule->headheightLE));
1011 marginsModule->footskipLE->setValidator(new LengthValidator(
1012 marginsModule->footskipLE));
1013 marginsModule->columnsepLE->setValidator(new LengthValidator(
1014 marginsModule->columnsepLE));
1016 bc().addCheckedLineEdit(marginsModule->topLE,
1017 marginsModule->topL);
1018 bc().addCheckedLineEdit(marginsModule->bottomLE,
1019 marginsModule->bottomL);
1020 bc().addCheckedLineEdit(marginsModule->innerLE,
1021 marginsModule->innerL);
1022 bc().addCheckedLineEdit(marginsModule->outerLE,
1023 marginsModule->outerL);
1024 bc().addCheckedLineEdit(marginsModule->headsepLE,
1025 marginsModule->headsepL);
1026 bc().addCheckedLineEdit(marginsModule->headheightLE,
1027 marginsModule->headheightL);
1028 bc().addCheckedLineEdit(marginsModule->footskipLE,
1029 marginsModule->footskipL);
1030 bc().addCheckedLineEdit(marginsModule->columnsepLE,
1031 marginsModule->columnsepL);
1035 langModule = new UiWidget<Ui::LanguageUi>(this);
1036 connect(langModule->languageCO, SIGNAL(activated(int)),
1037 this, SLOT(change_adaptor()));
1038 connect(langModule->languageCO, SIGNAL(activated(int)),
1039 this, SLOT(languageChanged(int)));
1040 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1041 this, SLOT(change_adaptor()));
1042 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1043 this, SLOT(change_adaptor()));
1044 connect(langModule->encodingCO, SIGNAL(activated(int)),
1045 this, SLOT(change_adaptor()));
1046 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1047 this, SLOT(change_adaptor()));
1048 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1049 this, SLOT(change_adaptor()));
1050 connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1051 this, SLOT(change_adaptor()));
1052 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1053 this, SLOT(languagePackageChanged(int)));
1054 connect(langModule->dynamicQuotesCB, SIGNAL(clicked()),
1055 this, SLOT(change_adaptor()));
1057 langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1058 langModule->languagePackageLE));
1060 QAbstractItemModel * language_model = guiApp->languageModel();
1061 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1062 language_model->sort(0);
1063 langModule->languageCO->setModel(language_model);
1064 langModule->languageCO->setModelColumn(0);
1066 // Always put the default encoding in the first position.
1067 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1068 QStringList encodinglist;
1069 Encodings::const_iterator it = encodings.begin();
1070 Encodings::const_iterator const end = encodings.end();
1071 for (; it != end; ++it)
1073 encodinglist.append(qt_(it->guiName()));
1074 encodinglist.sort();
1075 langModule->encodingCO->addItems(encodinglist);
1077 langModule->languagePackageCO->addItem(
1078 qt_("Default"), toqstr("default"));
1079 langModule->languagePackageCO->addItem(
1080 qt_("Automatic"), toqstr("auto"));
1081 langModule->languagePackageCO->addItem(
1082 qt_("Always Babel"), toqstr("babel"));
1083 langModule->languagePackageCO->addItem(
1084 qt_("Custom"), toqstr("custom"));
1085 langModule->languagePackageCO->addItem(
1086 qt_("None[[language package]]"), toqstr("none"));
1090 colorModule = new UiWidget<Ui::ColorUi>(this);
1091 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1092 this, SLOT(changeFontColor()));
1093 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1094 this, SLOT(deleteFontColor()));
1095 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1096 this, SLOT(changeNoteFontColor()));
1097 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1098 this, SLOT(deleteNoteFontColor()));
1099 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1100 this, SLOT(changeBackgroundColor()));
1101 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1102 this, SLOT(deleteBackgroundColor()));
1103 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1104 this, SLOT(changeBoxBackgroundColor()));
1105 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1106 this, SLOT(deleteBoxBackgroundColor()));
1110 numberingModule = new UiWidget<Ui::NumberingUi>(this);
1111 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1112 this, SLOT(change_adaptor()));
1113 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1114 this, SLOT(change_adaptor()));
1115 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1116 this, SLOT(updateNumbering()));
1117 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1118 this, SLOT(updateNumbering()));
1119 numberingModule->tocTW->setColumnCount(3);
1120 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1121 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1122 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1123 setSectionResizeMode(numberingModule->tocTW->header(), QHeaderView::ResizeToContents);
1126 biblioModule = new UiWidget<Ui::BiblioUi>(this);
1127 connect(biblioModule->citeEngineCO, SIGNAL(activated(int)),
1128 this, SLOT(citeEngineChanged(int)));
1129 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1130 this, SLOT(citeStyleChanged()));
1131 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1132 this, SLOT(biblioChanged()));
1133 connect(biblioModule->bibunitsCO, SIGNAL(activated(int)),
1134 this, SLOT(biblioChanged()));
1135 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1136 this, SLOT(bibtexChanged(int)));
1137 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1138 this, SLOT(biblioChanged()));
1139 connect(biblioModule->citePackageOptionsLE, SIGNAL(textChanged(QString)),
1140 this, SLOT(biblioChanged()));
1141 connect(biblioModule->defaultBiblioCO, SIGNAL(activated(int)),
1142 this, SLOT(biblioChanged()));
1143 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1144 this, SLOT(biblioChanged()));
1145 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1146 this, SLOT(updateResetDefaultBiblio()));
1147 connect(biblioModule->biblatexBbxCO, SIGNAL(activated(int)),
1148 this, SLOT(biblioChanged()));
1149 connect(biblioModule->biblatexBbxCO, SIGNAL(editTextChanged(QString)),
1150 this, SLOT(updateResetDefaultBiblio()));
1151 connect(biblioModule->biblatexCbxCO, SIGNAL(activated(int)),
1152 this, SLOT(biblioChanged()));
1153 connect(biblioModule->biblatexCbxCO, SIGNAL(editTextChanged(QString)),
1154 this, SLOT(updateResetDefaultBiblio()));
1155 connect(biblioModule->rescanBibliosPB, SIGNAL(clicked()),
1156 this, SLOT(rescanBibFiles()));
1157 connect(biblioModule->resetDefaultBiblioPB, SIGNAL(clicked()),
1158 this, SLOT(resetDefaultBibfile()));
1159 connect(biblioModule->resetCbxPB, SIGNAL(clicked()),
1160 this, SLOT(resetDefaultCbxBibfile()));
1161 connect(biblioModule->resetBbxPB, SIGNAL(clicked()),
1162 this, SLOT(resetDefaultBbxBibfile()));
1163 connect(biblioModule->matchBbxPB, SIGNAL(clicked()),
1164 this, SLOT(matchBiblatexStyles()));
1166 biblioModule->citeEngineCO->clear();
1167 for (LyXCiteEngine const & cet : theCiteEnginesList) {
1168 biblioModule->citeEngineCO->addItem(qt_(cet.getName()), toqstr(cet.getID()));
1169 int const i = biblioModule->citeEngineCO->findData(toqstr(cet.getID()));
1170 biblioModule->citeEngineCO->setItemData(i, qt_(cet.getDescription()),
1174 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1175 biblioModule->bibtexOptionsLE));
1176 biblioModule->defaultBiblioCO->lineEdit()->setValidator(new NoNewLineValidator(
1177 biblioModule->defaultBiblioCO->lineEdit()));
1179 // NOTE: we do not provide "custom" here for security reasons!
1180 biblioModule->bibtexCO->clear();
1181 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1182 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1183 it != lyxrc.bibtex_alternatives.end(); ++it) {
1184 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1185 biblioModule->bibtexCO->addItem(command, command);
1190 indicesModule = new GuiIndices;
1191 connect(indicesModule, SIGNAL(changed()),
1192 this, SLOT(change_adaptor()));
1196 mathsModule = new UiWidget<Ui::MathsUi>(this);
1197 QStringList headers;
1198 headers << qt_("Package") << qt_("Load automatically")
1199 << qt_("Load always") << qt_("Do not load");
1200 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1201 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1202 map<string, string> const & packages = BufferParams::auto_packages();
1203 mathsModule->packagesTW->setRowCount(packages.size());
1205 for (map<string, string>::const_iterator it = packages.begin();
1206 it != packages.end(); ++it) {
1207 docstring const package = from_ascii(it->first);
1208 QString autoTooltip = qt_(it->second);
1209 QString alwaysTooltip;
1210 if (package == "amsmath")
1212 qt_("The AMS LaTeX packages are always used");
1214 alwaysTooltip = toqstr(bformat(
1215 _("The LaTeX package %1$s is always used"),
1217 QString neverTooltip;
1218 if (package == "amsmath")
1220 qt_("The AMS LaTeX packages are never used");
1222 neverTooltip = toqstr(bformat(
1223 _("The LaTeX package %1$s is never used"),
1225 QRadioButton * autoRB = new QRadioButton(mathsModule);
1226 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1227 QRadioButton * neverRB = new QRadioButton(mathsModule);
1228 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1229 packageGroup->addButton(autoRB);
1230 packageGroup->addButton(alwaysRB);
1231 packageGroup->addButton(neverRB);
1232 autoRB->setToolTip(autoTooltip);
1233 alwaysRB->setToolTip(alwaysTooltip);
1234 neverRB->setToolTip(neverTooltip);
1235 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1236 mathsModule->packagesTW->setItem(i, 0, pack);
1237 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1238 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1239 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1241 connect(autoRB, SIGNAL(clicked()),
1242 this, SLOT(change_adaptor()));
1243 connect(alwaysRB, SIGNAL(clicked()),
1244 this, SLOT(change_adaptor()));
1245 connect(neverRB, SIGNAL(clicked()),
1246 this, SLOT(change_adaptor()));
1249 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1250 this, SLOT(allPackagesAuto()));
1251 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1252 this, SLOT(allPackagesAlways()));
1253 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1254 this, SLOT(allPackagesNot()));
1255 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1256 this, SLOT(change_adaptor()));
1257 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1258 this, SLOT(change_adaptor()));
1259 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1260 this, SLOT(change_adaptor()));
1261 connect(mathsModule->MathNumberingPosCO, SIGNAL(activated(int)),
1262 this, SLOT(change_adaptor()));
1264 connect(mathsModule->MathIndentCB, SIGNAL(toggled(bool)),
1265 this, SLOT(change_adaptor()));
1266 connect(mathsModule->MathIndentCB, SIGNAL(toggled(bool)),
1267 this, SLOT(allowMathIndent()));
1268 connect(mathsModule->MathIndentCO, SIGNAL(activated(int)),
1269 this, SLOT(change_adaptor()));
1270 connect(mathsModule->MathIndentCO, SIGNAL(activated(int)),
1271 this, SLOT(enableMathIndent(int)));
1272 connect(mathsModule->MathIndentLE, SIGNAL(textChanged(const QString &)),
1273 this, SLOT(change_adaptor()));
1274 connect(mathsModule->MathIndentLengthCO, SIGNAL(activated(int)),
1275 this, SLOT(change_adaptor()));
1278 mathsModule->MathIndentCO->addItem(qt_("Default"));
1279 mathsModule->MathIndentCO->addItem(qt_("Custom"));
1280 mathsModule->MathIndentLE->setValidator(new LengthValidator(
1281 mathsModule->MathIndentLE));
1282 // initialize the length validator
1283 bc().addCheckedLineEdit(mathsModule->MathIndentLE);
1284 mathsModule->MathNumberingPosCO->addItem(qt_("Left"));
1285 mathsModule->MathNumberingPosCO->addItem(qt_("Default"));
1286 mathsModule->MathNumberingPosCO->addItem(qt_("Right"));
1287 mathsModule->MathNumberingPosCO->setCurrentIndex(1);
1291 latexModule = new UiWidget<Ui::LaTeXUi>(this);
1292 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1293 this, SLOT(change_adaptor()));
1294 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1295 this, SLOT(change_adaptor()));
1296 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1297 this, SLOT(change_adaptor()));
1298 connect(latexModule->classCO, SIGNAL(activated(int)),
1299 this, SLOT(classChanged_adaptor()));
1300 connect(latexModule->classCO, SIGNAL(activated(int)),
1301 this, SLOT(change_adaptor()));
1302 connect(latexModule->layoutPB, SIGNAL(clicked()),
1303 this, SLOT(browseLayout()));
1304 connect(latexModule->layoutPB, SIGNAL(clicked()),
1305 this, SLOT(change_adaptor()));
1306 connect(latexModule->childDocGB, SIGNAL(clicked()),
1307 this, SLOT(change_adaptor()));
1308 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1309 this, SLOT(change_adaptor()));
1310 connect(latexModule->childDocPB, SIGNAL(clicked()),
1311 this, SLOT(browseMaster()));
1312 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1313 this, SLOT(change_adaptor()));
1314 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1315 this, SLOT(change_adaptor()));
1317 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1318 latexModule->optionsLE));
1319 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1320 latexModule->childDocLE));
1322 // postscript drivers
1323 for (int n = 0; tex_graphics[n][0]; ++n) {
1324 QString enc = qt_(tex_graphics_gui[n]);
1325 latexModule->psdriverCO->addItem(enc);
1328 LayoutFileList const & bcl = LayoutFileList::get();
1329 vector<LayoutFileIndex> classList = bcl.classList();
1330 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1332 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1333 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1334 for (int i = 0; cit != cen; ++cit, ++i) {
1335 LayoutFile const & tc = bcl[*cit];
1336 bool const available = tc.isTeXClassAvailable();
1337 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1338 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1339 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1341 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1342 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1343 "Please check if you have the matching %1$s class "
1344 "and all required packages (%2$s) installed."),
1345 output_type, from_utf8(tc.prerequisites(", "))));
1347 latexModule->classCO->addItemSort(toqstr(tc.name()),
1349 toqstr(translateIfPossible(from_utf8(tc.category()))),
1351 true, true, true, available);
1356 branchesModule = new GuiBranches(this);
1357 connect(branchesModule, SIGNAL(changed()),
1358 this, SLOT(change_adaptor()));
1359 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1360 this, SLOT(branchesRename(docstring const &, docstring const &)));
1361 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1362 updateUnknownBranches();
1366 preambleModule = new PreambleModule(this);
1367 connect(preambleModule, SIGNAL(changed()),
1368 this, SLOT(change_adaptor()));
1370 localLayout = new LocalLayout(this);
1371 connect(localLayout, SIGNAL(changed()),
1372 this, SLOT(change_adaptor()));
1376 bulletsModule = new BulletsModule(this);
1377 connect(bulletsModule, SIGNAL(changed()),
1378 this, SLOT(change_adaptor()));
1382 modulesModule = new UiWidget<Ui::ModulesUi>(this);
1383 modulesModule->availableLV->header()->setVisible(false);
1384 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1385 modulesModule->availableLV->header()->setStretchLastSection(false);
1387 new ModuleSelectionManager(this, modulesModule->availableLV,
1388 modulesModule->selectedLV,
1389 modulesModule->addPB,
1390 modulesModule->deletePB,
1391 modulesModule->upPB,
1392 modulesModule->downPB,
1393 availableModel(), selectedModel(), this);
1394 connect(selectionManager, SIGNAL(updateHook()),
1395 this, SLOT(updateModuleInfo()));
1396 connect(selectionManager, SIGNAL(selectionChanged()),
1397 this, SLOT(modulesChanged()));
1401 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>(this);
1402 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1403 this, SLOT(change_adaptor()));
1404 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1405 this, SLOT(change_adaptor()));
1406 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1407 this, SLOT(change_adaptor()));
1408 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1409 this, SLOT(change_adaptor()));
1410 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1411 this, SLOT(change_adaptor()));
1412 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1413 this, SLOT(change_adaptor()));
1414 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1415 this, SLOT(change_adaptor()));
1416 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1417 this, SLOT(change_adaptor()));
1418 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1419 this, SLOT(change_adaptor()));
1420 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1421 this, SLOT(change_adaptor()));
1422 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1423 this, SLOT(change_adaptor()));
1424 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1425 this, SLOT(change_adaptor()));
1426 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1427 this, SLOT(change_adaptor()));
1428 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1429 this, SLOT(change_adaptor()));
1430 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1431 this, SLOT(change_adaptor()));
1432 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1433 this, SLOT(change_adaptor()));
1435 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1436 pdfSupportModule->titleLE));
1437 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1438 pdfSupportModule->authorLE));
1439 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1440 pdfSupportModule->subjectLE));
1441 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1442 pdfSupportModule->keywordsLE));
1443 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1444 pdfSupportModule->optionsLE));
1446 for (int i = 0; backref_opts[i][0]; ++i)
1447 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1451 floatModule = new FloatPlacement;
1452 connect(floatModule, SIGNAL(changed()),
1453 this, SLOT(change_adaptor()));
1457 listingsModule = new UiWidget<Ui::ListingsSettingsUi>(this);
1458 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1459 this, SLOT(change_adaptor()));
1460 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1461 this, SLOT(change_adaptor()));
1462 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1463 this, SLOT(setListingsMessage()));
1464 connect(listingsModule->mintedCB, SIGNAL(clicked()),
1465 this, SLOT(change_adaptor()));
1466 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1467 this, SLOT(setListingsMessage()));
1468 listingsModule->listingsTB->setPlainText(
1469 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1473 docPS->addPanel(latexModule, N_("Document Class"));
1474 docPS->addPanel(masterChildModule, N_("Child Documents"));
1475 docPS->addPanel(modulesModule, N_("Modules"));
1476 docPS->addPanel(localLayout, N_("Local Layout"));
1477 docPS->addPanel(fontModule, N_("Fonts"));
1478 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1479 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1480 docPS->addPanel(marginsModule, N_("Page Margins"));
1481 docPS->addPanel(langModule, N_("Language"));
1482 docPS->addPanel(colorModule, N_("Colors"));
1483 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1484 docPS->addPanel(biblioModule, N_("Bibliography"));
1485 docPS->addPanel(indicesModule, N_("Indexes"));
1486 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1487 docPS->addPanel(mathsModule, N_("Math Options"));
1488 docPS->addPanel(floatModule, N_("Float Placement"));
1489 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1490 docPS->addPanel(bulletsModule, N_("Bullets"));
1491 docPS->addPanel(branchesModule, N_("Branches"));
1492 docPS->addPanel(outputModule, N_("Formats[[output]]"));
1493 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1494 docPS->setCurrentPanel("Document Class");
1495 // FIXME: hack to work around resizing bug in Qt >= 4.2
1496 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1497 #if QT_VERSION >= 0x040200
1498 docPS->updateGeometry();
1503 void GuiDocument::onBufferViewChanged()
1505 if (isVisibleView())
1506 initialiseParams("");
1510 void GuiDocument::saveDefaultClicked()
1516 void GuiDocument::useDefaultsClicked()
1522 void GuiDocument::change_adaptor()
1524 nonModuleChanged_ = true;
1529 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1534 string child = fromqstr(item->text(0));
1538 if (std::find(includeonlys_.begin(),
1539 includeonlys_.end(), child) != includeonlys_.end())
1540 includeonlys_.remove(child);
1542 includeonlys_.push_back(child);
1544 updateIncludeonlys();
1549 QString GuiDocument::validateListingsParameters()
1551 if (listingsModule->bypassCB->isChecked())
1553 string params = fromqstr(listingsModule->listingsED->toPlainText());
1554 return toqstr(InsetListingsParams(params).validate());
1558 void GuiDocument::setListingsMessage()
1561 static bool isOK = true;
1562 QString msg = validateListingsParameters();
1563 if (msg.isEmpty()) {
1567 // listingsTB->setTextColor("black");
1568 listingsModule->listingsTB->setPlainText(
1569 qt_("Input listings parameters below. "
1570 "Enter ? for a list of parameters."));
1573 // listingsTB->setTextColor("red");
1574 listingsModule->listingsTB->setPlainText(msg);
1579 void GuiDocument::setLSpacing(int item)
1581 textLayoutModule->lspacingLE->setEnabled(item == 3);
1585 void GuiDocument::setIndent(int item)
1587 bool const enable = (item == 1);
1588 textLayoutModule->indentLE->setEnabled(enable);
1589 textLayoutModule->indentLengthCO->setEnabled(enable);
1590 textLayoutModule->skipLE->setEnabled(false);
1591 textLayoutModule->skipLengthCO->setEnabled(false);
1596 void GuiDocument::enableIndent(bool indent)
1598 textLayoutModule->skipLE->setEnabled(!indent);
1599 textLayoutModule->skipLengthCO->setEnabled(!indent);
1601 setIndent(textLayoutModule->indentCO->currentIndex());
1605 void GuiDocument::setSkip(int item)
1607 bool const enable = (item == 3);
1608 textLayoutModule->skipLE->setEnabled(enable);
1609 textLayoutModule->skipLengthCO->setEnabled(enable);
1614 void GuiDocument::enableSkip(bool skip)
1616 textLayoutModule->indentLE->setEnabled(!skip);
1617 textLayoutModule->indentLengthCO->setEnabled(!skip);
1619 setSkip(textLayoutModule->skipCO->currentIndex());
1622 void GuiDocument::allowMathIndent() {
1623 // only disable when not checked, checked does not always allow enabling
1624 if (!mathsModule->MathIndentCB->isChecked()) {
1625 mathsModule->MathIndentLE->setEnabled(false);
1626 mathsModule->MathIndentLengthCO->setEnabled(false);
1628 if (mathsModule->MathIndentCB->isChecked()
1629 && mathsModule->MathIndentCO->currentIndex() == 1) {
1630 mathsModule->MathIndentLE->setEnabled(true);
1631 mathsModule->MathIndentLengthCO->setEnabled(true);
1636 void GuiDocument::enableMathIndent(int item)
1638 bool const enable = (item == 1);
1639 mathsModule->MathIndentLE->setEnabled(enable);
1640 mathsModule->MathIndentLengthCO->setEnabled(enable);
1645 void GuiDocument::setMargins()
1647 bool const extern_geometry =
1648 documentClass().provides("geometry");
1649 marginsModule->marginCB->setEnabled(!extern_geometry);
1650 if (extern_geometry) {
1651 marginsModule->marginCB->setChecked(false);
1652 setCustomMargins(true);
1654 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1655 setCustomMargins(!bp_.use_geometry);
1660 void GuiDocument::papersizeChanged(int paper_size)
1662 setCustomPapersize(paper_size == 1);
1666 void GuiDocument::setCustomPapersize(bool custom)
1668 pageLayoutModule->paperwidthL->setEnabled(custom);
1669 pageLayoutModule->paperwidthLE->setEnabled(custom);
1670 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1671 pageLayoutModule->paperheightL->setEnabled(custom);
1672 pageLayoutModule->paperheightLE->setEnabled(custom);
1673 pageLayoutModule->paperheightLE->setFocus();
1674 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1678 void GuiDocument::setColSep()
1680 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1684 void GuiDocument::setCustomMargins(bool custom)
1686 marginsModule->topL->setEnabled(!custom);
1687 marginsModule->topLE->setEnabled(!custom);
1688 marginsModule->topUnit->setEnabled(!custom);
1690 marginsModule->bottomL->setEnabled(!custom);
1691 marginsModule->bottomLE->setEnabled(!custom);
1692 marginsModule->bottomUnit->setEnabled(!custom);
1694 marginsModule->innerL->setEnabled(!custom);
1695 marginsModule->innerLE->setEnabled(!custom);
1696 marginsModule->innerUnit->setEnabled(!custom);
1698 marginsModule->outerL->setEnabled(!custom);
1699 marginsModule->outerLE->setEnabled(!custom);
1700 marginsModule->outerUnit->setEnabled(!custom);
1702 marginsModule->headheightL->setEnabled(!custom);
1703 marginsModule->headheightLE->setEnabled(!custom);
1704 marginsModule->headheightUnit->setEnabled(!custom);
1706 marginsModule->headsepL->setEnabled(!custom);
1707 marginsModule->headsepLE->setEnabled(!custom);
1708 marginsModule->headsepUnit->setEnabled(!custom);
1710 marginsModule->footskipL->setEnabled(!custom);
1711 marginsModule->footskipLE->setEnabled(!custom);
1712 marginsModule->footskipUnit->setEnabled(!custom);
1714 bool const enableColSep = !custom &&
1715 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1716 marginsModule->columnsepL->setEnabled(enableColSep);
1717 marginsModule->columnsepLE->setEnabled(enableColSep);
1718 marginsModule->columnsepUnit->setEnabled(enableColSep);
1722 void GuiDocument::changeBackgroundColor()
1724 QColor const & newColor = QColorDialog::getColor(
1725 rgb2qcolor(set_backgroundcolor), asQWidget());
1726 if (!newColor.isValid())
1728 // set the button color and text
1729 colorModule->backgroundPB->setStyleSheet(
1730 colorButtonStyleSheet(newColor));
1731 colorModule->backgroundPB->setText(qt_("&Change..."));
1733 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1734 is_backgroundcolor = true;
1739 void GuiDocument::deleteBackgroundColor()
1741 // set the button color back to default by setting an empty StyleSheet
1742 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1743 // change button text
1744 colorModule->backgroundPB->setText(qt_("&Default..."));
1745 // save default color (white)
1746 set_backgroundcolor = rgbFromHexName("#ffffff");
1747 is_backgroundcolor = false;
1752 void GuiDocument::changeFontColor()
1754 QColor const & newColor = QColorDialog::getColor(
1755 rgb2qcolor(set_fontcolor), asQWidget());
1756 if (!newColor.isValid())
1758 // set the button color and text
1759 colorModule->fontColorPB->setStyleSheet(
1760 colorButtonStyleSheet(newColor));
1761 colorModule->fontColorPB->setText(qt_("&Change..."));
1763 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1764 is_fontcolor = true;
1769 void GuiDocument::deleteFontColor()
1771 // set the button color back to default by setting an empty StyleSheet
1772 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1773 // change button text
1774 colorModule->fontColorPB->setText(qt_("&Default..."));
1775 // save default color (black)
1776 set_fontcolor = rgbFromHexName("#000000");
1777 is_fontcolor = false;
1782 void GuiDocument::changeNoteFontColor()
1784 QColor const & newColor = QColorDialog::getColor(
1785 rgb2qcolor(set_notefontcolor), asQWidget());
1786 if (!newColor.isValid())
1788 // set the button color
1789 colorModule->noteFontColorPB->setStyleSheet(
1790 colorButtonStyleSheet(newColor));
1792 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1797 void GuiDocument::deleteNoteFontColor()
1799 // set the button color back to pref
1800 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1801 colorModule->noteFontColorPB->setStyleSheet(
1802 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1807 void GuiDocument::changeBoxBackgroundColor()
1809 QColor const & newColor = QColorDialog::getColor(
1810 rgb2qcolor(set_boxbgcolor), asQWidget());
1811 if (!newColor.isValid())
1813 // set the button color
1814 colorModule->boxBackgroundPB->setStyleSheet(
1815 colorButtonStyleSheet(newColor));
1817 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1822 void GuiDocument::deleteBoxBackgroundColor()
1824 // set the button color back to pref
1825 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1826 colorModule->boxBackgroundPB->setStyleSheet(
1827 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1832 void GuiDocument::updateQuoteStyles(bool const set)
1834 Language const * lang = lyx::languages.getLanguage(
1835 fromqstr(langModule->languageCO->itemData(
1836 langModule->languageCO->currentIndex()).toString()));
1838 InsetQuotesParams::QuoteStyle def = bp_.getQuoteStyle(lang->quoteStyle());
1840 langModule->quoteStyleCO->clear();
1842 bool has_default = false;
1843 for (int i = 0; i < quoteparams.stylescount(); ++i) {
1844 InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::QuoteStyle(i);
1845 if (qs == InsetQuotesParams::DynamicQuotes)
1847 bool const langdef = (qs == def);
1849 // add the default style on top
1850 langModule->quoteStyleCO->insertItem(0,
1851 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1855 langModule->quoteStyleCO->addItem(
1856 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1858 if (set && has_default)
1859 // (re)set to the default style
1860 langModule->quoteStyleCO->setCurrentIndex(0);
1864 void GuiDocument::languageChanged(int i)
1866 // some languages only work with polyglossia
1867 Language const * lang = lyx::languages.getLanguage(
1868 fromqstr(langModule->languageCO->itemData(i).toString()));
1869 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1870 // If we force to switch fontspec on, store
1871 // current state (#8717)
1872 if (fontModule->osFontsCB->isEnabled())
1873 forced_fontspec_activation =
1874 !fontModule->osFontsCB->isChecked();
1875 fontModule->osFontsCB->setChecked(true);
1876 fontModule->osFontsCB->setEnabled(false);
1879 fontModule->osFontsCB->setEnabled(true);
1880 // If we have forced to switch fontspec on,
1881 // restore previous state (#8717)
1882 if (forced_fontspec_activation)
1883 fontModule->osFontsCB->setChecked(false);
1884 forced_fontspec_activation = false;
1887 // set appropriate quotation mark style
1888 updateQuoteStyles(true);
1892 void GuiDocument::osFontsChanged(bool nontexfonts)
1894 bool const tex_fonts = !nontexfonts;
1895 // store current fonts
1896 QString const font_roman = fontModule->fontsRomanCO->itemData(
1897 fontModule->fontsRomanCO->currentIndex()).toString();
1898 QString const font_sans = fontModule->fontsSansCO->itemData(
1899 fontModule->fontsSansCO->currentIndex()).toString();
1900 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1901 fontModule->fontsTypewriterCO->currentIndex()).toString();
1902 QString const font_math = fontModule->fontsMathCO->itemData(
1903 fontModule->fontsMathCO->currentIndex()).toString();
1904 int const font_sf_scale = fontModule->scaleSansSB->value();
1905 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1908 // store default format
1909 QString const dformat = outputModule->defaultFormatCO->itemData(
1910 outputModule->defaultFormatCO->currentIndex()).toString();
1911 updateDefaultFormat();
1912 // try to restore default format
1913 int index = outputModule->defaultFormatCO->findData(dformat);
1914 // set to default if format is not found
1917 outputModule->defaultFormatCO->setCurrentIndex(index);
1919 // try to restore fonts which were selected two toggles ago
1920 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1922 fontModule->fontsRomanCO->setCurrentIndex(index);
1923 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1925 fontModule->fontsSansCO->setCurrentIndex(index);
1926 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1928 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1929 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1931 fontModule->fontsMathCO->setCurrentIndex(index);
1932 // save fonts for next next toggle
1933 fontModule->font_roman = font_roman;
1934 fontModule->font_sans = font_sans;
1935 fontModule->font_typewriter = font_typewriter;
1936 fontModule->font_math = font_math;
1937 fontModule->font_sf_scale = font_sf_scale;
1938 fontModule->font_tt_scale = font_tt_scale;
1940 langModule->encodingCO->setEnabled(tex_fonts &&
1941 !langModule->defaultencodingRB->isChecked());
1942 langModule->defaultencodingRB->setEnabled(tex_fonts);
1943 langModule->otherencodingRB->setEnabled(tex_fonts);
1945 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1946 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1947 fontModule->cjkFontLE->setEnabled(tex_fonts);
1948 fontModule->cjkFontLA->setEnabled(tex_fonts);
1950 updateFontOptions();
1952 fontModule->fontencLA->setEnabled(tex_fonts);
1953 fontModule->fontencCO->setEnabled(tex_fonts);
1955 fontModule->fontencLE->setEnabled(false);
1957 fontencChanged(fontModule->fontencCO->currentIndex());
1961 void GuiDocument::mathFontChanged(int)
1963 updateFontOptions();
1967 void GuiDocument::fontOsfToggled(bool state)
1969 if (fontModule->osFontsCB->isChecked())
1971 QString font = fontModule->fontsRomanCO->itemData(
1972 fontModule->fontsRomanCO->currentIndex()).toString();
1973 if (hasMonolithicExpertSet(font))
1974 fontModule->fontScCB->setChecked(state);
1978 void GuiDocument::fontScToggled(bool state)
1980 if (fontModule->osFontsCB->isChecked())
1982 QString font = fontModule->fontsRomanCO->itemData(
1983 fontModule->fontsRomanCO->currentIndex()).toString();
1984 if (hasMonolithicExpertSet(font))
1985 fontModule->fontOsfCB->setChecked(state);
1989 void GuiDocument::updateFontOptions()
1991 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1994 font = fontModule->fontsSansCO->itemData(
1995 fontModule->fontsSansCO->currentIndex()).toString();
1996 bool scaleable = providesScale(font);
1997 fontModule->scaleSansSB->setEnabled(scaleable);
1998 fontModule->scaleSansLA->setEnabled(scaleable);
2000 font = fontModule->fontsTypewriterCO->itemData(
2001 fontModule->fontsTypewriterCO->currentIndex()).toString();
2002 scaleable = providesScale(font);
2003 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2004 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2006 font = fontModule->fontsRomanCO->itemData(
2007 fontModule->fontsRomanCO->currentIndex()).toString();
2008 fontModule->fontScCB->setEnabled(providesSC(font));
2009 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2010 fontModule->dashesCB->setEnabled(tex_fonts);
2011 updateMathFonts(font);
2015 void GuiDocument::updateFontsize(string const & items, string const & sel)
2017 fontModule->fontsizeCO->clear();
2018 fontModule->fontsizeCO->addItem(qt_("Default"));
2020 for (int n = 0; !token(items,'|',n).empty(); ++n)
2021 fontModule->fontsizeCO->
2022 addItem(toqstr(token(items,'|',n)));
2024 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
2025 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
2026 fontModule->fontsizeCO->setCurrentIndex(n);
2033 bool GuiDocument::ot1() const
2035 QString const fontenc =
2036 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
2037 return (fontenc == "default"
2038 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
2039 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
2043 bool GuiDocument::completeFontset() const
2045 return (fontModule->fontsSansCO->itemData(
2046 fontModule->fontsSansCO->currentIndex()).toString() == "default"
2047 && fontModule->fontsSansCO->itemData(
2048 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
2052 bool GuiDocument::noMathFont() const
2054 return (fontModule->fontsMathCO->itemData(
2055 fontModule->fontsMathCO->currentIndex()).toString() == "default");
2059 void GuiDocument::updateTexFonts()
2061 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
2063 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
2064 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
2065 for (; it != end; ++it) {
2066 LaTeXFont lf = it->second;
2067 if (lf.name().empty()) {
2068 LYXERR0("Error: Unnamed font: " << it->first);
2071 docstring const family = lf.family();
2072 docstring guiname = translateIfPossible(lf.guiname());
2073 if (!lf.available(ot1(), noMathFont()))
2074 guiname += _(" (not installed)");
2076 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
2077 else if (family == "sf")
2078 sffonts_.insert(toqstr(guiname), toqstr(it->first));
2079 else if (family == "tt")
2080 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
2081 else if (family == "math")
2082 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
2087 void GuiDocument::updateFontlist()
2089 fontModule->fontsRomanCO->clear();
2090 fontModule->fontsSansCO->clear();
2091 fontModule->fontsTypewriterCO->clear();
2092 fontModule->fontsMathCO->clear();
2094 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
2095 if (fontModule->osFontsCB->isChecked()) {
2096 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2097 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2098 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2099 QString unimath = qt_("Non-TeX Fonts Default");
2100 if (!LaTeXFeatures::isAvailable("unicode-math"))
2101 unimath += qt_(" (not available)");
2102 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
2103 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2105 QFontDatabase fontdb;
2106 QStringList families(fontdb.families());
2107 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2108 fontModule->fontsRomanCO->addItem(*it, *it);
2109 fontModule->fontsSansCO->addItem(*it, *it);
2110 fontModule->fontsTypewriterCO->addItem(*it, *it);
2115 if (rmfonts_.empty())
2118 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2119 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2120 while (rmi != rmfonts_.constEnd()) {
2121 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2125 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2126 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2127 while (sfi != sffonts_.constEnd()) {
2128 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2132 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2133 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2134 while (tti != ttfonts_.constEnd()) {
2135 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2139 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2140 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2141 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2142 while (mmi != mathfonts_.constEnd()) {
2143 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2149 void GuiDocument::fontencChanged(int item)
2151 fontModule->fontencLE->setEnabled(
2152 fontModule->fontencCO->itemData(item).toString() == "custom");
2153 // The availability of TeX fonts depends on the font encoding
2155 updateFontOptions();
2159 void GuiDocument::updateMathFonts(QString const & rm)
2161 if (fontModule->osFontsCB->isChecked())
2163 QString const math =
2164 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2165 int const i = fontModule->fontsMathCO->findData("default");
2166 if (providesNoMath(rm) && i == -1)
2167 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2168 else if (!providesNoMath(rm) && i != -1) {
2169 int const c = fontModule->fontsMathCO->currentIndex();
2170 fontModule->fontsMathCO->removeItem(i);
2172 fontModule->fontsMathCO->setCurrentIndex(0);
2177 void GuiDocument::romanChanged(int item)
2179 if (fontModule->osFontsCB->isChecked())
2181 QString const font =
2182 fontModule->fontsRomanCO->itemData(item).toString();
2183 fontModule->fontScCB->setEnabled(providesSC(font));
2184 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2185 updateMathFonts(font);
2189 void GuiDocument::sansChanged(int item)
2191 if (fontModule->osFontsCB->isChecked())
2193 QString const font =
2194 fontModule->fontsSansCO->itemData(item).toString();
2195 bool scaleable = providesScale(font);
2196 fontModule->scaleSansSB->setEnabled(scaleable);
2197 fontModule->scaleSansLA->setEnabled(scaleable);
2201 void GuiDocument::ttChanged(int item)
2203 if (fontModule->osFontsCB->isChecked())
2205 QString const font =
2206 fontModule->fontsTypewriterCO->itemData(item).toString();
2207 bool scaleable = providesScale(font);
2208 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2209 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2213 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2216 pageLayoutModule->pagestyleCO->clear();
2217 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2219 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2220 string style = token(items, '|', n);
2221 QString style_gui = qt_(style);
2222 pagestyles.push_back(pair<string, QString>(style, style_gui));
2223 pageLayoutModule->pagestyleCO->addItem(style_gui);
2226 if (sel == "default") {
2227 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2233 for (size_t i = 0; i < pagestyles.size(); ++i)
2234 if (pagestyles[i].first == sel)
2235 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2238 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2242 void GuiDocument::browseLayout()
2244 QString const label1 = qt_("Layouts|#o#O");
2245 QString const dir1 = toqstr(lyxrc.document_path);
2246 QStringList const filter(qt_("LyX Layout (*.layout)"));
2247 QString file = browseRelToParent(QString(), bufferFilePath(),
2248 qt_("Local layout file"), filter, false,
2251 if (!file.endsWith(".layout"))
2254 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2255 fromqstr(bufferFilePath()));
2257 int const ret = Alert::prompt(_("Local layout file"),
2258 _("The layout file you have selected is a local layout\n"
2259 "file, not one in the system or user directory.\n"
2260 "Your document will not work with this layout if you\n"
2261 "move the layout file to a different directory."),
2262 1, 1, _("&Set Layout"), _("&Cancel"));
2266 // load the layout file
2267 LayoutFileList & bcl = LayoutFileList::get();
2268 string classname = layoutFile.onlyFileName();
2269 // this will update an existing layout if that layout has been loaded before.
2270 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2271 classname.substr(0, classname.size() - 7),
2272 layoutFile.onlyPath().absFileName()));
2275 Alert::error(_("Error"),
2276 _("Unable to read local layout file."));
2280 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2282 // do not trigger classChanged if there is no change.
2283 if (latexModule->classCO->currentText() == toqstr(name))
2287 bool const avail = latexModule->classCO->set(toqstr(name));
2289 LayoutFile const & tc = bcl[name];
2290 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2291 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2292 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2293 tooltip += '\n' + qt_("This is a local layout file.");
2294 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2295 toqstr(translateIfPossible(from_utf8(tc.category()))),
2297 true, true, true, true);
2298 latexModule->classCO->set(toqstr(name));
2305 void GuiDocument::browseMaster()
2307 QString const title = qt_("Select master document");
2308 QString const dir1 = toqstr(lyxrc.document_path);
2309 QString const old = latexModule->childDocLE->text();
2310 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2311 QStringList const filter(qt_("LyX Files (*.lyx)"));
2312 QString file = browseRelToSub(old, docpath, title, filter, false,
2313 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2315 if (!file.isEmpty())
2316 latexModule->childDocLE->setText(file);
2320 void GuiDocument::classChanged_adaptor()
2322 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2327 void GuiDocument::classChanged()
2329 int idx = latexModule->classCO->currentIndex();
2332 string const classname = fromqstr(latexModule->classCO->getData(idx));
2334 if (applyPB->isEnabled()) {
2335 int const ret = Alert::prompt(_("Unapplied changes"),
2336 _("Some changes in the dialog were not yet applied.\n"
2337 "If you do not apply now, they will be lost after this action."),
2338 1, 1, _("&Apply"), _("&Dismiss"));
2343 // We load the TextClass as soon as it is selected. This is
2344 // necessary so that other options in the dialog can be updated
2345 // according to the new class. Note, however, that, if you use
2346 // the scroll wheel when sitting on the combo box, we'll load a
2347 // lot of TextClass objects very quickly....
2348 if (!bp_.setBaseClass(classname)) {
2349 Alert::error(_("Error"), _("Unable to set document class."));
2352 if (lyxrc.auto_reset_options)
2353 bp_.useClassDefaults();
2355 // With the introduction of modules came a distinction between the base
2356 // class and the document class. The former corresponds to the main layout
2357 // file; the latter is that plus the modules (or the document-specific layout,
2358 // or whatever else there could be). Our parameters come from the document
2359 // class. So when we set the base class, we also need to recreate the document
2360 // class. Otherwise, we still have the old one.
2361 bp_.makeDocumentClass();
2366 void GuiDocument::languagePackageChanged(int i)
2368 langModule->languagePackageLE->setEnabled(
2369 langModule->languagePackageCO->itemData(i).toString() == "custom");
2373 void GuiDocument::biblioChanged()
2375 biblioChanged_ = true;
2380 void GuiDocument::rescanBibFiles()
2383 rescanTexStyles("bbx cbx");
2385 rescanTexStyles("bst");
2389 void GuiDocument::resetDefaultBibfile(string const & which)
2391 QString const engine =
2392 biblioModule->citeEngineCO->itemData(
2393 biblioModule->citeEngineCO->currentIndex()).toString();
2395 CiteEngineType const cet =
2396 CiteEngineType(biblioModule->citeStyleCO->itemData(
2397 biblioModule->citeStyleCO->currentIndex()).toInt());
2399 updateDefaultBiblio(theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet), which);
2403 void GuiDocument::resetDefaultBbxBibfile()
2405 resetDefaultBibfile("bbx");
2409 void GuiDocument::resetDefaultCbxBibfile()
2411 resetDefaultBibfile("cbx");
2415 void GuiDocument::citeEngineChanged(int n)
2417 QString const engine =
2418 biblioModule->citeEngineCO->itemData(n).toString();
2420 vector<string> const engs =
2421 theCiteEnginesList[fromqstr(engine)]->getEngineType();
2423 updateCiteStyles(engs);
2424 updateEngineDependends();
2425 resetDefaultBibfile();
2430 void GuiDocument::updateEngineDependends()
2432 bool const biblatex = isBiblatex();
2434 // These are only useful with BibTeX
2435 biblioModule->defaultBiblioCO->setEnabled(!biblatex);
2436 biblioModule->bibtexStyleLA->setEnabled(!biblatex);
2437 biblioModule->resetDefaultBiblioPB->setEnabled(!biblatex);
2438 biblioModule->bibtopicCB->setEnabled(!biblatex);
2440 // These are only useful with Biblatex
2441 biblioModule->biblatexBbxCO->setEnabled(biblatex);
2442 biblioModule->biblatexBbxLA->setEnabled(biblatex);
2443 biblioModule->biblatexCbxCO->setEnabled(biblatex);
2444 biblioModule->biblatexCbxLA->setEnabled(biblatex);
2445 biblioModule->resetBbxPB->setEnabled(biblatex);
2446 biblioModule->resetCbxPB->setEnabled(biblatex);
2447 biblioModule->matchBbxPB->setEnabled(biblatex);
2449 // These are useful with biblatex, jurabib and natbib
2450 QString const engine =
2451 biblioModule->citeEngineCO->itemData(
2452 biblioModule->citeEngineCO->currentIndex()).toString();
2453 LyXCiteEngine const * ce = theCiteEnginesList[fromqstr(engine)];
2455 bool const citepack = ce->requires("biblatex.sty") || ce->requires("jurabib.sty")
2456 || ce->requires("natbib.sty");
2457 biblioModule->citePackageOptionsLE->setEnabled(citepack);
2458 biblioModule->citePackageOptionsL->setEnabled(citepack);
2462 void GuiDocument::citeStyleChanged()
2464 QString const engine =
2465 biblioModule->citeEngineCO->itemData(
2466 biblioModule->citeEngineCO->currentIndex()).toString();
2467 QString const currentDef = isBiblatex() ?
2468 biblioModule->biblatexBbxCO->currentText()
2469 : biblioModule->defaultBiblioCO->currentText();
2470 if (theCiteEnginesList[fromqstr(engine)]->isDefaultBiblio(fromqstr(currentDef)))
2471 resetDefaultBibfile();
2477 void GuiDocument::bibtexChanged(int n)
2479 biblioModule->bibtexOptionsLE->setEnabled(
2480 biblioModule->bibtexCO->itemData(n).toString() != "default");
2485 void GuiDocument::updateCiteStyles(vector<string> const & engs, CiteEngineType const & sel)
2487 biblioModule->citeStyleCO->clear();
2489 vector<string>::const_iterator it = engs.begin();
2490 vector<string>::const_iterator end = engs.end();
2491 for (; it != end; ++it) {
2492 if (*it == "default")
2493 biblioModule->citeStyleCO->addItem(qt_("Basic numerical"),
2494 ENGINE_TYPE_DEFAULT);
2495 else if (*it == "authoryear")
2496 biblioModule->citeStyleCO->addItem(qt_("Author-year"),
2497 ENGINE_TYPE_AUTHORYEAR);
2498 else if (*it == "numerical")
2499 biblioModule->citeStyleCO->addItem(qt_("Author-number"),
2500 ENGINE_TYPE_NUMERICAL);
2502 int i = biblioModule->citeStyleCO->findData(sel);
2503 if (biblioModule->citeStyleCO->findData(sel) == -1)
2505 biblioModule->citeStyleCO->setCurrentIndex(i);
2507 biblioModule->citationStyleL->setEnabled(engs.size() > 1);
2508 biblioModule->citeStyleCO->setEnabled(engs.size() > 1);
2512 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2514 engine_types_.clear();
2518 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2520 string style = token(items, '|', n);
2521 engine_types_.push_back(style);
2524 updateCiteStyles(engine_types_, sel);
2530 // both of these should take a vector<docstring>
2532 // This is an insanely complicated attempt to make this sort of thing
2533 // work with RTL languages.
2534 docstring formatStrVec(vector<string> const & v, docstring const & s)
2536 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2540 return translateIfPossible(from_utf8(v[0]));
2541 if (v.size() == 2) {
2542 docstring retval = _("%1$s and %2$s");
2543 retval = subst(retval, _("and"), s);
2544 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2545 translateIfPossible(from_utf8(v[1])));
2547 // The idea here is to format all but the last two items...
2548 int const vSize = v.size();
2549 docstring t2 = _("%1$s, %2$s");
2550 docstring retval = translateIfPossible(from_utf8(v[0]));
2551 for (int i = 1; i < vSize - 2; ++i)
2552 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2553 //...and then to plug them, and the last two, into this schema
2554 docstring t = _("%1$s, %2$s, and %3$s");
2555 t = subst(t, _("and"), s);
2556 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2557 translateIfPossible(from_utf8(v[vSize - 1])));
2560 vector<string> idsToNames(vector<string> const & idList)
2562 vector<string> retval;
2563 vector<string>::const_iterator it = idList.begin();
2564 vector<string>::const_iterator end = idList.end();
2565 for (; it != end; ++it) {
2566 LyXModule const * const mod = theModuleList[*it];
2568 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2569 translateIfPossible(from_utf8(*it)))));
2571 retval.push_back(mod->getName());
2575 } // end anonymous namespace
2578 void GuiDocument::modulesToParams(BufferParams & bp)
2580 // update list of loaded modules
2581 bp.clearLayoutModules();
2582 int const srows = modules_sel_model_.rowCount();
2583 for (int i = 0; i < srows; ++i)
2584 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2586 // update the list of removed modules
2587 bp.clearRemovedModules();
2588 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2589 list<string>::const_iterator rit = reqmods.begin();
2590 list<string>::const_iterator ren = reqmods.end();
2592 // check each of the default modules
2593 for (; rit != ren; ++rit) {
2594 list<string>::const_iterator mit = bp.getModules().begin();
2595 list<string>::const_iterator men = bp.getModules().end();
2597 for (; mit != men; ++mit) {
2604 // the module isn't present so must have been removed by the user
2605 bp.addRemovedModule(*rit);
2610 void GuiDocument::modulesChanged()
2612 modulesToParams(bp_);
2614 if (applyPB->isEnabled() && nonModuleChanged_) {
2615 int const ret = Alert::prompt(_("Unapplied changes"),
2616 _("Some changes in the dialog were not yet applied.\n"
2617 "If you do not apply now, they will be lost after this action."),
2618 1, 1, _("&Apply"), _("&Dismiss"));
2623 bp_.makeDocumentClass();
2629 void GuiDocument::updateModuleInfo()
2631 selectionManager->update();
2633 //Module description
2634 bool const focus_on_selected = selectionManager->selectedFocused();
2635 QAbstractItemView * lv;
2636 if (focus_on_selected)
2637 lv = modulesModule->selectedLV;
2639 lv = modulesModule->availableLV;
2640 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2641 modulesModule->infoML->document()->clear();
2644 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2645 GuiIdListModel const & id_model =
2646 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2647 string const modName = id_model.getIDString(idx.row());
2648 docstring desc = getModuleDescription(modName);
2650 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2651 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2654 desc += _("Module provided by document class.");
2657 docstring cat = getModuleCategory(modName);
2661 desc += bformat(_("Category: %1$s."), cat);
2664 vector<string> pkglist = getPackageList(modName);
2665 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2666 if (!pkgdesc.empty()) {
2669 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2672 pkglist = getRequiredList(modName);
2673 if (!pkglist.empty()) {
2674 vector<string> const reqdescs = idsToNames(pkglist);
2675 pkgdesc = formatStrVec(reqdescs, _("or"));
2678 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2681 pkglist = getExcludedList(modName);
2682 if (!pkglist.empty()) {
2683 vector<string> const reqdescs = idsToNames(pkglist);
2684 pkgdesc = formatStrVec(reqdescs, _( "and"));
2687 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2690 if (!isModuleAvailable(modName)) {
2693 desc += _("WARNING: Some required packages are unavailable!");
2696 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2700 void GuiDocument::updateNumbering()
2702 DocumentClass const & tclass = documentClass();
2704 numberingModule->tocTW->setUpdatesEnabled(false);
2705 numberingModule->tocTW->clear();
2707 int const depth = numberingModule->depthSL->value();
2708 int const toc = numberingModule->tocSL->value();
2709 QString const no = qt_("No");
2710 QString const yes = qt_("Yes");
2711 QTreeWidgetItem * item = 0;
2713 DocumentClass::const_iterator lit = tclass.begin();
2714 DocumentClass::const_iterator len = tclass.end();
2715 for (; lit != len; ++lit) {
2716 int const toclevel = lit->toclevel;
2717 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2718 item = new QTreeWidgetItem(numberingModule->tocTW);
2719 item->setText(0, toqstr(translateIfPossible(lit->name())));
2720 item->setText(1, (toclevel <= depth) ? yes : no);
2721 item->setText(2, (toclevel <= toc) ? yes : no);
2725 numberingModule->tocTW->setUpdatesEnabled(true);
2726 numberingModule->tocTW->update();
2730 void GuiDocument::updateDefaultFormat()
2734 // make a copy in order to consider unapplied changes
2735 BufferParams param_copy = buffer().params();
2736 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2737 int const idx = latexModule->classCO->currentIndex();
2739 string const classname = fromqstr(latexModule->classCO->getData(idx));
2740 param_copy.setBaseClass(classname);
2741 param_copy.makeDocumentClass(true);
2743 outputModule->defaultFormatCO->blockSignals(true);
2744 outputModule->defaultFormatCO->clear();
2745 outputModule->defaultFormatCO->addItem(qt_("Default"),
2746 QVariant(QString("default")));
2747 FormatList const & formats =
2748 param_copy.exportableFormats(true);
2749 for (Format const * f : formats)
2750 outputModule->defaultFormatCO->addItem
2751 (toqstr(translateIfPossible(f->prettyname())),
2752 QVariant(toqstr(f->name())));
2753 outputModule->defaultFormatCO->blockSignals(false);
2757 bool GuiDocument::isChildIncluded(string const & child)
2759 if (includeonlys_.empty())
2761 return (std::find(includeonlys_.begin(),
2762 includeonlys_.end(), child) != includeonlys_.end());
2766 void GuiDocument::applyView()
2769 preambleModule->apply(bp_);
2770 localLayout->apply(bp_);
2773 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2774 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2777 string const engine =
2778 fromqstr(biblioModule->citeEngineCO->itemData(
2779 biblioModule->citeEngineCO->currentIndex()).toString());
2780 bp_.setCiteEngine(engine);
2782 CiteEngineType const style = CiteEngineType(biblioModule->citeStyleCO->itemData(
2783 biblioModule->citeStyleCO->currentIndex()).toInt());
2784 if (theCiteEnginesList[engine]->hasEngineType(style))
2785 bp_.setCiteEngineType(style);
2787 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2789 bp_.splitbib(biblioModule->bibtopicCB->isChecked());
2791 bp_.multibib = fromqstr(biblioModule->bibunitsCO->itemData(
2792 biblioModule->bibunitsCO->currentIndex()).toString());
2794 bp_.setDefaultBiblioStyle(fromqstr(biblioModule->defaultBiblioCO->currentText()));
2796 bp_.biblatex_bibstyle = fromqstr(biblioModule->biblatexBbxCO->currentText());
2797 bp_.biblatex_citestyle = fromqstr(biblioModule->biblatexCbxCO->currentText());
2798 bp_.biblio_opts = fromqstr(biblioModule->citePackageOptionsLE->text());
2800 string const bibtex_command =
2801 fromqstr(biblioModule->bibtexCO->itemData(
2802 biblioModule->bibtexCO->currentIndex()).toString());
2803 string const bibtex_options =
2804 fromqstr(biblioModule->bibtexOptionsLE->text());
2805 if (bibtex_command == "default" || bibtex_options.empty())
2806 bp_.bibtex_command = bibtex_command;
2808 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2810 if (biblioChanged_) {
2811 buffer().invalidateBibinfoCache();
2812 buffer().removeBiblioTempFiles();
2816 indicesModule->apply(bp_);
2818 // language & quotes
2819 if (langModule->defaultencodingRB->isChecked()) {
2820 bp_.inputenc = "auto";
2822 int i = langModule->encodingCO->currentIndex();
2824 bp_.inputenc = "default";
2826 QString const enc_gui =
2827 langModule->encodingCO->currentText();
2828 Encodings::const_iterator it = encodings.begin();
2829 Encodings::const_iterator const end = encodings.end();
2831 for (; it != end; ++it) {
2832 if (qt_(it->guiName()) == enc_gui &&
2834 bp_.inputenc = it->name();
2840 // should not happen
2841 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2842 bp_.inputenc = "default";
2847 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2848 langModule->quoteStyleCO->currentIndex()).toInt();
2849 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2851 QString const langname = langModule->languageCO->itemData(
2852 langModule->languageCO->currentIndex()).toString();
2853 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2854 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2855 // If current cursor language was the document language, then update it too.
2856 if (cur.current_font.language() == bp_.language) {
2857 cur.current_font.setLanguage(newlang);
2858 cur.real_current_font.setLanguage(newlang);
2860 bp_.language = newlang;
2862 QString const pack = langModule->languagePackageCO->itemData(
2863 langModule->languagePackageCO->currentIndex()).toString();
2864 if (pack == "custom")
2866 fromqstr(langModule->languagePackageLE->text());
2868 bp_.lang_package = fromqstr(pack);
2871 bp_.backgroundcolor = set_backgroundcolor;
2872 bp_.isbackgroundcolor = is_backgroundcolor;
2873 bp_.fontcolor = set_fontcolor;
2874 bp_.isfontcolor = is_fontcolor;
2875 bp_.notefontcolor = set_notefontcolor;
2876 bp_.boxbgcolor = set_boxbgcolor;
2879 if (bp_.documentClass().hasTocLevels()) {
2880 bp_.tocdepth = numberingModule->tocSL->value();
2881 bp_.secnumdepth = numberingModule->depthSL->value();
2885 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2886 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2887 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2888 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2891 bp_.graphics_driver =
2892 tex_graphics[latexModule->psdriverCO->currentIndex()];
2895 int idx = latexModule->classCO->currentIndex();
2897 string const classname = fromqstr(latexModule->classCO->getData(idx));
2898 bp_.setBaseClass(classname);
2902 modulesToParams(bp_);
2905 map<string, string> const & packages = BufferParams::auto_packages();
2906 for (map<string, string>::const_iterator it = packages.begin();
2907 it != packages.end(); ++it) {
2908 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2911 int row = mathsModule->packagesTW->row(item);
2912 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2913 if (rb->isChecked()) {
2914 bp_.use_package(it->first, BufferParams::package_auto);
2917 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2918 if (rb->isChecked()) {
2919 bp_.use_package(it->first, BufferParams::package_on);
2922 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2923 if (rb->isChecked())
2924 bp_.use_package(it->first, BufferParams::package_off);
2926 // if math is indented
2927 bp_.is_math_indent = mathsModule->MathIndentCB->isChecked();
2928 if (bp_.is_math_indent) {
2929 // if formulas are indented
2930 switch (mathsModule->MathIndentCO->currentIndex()) {
2932 bp_.setMathIndent(Length());
2935 Length mathindent(widgetsToLength(mathsModule->MathIndentLE,
2936 mathsModule->MathIndentLengthCO));
2937 bp_.setMathIndent(mathindent);
2941 // this should never happen
2942 bp_.setMathIndent(Length());
2946 switch (mathsModule->MathNumberingPosCO->currentIndex()) {
2948 bp_.math_numbering_side = BufferParams::LEFT;
2951 bp_.math_numbering_side = BufferParams::DEFAULT;
2954 bp_.math_numbering_side = BufferParams::RIGHT;
2957 // this should never happen
2958 bp_.math_numbering_side = BufferParams::DEFAULT;
2963 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2964 bp_.pagestyle = "default";
2966 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2967 for (size_t i = 0; i != pagestyles.size(); ++i)
2968 if (pagestyles[i].second == style_gui)
2969 bp_.pagestyle = pagestyles[i].first;
2973 switch (textLayoutModule->lspacingCO->currentIndex()) {
2975 bp_.spacing().set(Spacing::Single);
2978 bp_.spacing().set(Spacing::Onehalf);
2981 bp_.spacing().set(Spacing::Double);
2984 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2986 bp_.spacing().set(Spacing::Single);
2988 bp_.spacing().set(Spacing::Other, s);
2993 if (textLayoutModule->twoColumnCB->isChecked())
2998 bp_.justification = textLayoutModule->justCB->isChecked();
3000 if (textLayoutModule->indentRB->isChecked()) {
3001 // if paragraphs are separated by an indentation
3002 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
3003 switch (textLayoutModule->indentCO->currentIndex()) {
3005 bp_.setParIndent(Length());
3008 Length parindent(widgetsToLength(textLayoutModule->indentLE,
3009 textLayoutModule->indentLengthCO));
3010 bp_.setParIndent(parindent);
3014 // this should never happen
3015 bp_.setParIndent(Length());
3019 // if paragraphs are separated by a skip
3020 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
3021 switch (textLayoutModule->skipCO->currentIndex()) {
3023 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
3026 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
3029 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
3034 widgetsToLength(textLayoutModule->skipLE,
3035 textLayoutModule->skipLengthCO)
3041 // this should never happen
3042 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
3048 fromqstr(latexModule->optionsLE->text());
3050 bp_.use_default_options =
3051 latexModule->defaultOptionsCB->isChecked();
3053 if (latexModule->childDocGB->isChecked())
3055 fromqstr(latexModule->childDocLE->text());
3057 bp_.master = string();
3060 bp_.clearIncludedChildren();
3061 if (masterChildModule->includeonlyRB->isChecked()) {
3062 list<string>::const_iterator it = includeonlys_.begin();
3063 for (; it != includeonlys_.end() ; ++it) {
3064 bp_.addIncludedChildren(*it);
3067 bp_.maintain_unincluded_children =
3068 masterChildModule->maintainAuxCB->isChecked();
3071 bp_.float_placement = floatModule->get();
3074 // text should have passed validation
3075 bp_.use_minted = listingsModule->mintedCB->isChecked();
3076 bp_.listings_params =
3077 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
3080 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
3081 outputModule->defaultFormatCO->currentIndex()).toString());
3083 bool const nontexfonts = fontModule->osFontsCB->isChecked();
3084 bp_.useNonTeXFonts = nontexfonts;
3086 bp_.output_sync = outputModule->outputsyncCB->isChecked();
3088 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
3090 int mathfmt = outputModule->mathoutCB->currentIndex();
3093 BufferParams::MathOutput const mo =
3094 static_cast<BufferParams::MathOutput>(mathfmt);
3095 bp_.html_math_output = mo;
3096 bp_.html_be_strict = outputModule->strictCB->isChecked();
3097 bp_.html_css_as_file = outputModule->cssCB->isChecked();
3098 bp_.html_math_img_scale = outputModule->mathimgSB->value();
3099 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
3101 bp_.save_transient_properties =
3102 outputModule->saveTransientPropertiesCB->isChecked();
3105 bp_.fonts_roman[nontexfonts] =
3106 fromqstr(fontModule->fontsRomanCO->
3107 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
3108 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
3110 bp_.fonts_sans[nontexfonts] =
3111 fromqstr(fontModule->fontsSansCO->
3112 itemData(fontModule->fontsSansCO->currentIndex()).toString());
3113 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
3115 bp_.fonts_typewriter[nontexfonts] =
3116 fromqstr(fontModule->fontsTypewriterCO->
3117 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
3118 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
3120 bp_.fonts_math[nontexfonts] =
3121 fromqstr(fontModule->fontsMathCO->
3122 itemData(fontModule->fontsMathCO->currentIndex()).toString());
3123 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
3125 QString const fontenc =
3126 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
3127 if (fontenc == "custom")
3128 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
3130 bp_.fontenc = fromqstr(fontenc);
3133 fromqstr(fontModule->cjkFontLE->text());
3135 bp_.use_microtype = fontModule->microtypeCB->isChecked();
3136 bp_.use_dash_ligatures = fontModule->dashesCB->isChecked();
3138 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
3139 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
3141 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
3142 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
3144 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
3146 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
3149 bp_.fonts_default_family = "default";
3151 bp_.fonts_default_family = GuiDocument::fontfamilies[
3152 fontModule->fontsDefaultCO->currentIndex()];
3154 if (fontModule->fontsizeCO->currentIndex() == 0)
3155 bp_.fontsize = "default";
3158 fromqstr(fontModule->fontsizeCO->currentText());
3161 bp_.papersize = PAPER_SIZE(
3162 pageLayoutModule->papersizeCO->currentIndex());
3164 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
3165 pageLayoutModule->paperwidthUnitCO);
3167 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
3168 pageLayoutModule->paperheightUnitCO);
3170 if (pageLayoutModule->facingPagesCB->isChecked())
3171 bp_.sides = TwoSides;
3173 bp_.sides = OneSide;
3175 if (pageLayoutModule->landscapeRB->isChecked())
3176 bp_.orientation = ORIENTATION_LANDSCAPE;
3178 bp_.orientation = ORIENTATION_PORTRAIT;
3181 bp_.use_geometry = !marginsModule->marginCB->isChecked();
3183 Ui::MarginsUi const * m = marginsModule;
3185 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
3186 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
3187 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3188 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3189 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3190 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3191 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3192 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3195 branchesModule->apply(bp_);
3198 PDFOptions & pdf = bp_.pdfoptions();
3199 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3200 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3201 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3202 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3203 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3205 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3206 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3207 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3208 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3210 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3211 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3212 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3213 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3215 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3216 if (pdfSupportModule->fullscreenCB->isChecked())
3217 pdf.pagemode = pdf.pagemode_fullscreen;
3219 pdf.pagemode.clear();
3220 pdf.quoted_options = pdf.quoted_options_check(
3221 fromqstr(pdfSupportModule->optionsLE->text()));
3224 nonModuleChanged_ = false;
3228 void GuiDocument::paramsToDialog()
3230 // set the default unit
3231 Length::UNIT const default_unit = Length::defaultUnit();
3234 preambleModule->update(bp_, id());
3235 localLayout->update(bp_, id());
3238 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3239 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3242 string const cite_engine = bp_.citeEngine().list().front();
3244 biblioModule->citeEngineCO->setCurrentIndex(
3245 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3247 updateEngineType(documentClass().opt_enginetype(),
3248 bp_.citeEngineType());
3250 biblioModule->citeStyleCO->setCurrentIndex(
3251 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3253 biblioModule->bibtopicCB->setChecked(bp_.splitbib());
3255 biblioModule->bibunitsCO->clear();
3256 biblioModule->bibunitsCO->addItem(qt_("No"), QString());
3257 if (documentClass().hasLaTeXLayout("part"))
3258 biblioModule->bibunitsCO->addItem(qt_("per part"), toqstr("part"));
3259 if (documentClass().hasLaTeXLayout("chapter"))
3260 biblioModule->bibunitsCO->addItem(qt_("per chapter"), toqstr("chapter"));
3261 if (documentClass().hasLaTeXLayout("section"))
3262 biblioModule->bibunitsCO->addItem(qt_("per section"), toqstr("section"));
3263 if (documentClass().hasLaTeXLayout("subsection"))
3264 biblioModule->bibunitsCO->addItem(qt_("per subsection"), toqstr("subsection"));
3265 biblioModule->bibunitsCO->addItem(qt_("per child document"), toqstr("child"));
3267 int const mbpos = biblioModule->bibunitsCO->findData(toqstr(bp_.multibib));
3269 biblioModule->bibunitsCO->setCurrentIndex(mbpos);
3271 biblioModule->bibunitsCO->setCurrentIndex(0);
3273 updateEngineDependends();
3276 updateDefaultBiblio(bp_.biblatex_bibstyle, "bbx");
3277 updateDefaultBiblio(bp_.biblatex_citestyle, "cbx");
3279 updateDefaultBiblio(bp_.defaultBiblioStyle());
3281 biblioModule->citePackageOptionsLE->setText(toqstr(bp_.biblio_opts));
3285 split(bp_.bibtex_command, command, ' ');
3287 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3289 biblioModule->bibtexCO->setCurrentIndex(bpos);
3290 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3292 // We reset to default if we do not know the specified compiler
3293 // This is for security reasons
3294 biblioModule->bibtexCO->setCurrentIndex(
3295 biblioModule->bibtexCO->findData(toqstr("default")));
3296 biblioModule->bibtexOptionsLE->clear();
3298 biblioModule->bibtexOptionsLE->setEnabled(
3299 biblioModule->bibtexCO->currentIndex() != 0);
3301 biblioChanged_ = false;
3304 // We may be called when there is no Buffer, e.g., when
3305 // the last view has just been closed.
3306 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3307 indicesModule->update(bp_, isReadOnly);
3309 // language & quotes
3310 int const pos = langModule->languageCO->findData(toqstr(
3311 bp_.language->lang()));
3312 langModule->languageCO->setCurrentIndex(pos);
3314 updateQuoteStyles();
3316 langModule->quoteStyleCO->setCurrentIndex(
3317 langModule->quoteStyleCO->findData(bp_.quotes_style));
3318 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3320 bool default_enc = true;
3321 if (bp_.inputenc != "auto") {
3322 default_enc = false;
3323 if (bp_.inputenc == "default") {
3324 langModule->encodingCO->setCurrentIndex(0);
3327 Encodings::const_iterator it = encodings.begin();
3328 Encodings::const_iterator const end = encodings.end();
3329 for (; it != end; ++it) {
3330 if (it->name() == bp_.inputenc &&
3332 enc_gui = it->guiName();
3336 int const i = langModule->encodingCO->findText(
3339 langModule->encodingCO->setCurrentIndex(i);
3341 // unknown encoding. Set to default.
3345 langModule->defaultencodingRB->setChecked(default_enc);
3346 langModule->otherencodingRB->setChecked(!default_enc);
3348 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3350 langModule->languagePackageCO->setCurrentIndex(
3351 langModule->languagePackageCO->findData("custom"));
3352 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3354 langModule->languagePackageCO->setCurrentIndex(p);
3355 langModule->languagePackageLE->clear();
3359 if (bp_.isfontcolor) {
3360 colorModule->fontColorPB->setStyleSheet(
3361 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3363 set_fontcolor = bp_.fontcolor;
3364 is_fontcolor = bp_.isfontcolor;
3366 colorModule->noteFontColorPB->setStyleSheet(
3367 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3368 set_notefontcolor = bp_.notefontcolor;
3370 if (bp_.isbackgroundcolor) {
3371 colorModule->backgroundPB->setStyleSheet(
3372 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3374 set_backgroundcolor = bp_.backgroundcolor;
3375 is_backgroundcolor = bp_.isbackgroundcolor;
3377 colorModule->boxBackgroundPB->setStyleSheet(
3378 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3379 set_boxbgcolor = bp_.boxbgcolor;
3382 int const min_toclevel = documentClass().min_toclevel();
3383 int const max_toclevel = documentClass().max_toclevel();
3384 if (documentClass().hasTocLevels()) {
3385 numberingModule->setEnabled(true);
3386 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3387 numberingModule->depthSL->setMaximum(max_toclevel);
3388 numberingModule->depthSL->setValue(bp_.secnumdepth);
3389 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3390 numberingModule->tocSL->setMaximum(max_toclevel);
3391 numberingModule->tocSL->setValue(bp_.tocdepth);
3394 numberingModule->setEnabled(false);
3395 numberingModule->tocTW->clear();
3399 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3400 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3401 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3402 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3403 bulletsModule->init();
3406 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3408 latexModule->psdriverCO->setCurrentIndex(nitem);
3412 mathsModule->MathIndentCB->setChecked(bp_.is_math_indent);
3413 if (bp_.is_math_indent) {
3414 Length const mathindent = bp_.getMathIndent();
3416 if (!mathindent.empty()) {
3417 lengthToWidgets(mathsModule->MathIndentLE,
3418 mathsModule->MathIndentLengthCO,
3419 mathindent, default_unit);
3422 mathsModule->MathIndentCO->setCurrentIndex(indent);
3423 enableMathIndent(indent);
3425 switch(bp_.math_numbering_side) {
3426 case BufferParams::LEFT:
3427 mathsModule->MathNumberingPosCO->setCurrentIndex(0);
3429 case BufferParams::DEFAULT:
3430 mathsModule->MathNumberingPosCO->setCurrentIndex(1);
3432 case BufferParams::RIGHT:
3433 mathsModule->MathNumberingPosCO->setCurrentIndex(2);
3436 map<string, string> const & packages = BufferParams::auto_packages();
3437 for (map<string, string>::const_iterator it = packages.begin();
3438 it != packages.end(); ++it) {
3439 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3442 int row = mathsModule->packagesTW->row(item);
3443 switch (bp_.use_package(it->first)) {
3444 case BufferParams::package_off: {
3445 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3446 rb->setChecked(true);
3449 case BufferParams::package_on: {
3450 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3451 rb->setChecked(true);
3454 case BufferParams::package_auto: {
3455 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3456 rb->setChecked(true);
3462 switch (bp_.spacing().getSpace()) {
3463 case Spacing::Other: nitem = 3; break;
3464 case Spacing::Double: nitem = 2; break;
3465 case Spacing::Onehalf: nitem = 1; break;
3466 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3470 string const & layoutID = bp_.baseClassID();
3471 setLayoutComboByIDString(layoutID);
3473 updatePagestyle(documentClass().opt_pagestyle(),
3476 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3477 if (bp_.spacing().getSpace() == Spacing::Other) {
3478 doubleToWidget(textLayoutModule->lspacingLE,
3479 bp_.spacing().getValueAsString());
3483 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3484 textLayoutModule->indentRB->setChecked(true);
3485 string parindent = bp_.getParIndent().asString();
3487 if (!parindent.empty()) {
3488 lengthToWidgets(textLayoutModule->indentLE,
3489 textLayoutModule->indentLengthCO,
3490 parindent, default_unit);
3493 textLayoutModule->indentCO->setCurrentIndex(indent);
3496 textLayoutModule->skipRB->setChecked(true);
3498 switch (bp_.getDefSkip().kind()) {
3499 case VSpace::SMALLSKIP:
3502 case VSpace::MEDSKIP:
3505 case VSpace::BIGSKIP:
3508 case VSpace::LENGTH:
3511 string const length = bp_.getDefSkip().asLyXCommand();
3512 lengthToWidgets(textLayoutModule->skipLE,
3513 textLayoutModule->skipLengthCO,
3514 length, default_unit);
3521 textLayoutModule->skipCO->setCurrentIndex(skip);
3525 textLayoutModule->twoColumnCB->setChecked(
3527 textLayoutModule->justCB->setChecked(bp_.justification);
3529 if (!bp_.options.empty()) {
3530 latexModule->optionsLE->setText(
3531 toqstr(bp_.options));
3533 latexModule->optionsLE->setText(QString());
3537 latexModule->defaultOptionsCB->setChecked(
3538 bp_.use_default_options);
3539 updateSelectedModules();
3540 selectionManager->updateProvidedModules(
3541 bp_.baseClass()->providedModules());
3542 selectionManager->updateExcludedModules(
3543 bp_.baseClass()->excludedModules());
3545 if (!documentClass().options().empty()) {
3546 latexModule->defaultOptionsLE->setText(
3547 toqstr(documentClass().options()));
3549 latexModule->defaultOptionsLE->setText(
3550 toqstr(_("[No options predefined]")));
3553 latexModule->defaultOptionsLE->setEnabled(
3554 bp_.use_default_options
3555 && !documentClass().options().empty());
3557 latexModule->defaultOptionsCB->setEnabled(
3558 !documentClass().options().empty());
3560 if (!bp_.master.empty()) {
3561 latexModule->childDocGB->setChecked(true);
3562 latexModule->childDocLE->setText(
3563 toqstr(bp_.master));
3565 latexModule->childDocLE->setText(QString());
3566 latexModule->childDocGB->setChecked(false);
3570 if (!bufferview() || !buffer().hasChildren()) {
3571 masterChildModule->childrenTW->clear();
3572 includeonlys_.clear();
3573 docPS->showPanel("Child Documents", false);
3574 if (docPS->isCurrentPanel("Child Documents"))
3575 docPS->setCurrentPanel("Document Class");
3577 docPS->showPanel("Child Documents", true);
3578 masterChildModule->setEnabled(true);
3579 includeonlys_ = bp_.getIncludedChildren();
3580 updateIncludeonlys();
3582 masterChildModule->maintainAuxCB->setChecked(
3583 bp_.maintain_unincluded_children);
3586 floatModule->set(bp_.float_placement);
3589 // break listings_params to multiple lines
3591 InsetListingsParams(bp_.listings_params).separatedParams();
3592 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3593 listingsModule->mintedCB->setChecked(bp_.use_minted);
3597 // some languages only work with polyglossia/XeTeX
3598 Language const * lang = lyx::languages.getLanguage(
3599 fromqstr(langModule->languageCO->itemData(
3600 langModule->languageCO->currentIndex()).toString()));
3601 bool const need_fontspec =
3602 lang->babel().empty() && !lang->polyglossia().empty();
3603 bool const os_fonts_available =
3604 bp_.baseClass()->outputType() == lyx::LATEX
3605 && LaTeXFeatures::isAvailable("fontspec");
3606 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3607 fontModule->osFontsCB->setChecked(
3608 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3609 updateFontsize(documentClass().opt_fontsize(),
3612 QString font = toqstr(bp_.fontsRoman());
3613 int rpos = fontModule->fontsRomanCO->findData(font);
3615 rpos = fontModule->fontsRomanCO->count();
3616 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3618 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3619 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3621 font = toqstr(bp_.fontsSans());
3622 int spos = fontModule->fontsSansCO->findData(font);
3624 spos = fontModule->fontsSansCO->count();
3625 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3627 fontModule->fontsSansCO->setCurrentIndex(spos);
3628 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3630 font = toqstr(bp_.fontsTypewriter());
3631 int tpos = fontModule->fontsTypewriterCO->findData(font);
3633 tpos = fontModule->fontsTypewriterCO->count();
3634 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3636 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3637 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3639 font = toqstr(bp_.fontsMath());
3640 int mpos = fontModule->fontsMathCO->findData(font);
3642 mpos = fontModule->fontsMathCO->count();
3643 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3645 fontModule->fontsMathCO->setCurrentIndex(mpos);
3646 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3648 if (bp_.useNonTeXFonts && os_fonts_available) {
3649 fontModule->fontencLA->setEnabled(false);
3650 fontModule->fontencCO->setEnabled(false);
3651 fontModule->fontencLE->setEnabled(false);
3653 fontModule->fontencLA->setEnabled(true);
3654 fontModule->fontencCO->setEnabled(true);
3655 fontModule->fontencLE->setEnabled(true);
3661 if (!bp_.fonts_cjk.empty())
3662 fontModule->cjkFontLE->setText(
3663 toqstr(bp_.fonts_cjk));
3665 fontModule->cjkFontLE->setText(QString());
3667 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3668 fontModule->dashesCB->setChecked(bp_.use_dash_ligatures);
3670 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3671 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3672 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3673 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3674 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3675 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3677 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3679 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3681 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3682 fontModule->fontencCO->setCurrentIndex(
3683 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3684 fontModule->fontencLE->setEnabled(false);
3686 fontModule->fontencCO->setCurrentIndex(1);
3687 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3691 // This must be set _after_ fonts since updateDefaultFormat()
3692 // checks osFontsCB settings.
3693 // update combobox with formats
3694 updateDefaultFormat();
3695 int index = outputModule->defaultFormatCO->findData(toqstr(
3696 bp_.default_output_format));
3697 // set to default if format is not found
3700 outputModule->defaultFormatCO->setCurrentIndex(index);
3702 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3703 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3705 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3706 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3707 outputModule->strictCB->setChecked(bp_.html_be_strict);
3708 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3710 outputModule->saveTransientPropertiesCB
3711 ->setChecked(bp_.save_transient_properties);
3714 bool const extern_geometry =
3715 documentClass().provides("geometry");
3716 int const psize = bp_.papersize;
3717 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3718 setCustomPapersize(!extern_geometry && psize == 1);
3719 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3721 bool const landscape =
3722 bp_.orientation == ORIENTATION_LANDSCAPE;
3723 pageLayoutModule->landscapeRB->setChecked(landscape);
3724 pageLayoutModule->portraitRB->setChecked(!landscape);
3725 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3726 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3728 pageLayoutModule->facingPagesCB->setChecked(
3729 bp_.sides == TwoSides);
3731 lengthToWidgets(pageLayoutModule->paperwidthLE,
3732 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3733 lengthToWidgets(pageLayoutModule->paperheightLE,
3734 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3737 Ui::MarginsUi * m = marginsModule;
3741 lengthToWidgets(m->topLE, m->topUnit,
3742 bp_.topmargin, default_unit);
3744 lengthToWidgets(m->bottomLE, m->bottomUnit,
3745 bp_.bottommargin, default_unit);
3747 lengthToWidgets(m->innerLE, m->innerUnit,
3748 bp_.leftmargin, default_unit);
3750 lengthToWidgets(m->outerLE, m->outerUnit,
3751 bp_.rightmargin, default_unit);
3753 lengthToWidgets(m->headheightLE, m->headheightUnit,
3754 bp_.headheight, default_unit);
3756 lengthToWidgets(m->headsepLE, m->headsepUnit,
3757 bp_.headsep, default_unit);
3759 lengthToWidgets(m->footskipLE, m->footskipUnit,
3760 bp_.footskip, default_unit);
3762 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3763 bp_.columnsep, default_unit);
3766 updateUnknownBranches();
3767 branchesModule->update(bp_);
3770 PDFOptions const & pdf = bp_.pdfoptions();
3771 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3772 if (bp_.documentClass().provides("hyperref"))
3773 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3775 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3776 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3777 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3778 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3779 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3781 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3782 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3783 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3785 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3787 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3788 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3789 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3790 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3792 nn = findToken(backref_opts, pdf.backref);
3794 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3796 pdfSupportModule->fullscreenCB->setChecked
3797 (pdf.pagemode == pdf.pagemode_fullscreen);
3799 pdfSupportModule->optionsLE->setText(
3800 toqstr(pdf.quoted_options));
3802 // Make sure that the bc is in the INITIAL state
3803 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3806 // clear changed branches cache
3807 changedBranches_.clear();
3810 nonModuleChanged_ = false;
3814 void GuiDocument::saveDocDefault()
3816 // we have to apply the params first
3822 void GuiDocument::updateAvailableModules()
3824 modules_av_model_.clear();
3825 list<modInfoStruct> modInfoList = getModuleInfo();
3826 // Sort names according to the locale
3827 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3828 return 0 < b.name.localeAwareCompare(a.name);
3831 for (modInfoStruct const & m : modInfoList) {
3832 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3838 void GuiDocument::updateSelectedModules()
3840 modules_sel_model_.clear();
3841 list<modInfoStruct> const selModList = getSelectedModules();
3843 for (modInfoStruct const & m : selModList) {
3844 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3850 void GuiDocument::updateIncludeonlys()
3852 masterChildModule->childrenTW->clear();
3853 QString const no = qt_("No");
3854 QString const yes = qt_("Yes");
3856 if (includeonlys_.empty()) {
3857 masterChildModule->includeallRB->setChecked(true);
3858 masterChildModule->childrenTW->setEnabled(false);
3859 masterChildModule->maintainAuxCB->setEnabled(false);
3861 masterChildModule->includeonlyRB->setChecked(true);
3862 masterChildModule->childrenTW->setEnabled(true);
3863 masterChildModule->maintainAuxCB->setEnabled(true);
3865 ListOfBuffers children = buffer().getChildren();
3866 ListOfBuffers::const_iterator it = children.begin();
3867 ListOfBuffers::const_iterator end = children.end();
3868 bool has_unincluded = false;
3869 bool all_unincluded = true;
3870 for (; it != end; ++it) {
3871 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3874 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3875 from_utf8(buffer().filePath())));
3876 item->setText(0, toqstr(name));
3877 item->setText(1, isChildIncluded(name) ? yes : no);
3878 if (!isChildIncluded(name))
3879 has_unincluded = true;
3881 all_unincluded = false;
3883 // Both if all childs are included and if none is included
3884 // is equal to "include all" (i.e., ommit \includeonly).
3885 // Thus, reset the GUI.
3886 if (!has_unincluded || all_unincluded) {
3887 masterChildModule->includeallRB->setChecked(true);
3888 masterChildModule->childrenTW->setEnabled(false);
3889 includeonlys_.clear();
3891 // If all are included, we need to update again.
3892 if (!has_unincluded)
3893 updateIncludeonlys();
3897 bool GuiDocument::isBiblatex() const
3899 QString const engine =
3900 biblioModule->citeEngineCO->itemData(
3901 biblioModule->citeEngineCO->currentIndex()).toString();
3903 return theCiteEnginesList[fromqstr(engine)]->getCiteFramework() == "biblatex";
3907 void GuiDocument::updateDefaultBiblio(string const & style,
3908 string const & which)
3910 QString const bibstyle = toqstr(style);
3911 biblioModule->defaultBiblioCO->clear();
3916 if (which != "cbx") {
3917 // First the bbx styles
3918 biblioModule->biblatexBbxCO->clear();
3919 QStringList str = texFileList("bbxFiles.lst");
3920 // test whether we have a valid list, otherwise run rescan
3921 if (str.isEmpty()) {
3922 rescanTexStyles("bbx");
3923 str = texFileList("bbxFiles.lst");
3925 for (int i = 0; i != str.size(); ++i)
3926 str[i] = onlyFileName(str[i]);
3927 // sort on filename only (no path)
3930 for (int i = 0; i != str.count(); ++i) {
3931 QString item = changeExtension(str[i], "");
3932 if (item == bibstyle)
3934 biblioModule->biblatexBbxCO->addItem(item);
3937 if (item_nr == -1 && !bibstyle.isEmpty()) {
3938 biblioModule->biblatexBbxCO->addItem(bibstyle);
3939 item_nr = biblioModule->biblatexBbxCO->count() - 1;
3943 biblioModule->biblatexBbxCO->setCurrentIndex(item_nr);
3945 biblioModule->biblatexBbxCO->clearEditText();
3948 if (which != "bbx") {
3949 // now the cbx styles
3950 biblioModule->biblatexCbxCO->clear();
3951 QStringList str = texFileList("cbxFiles.lst");
3952 // test whether we have a valid list, otherwise run rescan
3953 if (str.isEmpty()) {
3954 rescanTexStyles("cbx");
3955 str = texFileList("cbxFiles.lst");
3957 for (int i = 0; i != str.size(); ++i)
3958 str[i] = onlyFileName(str[i]);
3959 // sort on filename only (no path)
3962 for (int i = 0; i != str.count(); ++i) {
3963 QString item = changeExtension(str[i], "");
3964 if (item == bibstyle)
3966 biblioModule->biblatexCbxCO->addItem(item);
3969 if (item_nr == -1 && !bibstyle.isEmpty()) {
3970 biblioModule->biblatexCbxCO->addItem(bibstyle);
3971 item_nr = biblioModule->biblatexCbxCO->count() - 1;
3975 biblioModule->biblatexCbxCO->setCurrentIndex(item_nr);
3977 biblioModule->biblatexCbxCO->clearEditText();
3980 biblioModule->biblatexBbxCO->clear();
3981 biblioModule->biblatexCbxCO->clear();
3982 QStringList str = texFileList("bstFiles.lst");
3983 // test whether we have a valid list, otherwise run rescan
3984 if (str.isEmpty()) {
3985 rescanTexStyles("bst");
3986 str = texFileList("bstFiles.lst");
3988 for (int i = 0; i != str.size(); ++i)
3989 str[i] = onlyFileName(str[i]);
3990 // sort on filename only (no path)
3993 for (int i = 0; i != str.count(); ++i) {
3994 QString item = changeExtension(str[i], "");
3995 if (item == bibstyle)
3997 biblioModule->defaultBiblioCO->addItem(item);
4000 if (item_nr == -1 && !bibstyle.isEmpty()) {
4001 biblioModule->defaultBiblioCO->addItem(bibstyle);
4002 item_nr = biblioModule->defaultBiblioCO->count() - 1;
4006 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
4008 biblioModule->defaultBiblioCO->clearEditText();
4011 updateResetDefaultBiblio();
4015 void GuiDocument::updateResetDefaultBiblio()
4017 QString const engine =
4018 biblioModule->citeEngineCO->itemData(
4019 biblioModule->citeEngineCO->currentIndex()).toString();
4020 CiteEngineType const cet =
4021 CiteEngineType(biblioModule->citeStyleCO->itemData(
4022 biblioModule->citeStyleCO->currentIndex()).toInt());
4024 string const defbib = theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet);
4026 QString const bbx = biblioModule->biblatexBbxCO->currentText();
4027 QString const cbx = biblioModule->biblatexCbxCO->currentText();
4028 biblioModule->resetCbxPB->setEnabled(defbib != fromqstr(cbx));
4029 biblioModule->resetBbxPB->setEnabled(defbib != fromqstr(bbx));
4030 biblioModule->matchBbxPB->setEnabled(bbx != cbx && !cbx.isEmpty()
4031 && biblioModule->biblatexBbxCO->findText(cbx) != -1);
4033 biblioModule->resetDefaultBiblioPB->setEnabled(
4034 defbib != fromqstr(biblioModule->defaultBiblioCO->currentText()));
4038 void GuiDocument::matchBiblatexStyles()
4040 updateDefaultBiblio(fromqstr(biblioModule->biblatexCbxCO->currentText()), "bbx");
4045 void GuiDocument::updateContents()
4047 // Nothing to do here as the document settings is not cursor dependant.
4052 void GuiDocument::useClassDefaults()
4054 if (applyPB->isEnabled()) {
4055 int const ret = Alert::prompt(_("Unapplied changes"),
4056 _("Some changes in the dialog were not yet applied.\n"
4057 "If you do not apply now, they will be lost after this action."),
4058 1, 1, _("&Apply"), _("&Dismiss"));
4063 int idx = latexModule->classCO->currentIndex();
4064 string const classname = fromqstr(latexModule->classCO->getData(idx));
4065 if (!bp_.setBaseClass(classname)) {
4066 Alert::error(_("Error"), _("Unable to set document class."));
4069 bp_.useClassDefaults();
4074 void GuiDocument::setLayoutComboByIDString(string const & idString)
4076 if (!latexModule->classCO->set(toqstr(idString)))
4077 Alert::warning(_("Can't set layout!"),
4078 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
4082 bool GuiDocument::isValid()
4085 validateListingsParameters().isEmpty() &&
4086 localLayout->isValid() &&
4088 // if we're asking for skips between paragraphs
4089 !textLayoutModule->skipRB->isChecked() ||
4090 // then either we haven't chosen custom
4091 textLayoutModule->skipCO->currentIndex() != 3 ||
4092 // or else a length has been given
4093 !textLayoutModule->skipLE->text().isEmpty()
4096 // if we're asking for indentation
4097 !textLayoutModule->indentRB->isChecked() ||
4098 // then either we haven't chosen custom
4099 textLayoutModule->indentCO->currentIndex() != 1 ||
4100 // or else a length has been given
4101 !textLayoutModule->indentLE->text().isEmpty()
4104 // if we're asking for math indentation
4105 !mathsModule->MathIndentCB->isChecked() ||
4106 // then either we haven't chosen custom
4107 mathsModule->MathIndentCO->currentIndex() != 1 ||
4108 // or else a length has been given
4109 !mathsModule->MathIndentLE->text().isEmpty()
4114 char const * const GuiDocument::fontfamilies[5] = {
4115 "default", "rmdefault", "sfdefault", "ttdefault", ""
4119 char const * GuiDocument::fontfamilies_gui[5] = {
4120 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
4124 bool GuiDocument::initialiseParams(string const &)
4126 BufferView const * view = bufferview();
4128 bp_ = BufferParams();
4132 bp_ = view->buffer().params();
4134 updateAvailableModules();
4135 //FIXME It'd be nice to make sure here that the selected
4136 //modules are consistent: That required modules are actually
4137 //selected, and that we don't have conflicts. If so, we could
4138 //at least pop up a warning.
4144 void GuiDocument::clearParams()
4146 bp_ = BufferParams();
4150 BufferId GuiDocument::id() const
4152 BufferView const * const view = bufferview();
4153 return view? &view->buffer() : 0;
4157 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
4159 return moduleNames_;
4163 list<GuiDocument::modInfoStruct> const
4164 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
4166 list<modInfoStruct> mInfo;
4167 for (string const & name : mods) {
4169 LyXModule const * const mod = theModuleList[name];
4174 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
4182 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
4184 return makeModuleInfo(params().getModules());
4188 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
4190 return makeModuleInfo(params().baseClass()->providedModules());
4194 DocumentClass const & GuiDocument::documentClass() const
4196 return bp_.documentClass();
4200 static void dispatch_bufferparams(Dialog const & dialog,
4201 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
4204 ss << "\\begin_header\n";
4205 bp.writeFile(ss, buf);
4206 ss << "\\end_header\n";
4207 dialog.dispatch(FuncRequest(lfun, ss.str()));
4211 void GuiDocument::dispatchParams()
4213 // We need a non-const buffer object.
4214 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
4215 // There may be several undo records; group them (bug #8998)
4216 buf.undo().beginUndoGroup();
4218 // This must come first so that a language change is correctly noticed
4221 // Apply the BufferParams. Note that this will set the base class
4222 // and then update the buffer's layout.
4223 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
4225 if (!params().master.empty()) {
4226 FileName const master_file = support::makeAbsPath(params().master,
4227 support::onlyPath(buffer().absFileName()));
4228 if (isLyXFileName(master_file.absFileName())) {
4229 Buffer * master = checkAndLoadLyXFile(master_file);
4231 if (master->isChild(const_cast<Buffer *>(&buffer())))
4232 const_cast<Buffer &>(buffer()).setParent(master);
4234 Alert::warning(_("Assigned master does not include this file"),
4235 bformat(_("You must include this file in the document\n"
4236 "'%1$s' in order to use the master document\n"
4237 "feature."), from_utf8(params().master)));
4239 Alert::warning(_("Could not load master"),
4240 bformat(_("The master document '%1$s'\n"
4241 "could not be loaded."),
4242 from_utf8(params().master)));
4246 // Generate the colours requested by each new branch.
4247 BranchList & branchlist = params().branchlist();
4248 if (!branchlist.empty()) {
4249 BranchList::const_iterator it = branchlist.begin();
4250 BranchList::const_iterator const end = branchlist.end();
4251 for (; it != end; ++it) {
4252 docstring const & current_branch = it->branch();
4253 Branch const * branch = branchlist.find(current_branch);
4254 string const x11hexname = X11hexname(branch->color());
4255 // display the new color
4256 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
4257 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4260 // rename branches in the document
4261 executeBranchRenaming();
4262 // and clear changed branches cache
4263 changedBranches_.clear();
4265 // Generate the colours requested by indices.
4266 IndicesList & indiceslist = params().indiceslist();
4267 if (!indiceslist.empty()) {
4268 IndicesList::const_iterator it = indiceslist.begin();
4269 IndicesList::const_iterator const end = indiceslist.end();
4270 for (; it != end; ++it) {
4271 docstring const & current_index = it->shortcut();
4272 Index const * index = indiceslist.findShortcut(current_index);
4273 string const x11hexname = X11hexname(index->color());
4274 // display the new color
4275 docstring const str = current_index + ' ' + from_ascii(x11hexname);
4276 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4280 // If we used an LFUN, we would not need these two lines:
4281 BufferView * bv = const_cast<BufferView *>(bufferview());
4282 bv->processUpdateFlags(Update::Force | Update::FitCursor);
4284 // Don't forget to close the group. Note that it is important
4285 // to check that there is no early return in the method.
4286 buf.undo().endUndoGroup();
4290 void GuiDocument::setLanguage() const
4292 Language const * const newL = bp_.language;
4293 if (buffer().params().language == newL)
4296 string const & lang_name = newL->lang();
4297 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
4301 void GuiDocument::saveAsDefault() const
4303 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
4307 bool GuiDocument::providesOSF(QString const & font) const
4309 if (fontModule->osFontsCB->isChecked())
4310 // FIXME: we should check if the fonts really
4311 // have OSF support. But how?
4313 return theLaTeXFonts().getLaTeXFont(
4314 qstring_to_ucs4(font)).providesOSF(ot1(),
4320 bool GuiDocument::providesSC(QString const & font) const
4322 if (fontModule->osFontsCB->isChecked())
4324 return theLaTeXFonts().getLaTeXFont(
4325 qstring_to_ucs4(font)).providesSC(ot1(),
4331 bool GuiDocument::providesScale(QString const & font) const
4333 if (fontModule->osFontsCB->isChecked())
4335 return theLaTeXFonts().getLaTeXFont(
4336 qstring_to_ucs4(font)).providesScale(ot1(),
4342 bool GuiDocument::providesNoMath(QString const & font) const
4344 if (fontModule->osFontsCB->isChecked())
4346 return theLaTeXFonts().getLaTeXFont(
4347 qstring_to_ucs4(font)).providesNoMath(ot1(),
4352 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4354 if (fontModule->osFontsCB->isChecked())
4356 return theLaTeXFonts().getLaTeXFont(
4357 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4364 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4366 // FIXME Unicode: docstrings would be better for these parameters but this
4367 // change requires a lot of others
4370 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4371 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4372 // Find the first sentence of the description
4373 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4374 int pos = bf.toNextBoundary();
4377 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4378 // Tooltip is the desc followed by the module name
4379 m.description = QString("%1<i>%2</i>")
4380 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4386 void GuiDocument::loadModuleInfo()
4388 moduleNames_.clear();
4389 for (LyXModule const & mod : theModuleList)
4390 if (mod.category().substr(0, 8) != "Citation")
4391 moduleNames_.push_back(modInfo(mod));
4395 void GuiDocument::updateUnknownBranches()
4399 list<docstring> used_branches;
4400 buffer().getUsedBranches(used_branches);
4401 list<docstring>::const_iterator it = used_branches.begin();
4402 QStringList unknown_branches;
4403 for (; it != used_branches.end() ; ++it) {
4404 if (!buffer().params().branchlist().find(*it))
4405 unknown_branches.append(toqstr(*it));
4407 branchesModule->setUnknownBranches(unknown_branches);
4411 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4413 map<docstring, docstring>::iterator it = changedBranches_.begin();
4414 for (; it != changedBranches_.end() ; ++it) {
4415 if (it->second == oldname) {
4416 // branch has already been renamed
4417 it->second = newname;
4422 changedBranches_[oldname] = newname;
4426 void GuiDocument::executeBranchRenaming() const
4428 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4429 for (; it != changedBranches_.end() ; ++it) {
4430 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4431 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4436 void GuiDocument::allPackagesAuto()
4442 void GuiDocument::allPackagesAlways()
4448 void GuiDocument::allPackagesNot()
4454 void GuiDocument::allPackages(int col)
4456 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4457 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4458 rb->setChecked(true);
4463 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4466 } // namespace frontend
4469 #include "moc_GuiDocument.cpp"