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(setMathIndent(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_("Right"));
1286 mathsModule->MathNumberingPosCO->setCurrentIndex(2);
1290 latexModule = new UiWidget<Ui::LaTeXUi>(this);
1291 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1292 this, SLOT(change_adaptor()));
1293 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1294 this, SLOT(change_adaptor()));
1295 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1296 this, SLOT(change_adaptor()));
1297 connect(latexModule->classCO, SIGNAL(activated(int)),
1298 this, SLOT(classChanged_adaptor()));
1299 connect(latexModule->classCO, SIGNAL(activated(int)),
1300 this, SLOT(change_adaptor()));
1301 connect(latexModule->layoutPB, SIGNAL(clicked()),
1302 this, SLOT(browseLayout()));
1303 connect(latexModule->layoutPB, SIGNAL(clicked()),
1304 this, SLOT(change_adaptor()));
1305 connect(latexModule->childDocGB, SIGNAL(clicked()),
1306 this, SLOT(change_adaptor()));
1307 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1308 this, SLOT(change_adaptor()));
1309 connect(latexModule->childDocPB, SIGNAL(clicked()),
1310 this, SLOT(browseMaster()));
1311 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1312 this, SLOT(change_adaptor()));
1313 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1314 this, SLOT(change_adaptor()));
1316 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1317 latexModule->optionsLE));
1318 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1319 latexModule->childDocLE));
1321 // postscript drivers
1322 for (int n = 0; tex_graphics[n][0]; ++n) {
1323 QString enc = qt_(tex_graphics_gui[n]);
1324 latexModule->psdriverCO->addItem(enc);
1327 LayoutFileList const & bcl = LayoutFileList::get();
1328 vector<LayoutFileIndex> classList = bcl.classList();
1329 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1331 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1332 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1333 for (int i = 0; cit != cen; ++cit, ++i) {
1334 LayoutFile const & tc = bcl[*cit];
1335 bool const available = tc.isTeXClassAvailable();
1336 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1337 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1338 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1340 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1341 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1342 "Please check if you have the matching %1$s class "
1343 "and all required packages (%2$s) installed."),
1344 output_type, from_utf8(tc.prerequisites(", "))));
1346 latexModule->classCO->addItemSort(toqstr(tc.name()),
1348 toqstr(translateIfPossible(from_utf8(tc.category()))),
1350 true, true, true, available);
1355 branchesModule = new GuiBranches(this);
1356 connect(branchesModule, SIGNAL(changed()),
1357 this, SLOT(change_adaptor()));
1358 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1359 this, SLOT(branchesRename(docstring const &, docstring const &)));
1360 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1361 updateUnknownBranches();
1365 preambleModule = new PreambleModule(this);
1366 connect(preambleModule, SIGNAL(changed()),
1367 this, SLOT(change_adaptor()));
1369 localLayout = new LocalLayout(this);
1370 connect(localLayout, SIGNAL(changed()),
1371 this, SLOT(change_adaptor()));
1375 bulletsModule = new BulletsModule(this);
1376 connect(bulletsModule, SIGNAL(changed()),
1377 this, SLOT(change_adaptor()));
1381 modulesModule = new UiWidget<Ui::ModulesUi>(this);
1382 modulesModule->availableLV->header()->setVisible(false);
1383 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1384 modulesModule->availableLV->header()->setStretchLastSection(false);
1386 new ModuleSelectionManager(this, modulesModule->availableLV,
1387 modulesModule->selectedLV,
1388 modulesModule->addPB,
1389 modulesModule->deletePB,
1390 modulesModule->upPB,
1391 modulesModule->downPB,
1392 availableModel(), selectedModel(), this);
1393 connect(selectionManager, SIGNAL(updateHook()),
1394 this, SLOT(updateModuleInfo()));
1395 connect(selectionManager, SIGNAL(selectionChanged()),
1396 this, SLOT(modulesChanged()));
1400 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>(this);
1401 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1402 this, SLOT(change_adaptor()));
1403 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1404 this, SLOT(change_adaptor()));
1405 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1406 this, SLOT(change_adaptor()));
1407 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1408 this, SLOT(change_adaptor()));
1409 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1410 this, SLOT(change_adaptor()));
1411 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1412 this, SLOT(change_adaptor()));
1413 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1414 this, SLOT(change_adaptor()));
1415 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1416 this, SLOT(change_adaptor()));
1417 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1418 this, SLOT(change_adaptor()));
1419 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1420 this, SLOT(change_adaptor()));
1421 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1422 this, SLOT(change_adaptor()));
1423 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1424 this, SLOT(change_adaptor()));
1425 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1426 this, SLOT(change_adaptor()));
1427 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1428 this, SLOT(change_adaptor()));
1429 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1430 this, SLOT(change_adaptor()));
1431 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1432 this, SLOT(change_adaptor()));
1434 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1435 pdfSupportModule->titleLE));
1436 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1437 pdfSupportModule->authorLE));
1438 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1439 pdfSupportModule->subjectLE));
1440 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1441 pdfSupportModule->keywordsLE));
1442 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1443 pdfSupportModule->optionsLE));
1445 for (int i = 0; backref_opts[i][0]; ++i)
1446 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1450 floatModule = new FloatPlacement;
1451 connect(floatModule, SIGNAL(changed()),
1452 this, SLOT(change_adaptor()));
1456 listingsModule = new UiWidget<Ui::ListingsSettingsUi>(this);
1457 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1458 this, SLOT(change_adaptor()));
1459 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1460 this, SLOT(change_adaptor()));
1461 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1462 this, SLOT(setListingsMessage()));
1463 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1464 this, SLOT(setListingsMessage()));
1465 listingsModule->listingsTB->setPlainText(
1466 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1470 docPS->addPanel(latexModule, N_("Document Class"));
1471 docPS->addPanel(masterChildModule, N_("Child Documents"));
1472 docPS->addPanel(modulesModule, N_("Modules"));
1473 docPS->addPanel(localLayout, N_("Local Layout"));
1474 docPS->addPanel(fontModule, N_("Fonts"));
1475 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1476 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1477 docPS->addPanel(marginsModule, N_("Page Margins"));
1478 docPS->addPanel(langModule, N_("Language"));
1479 docPS->addPanel(colorModule, N_("Colors"));
1480 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1481 docPS->addPanel(biblioModule, N_("Bibliography"));
1482 docPS->addPanel(indicesModule, N_("Indexes"));
1483 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1484 docPS->addPanel(mathsModule, N_("Math Options"));
1485 docPS->addPanel(floatModule, N_("Float Placement"));
1486 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1487 docPS->addPanel(bulletsModule, N_("Bullets"));
1488 docPS->addPanel(branchesModule, N_("Branches"));
1489 docPS->addPanel(outputModule, N_("Formats[[output]]"));
1490 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1491 docPS->setCurrentPanel("Document Class");
1492 // FIXME: hack to work around resizing bug in Qt >= 4.2
1493 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1494 #if QT_VERSION >= 0x040200
1495 docPS->updateGeometry();
1500 void GuiDocument::onBufferViewChanged()
1502 if (isVisibleView())
1503 initialiseParams("");
1507 void GuiDocument::saveDefaultClicked()
1513 void GuiDocument::useDefaultsClicked()
1519 void GuiDocument::change_adaptor()
1521 nonModuleChanged_ = true;
1526 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1531 string child = fromqstr(item->text(0));
1535 if (std::find(includeonlys_.begin(),
1536 includeonlys_.end(), child) != includeonlys_.end())
1537 includeonlys_.remove(child);
1539 includeonlys_.push_back(child);
1541 updateIncludeonlys();
1546 QString GuiDocument::validateListingsParameters()
1548 if (listingsModule->bypassCB->isChecked())
1550 string params = fromqstr(listingsModule->listingsED->toPlainText());
1551 return toqstr(InsetListingsParams(params).validate());
1555 void GuiDocument::setListingsMessage()
1558 static bool isOK = true;
1559 QString msg = validateListingsParameters();
1560 if (msg.isEmpty()) {
1564 // listingsTB->setTextColor("black");
1565 listingsModule->listingsTB->setPlainText(
1566 qt_("Input listings parameters below. "
1567 "Enter ? for a list of parameters."));
1570 // listingsTB->setTextColor("red");
1571 listingsModule->listingsTB->setPlainText(msg);
1576 void GuiDocument::setLSpacing(int item)
1578 textLayoutModule->lspacingLE->setEnabled(item == 3);
1582 void GuiDocument::setIndent(int item)
1584 bool const enable = (item == 1);
1585 textLayoutModule->indentLE->setEnabled(enable);
1586 textLayoutModule->indentLengthCO->setEnabled(enable);
1587 textLayoutModule->skipLE->setEnabled(false);
1588 textLayoutModule->skipLengthCO->setEnabled(false);
1593 void GuiDocument::enableIndent(bool indent)
1595 textLayoutModule->skipLE->setEnabled(!indent);
1596 textLayoutModule->skipLengthCO->setEnabled(!indent);
1598 setIndent(textLayoutModule->indentCO->currentIndex());
1602 void GuiDocument::setSkip(int item)
1604 bool const enable = (item == 3);
1605 textLayoutModule->skipLE->setEnabled(enable);
1606 textLayoutModule->skipLengthCO->setEnabled(enable);
1611 void GuiDocument::enableSkip(bool skip)
1613 textLayoutModule->indentLE->setEnabled(!skip);
1614 textLayoutModule->indentLengthCO->setEnabled(!skip);
1616 setSkip(textLayoutModule->skipCO->currentIndex());
1619 void GuiDocument::allowMathIndent() {
1620 // only disable when not checked, checked does not always allow enabling
1621 if (!mathsModule->MathIndentCB->isChecked()) {
1622 mathsModule->MathIndentLE->setEnabled(false);
1623 mathsModule->MathIndentLengthCO->setEnabled(false);
1625 if (mathsModule->MathIndentCB->isChecked()
1626 && mathsModule->MathIndentCO->currentIndex() == 1) {
1627 mathsModule->MathIndentLE->setEnabled(true);
1628 mathsModule->MathIndentLengthCO->setEnabled(true);
1633 void GuiDocument::setMathIndent(int item)
1635 bool const enable = (item == 1);
1636 mathsModule->MathIndentLE->setEnabled(enable);
1637 mathsModule->MathIndentLengthCO->setEnabled(enable);
1642 void GuiDocument::setMargins()
1644 bool const extern_geometry =
1645 documentClass().provides("geometry");
1646 marginsModule->marginCB->setEnabled(!extern_geometry);
1647 if (extern_geometry) {
1648 marginsModule->marginCB->setChecked(false);
1649 setCustomMargins(true);
1651 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1652 setCustomMargins(!bp_.use_geometry);
1657 void GuiDocument::papersizeChanged(int paper_size)
1659 setCustomPapersize(paper_size == 1);
1663 void GuiDocument::setCustomPapersize(bool custom)
1665 pageLayoutModule->paperwidthL->setEnabled(custom);
1666 pageLayoutModule->paperwidthLE->setEnabled(custom);
1667 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1668 pageLayoutModule->paperheightL->setEnabled(custom);
1669 pageLayoutModule->paperheightLE->setEnabled(custom);
1670 pageLayoutModule->paperheightLE->setFocus();
1671 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1675 void GuiDocument::setColSep()
1677 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1681 void GuiDocument::setCustomMargins(bool custom)
1683 marginsModule->topL->setEnabled(!custom);
1684 marginsModule->topLE->setEnabled(!custom);
1685 marginsModule->topUnit->setEnabled(!custom);
1687 marginsModule->bottomL->setEnabled(!custom);
1688 marginsModule->bottomLE->setEnabled(!custom);
1689 marginsModule->bottomUnit->setEnabled(!custom);
1691 marginsModule->innerL->setEnabled(!custom);
1692 marginsModule->innerLE->setEnabled(!custom);
1693 marginsModule->innerUnit->setEnabled(!custom);
1695 marginsModule->outerL->setEnabled(!custom);
1696 marginsModule->outerLE->setEnabled(!custom);
1697 marginsModule->outerUnit->setEnabled(!custom);
1699 marginsModule->headheightL->setEnabled(!custom);
1700 marginsModule->headheightLE->setEnabled(!custom);
1701 marginsModule->headheightUnit->setEnabled(!custom);
1703 marginsModule->headsepL->setEnabled(!custom);
1704 marginsModule->headsepLE->setEnabled(!custom);
1705 marginsModule->headsepUnit->setEnabled(!custom);
1707 marginsModule->footskipL->setEnabled(!custom);
1708 marginsModule->footskipLE->setEnabled(!custom);
1709 marginsModule->footskipUnit->setEnabled(!custom);
1711 bool const enableColSep = !custom &&
1712 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1713 marginsModule->columnsepL->setEnabled(enableColSep);
1714 marginsModule->columnsepLE->setEnabled(enableColSep);
1715 marginsModule->columnsepUnit->setEnabled(enableColSep);
1719 void GuiDocument::changeBackgroundColor()
1721 QColor const & newColor = QColorDialog::getColor(
1722 rgb2qcolor(set_backgroundcolor), asQWidget());
1723 if (!newColor.isValid())
1725 // set the button color and text
1726 colorModule->backgroundPB->setStyleSheet(
1727 colorButtonStyleSheet(newColor));
1728 colorModule->backgroundPB->setText(qt_("&Change..."));
1730 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1731 is_backgroundcolor = true;
1736 void GuiDocument::deleteBackgroundColor()
1738 // set the button color back to default by setting an empty StyleSheet
1739 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1740 // change button text
1741 colorModule->backgroundPB->setText(qt_("&Default..."));
1742 // save default color (white)
1743 set_backgroundcolor = rgbFromHexName("#ffffff");
1744 is_backgroundcolor = false;
1749 void GuiDocument::changeFontColor()
1751 QColor const & newColor = QColorDialog::getColor(
1752 rgb2qcolor(set_fontcolor), asQWidget());
1753 if (!newColor.isValid())
1755 // set the button color and text
1756 colorModule->fontColorPB->setStyleSheet(
1757 colorButtonStyleSheet(newColor));
1758 colorModule->fontColorPB->setText(qt_("&Change..."));
1760 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1761 is_fontcolor = true;
1766 void GuiDocument::deleteFontColor()
1768 // set the button color back to default by setting an empty StyleSheet
1769 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1770 // change button text
1771 colorModule->fontColorPB->setText(qt_("&Default..."));
1772 // save default color (black)
1773 set_fontcolor = rgbFromHexName("#000000");
1774 is_fontcolor = false;
1779 void GuiDocument::changeNoteFontColor()
1781 QColor const & newColor = QColorDialog::getColor(
1782 rgb2qcolor(set_notefontcolor), asQWidget());
1783 if (!newColor.isValid())
1785 // set the button color
1786 colorModule->noteFontColorPB->setStyleSheet(
1787 colorButtonStyleSheet(newColor));
1789 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1794 void GuiDocument::deleteNoteFontColor()
1796 // set the button color back to pref
1797 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1798 colorModule->noteFontColorPB->setStyleSheet(
1799 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1804 void GuiDocument::changeBoxBackgroundColor()
1806 QColor const & newColor = QColorDialog::getColor(
1807 rgb2qcolor(set_boxbgcolor), asQWidget());
1808 if (!newColor.isValid())
1810 // set the button color
1811 colorModule->boxBackgroundPB->setStyleSheet(
1812 colorButtonStyleSheet(newColor));
1814 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1819 void GuiDocument::deleteBoxBackgroundColor()
1821 // set the button color back to pref
1822 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1823 colorModule->boxBackgroundPB->setStyleSheet(
1824 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1829 void GuiDocument::updateQuoteStyles(bool const set)
1831 Language const * lang = lyx::languages.getLanguage(
1832 fromqstr(langModule->languageCO->itemData(
1833 langModule->languageCO->currentIndex()).toString()));
1835 InsetQuotesParams::QuoteStyle def = bp_.getQuoteStyle(lang->quoteStyle());
1837 langModule->quoteStyleCO->clear();
1839 bool has_default = false;
1840 for (int i = 0; i < quoteparams.stylescount(); ++i) {
1841 InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::QuoteStyle(i);
1842 if (qs == InsetQuotesParams::DynamicQuotes)
1844 bool const langdef = (qs == def);
1846 // add the default style on top
1847 langModule->quoteStyleCO->insertItem(0,
1848 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1852 langModule->quoteStyleCO->addItem(
1853 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1855 if (set && has_default)
1856 // (re)set to the default style
1857 langModule->quoteStyleCO->setCurrentIndex(0);
1861 void GuiDocument::languageChanged(int i)
1863 // some languages only work with polyglossia
1864 Language const * lang = lyx::languages.getLanguage(
1865 fromqstr(langModule->languageCO->itemData(i).toString()));
1866 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1867 // If we force to switch fontspec on, store
1868 // current state (#8717)
1869 if (fontModule->osFontsCB->isEnabled())
1870 forced_fontspec_activation =
1871 !fontModule->osFontsCB->isChecked();
1872 fontModule->osFontsCB->setChecked(true);
1873 fontModule->osFontsCB->setEnabled(false);
1876 fontModule->osFontsCB->setEnabled(true);
1877 // If we have forced to switch fontspec on,
1878 // restore previous state (#8717)
1879 if (forced_fontspec_activation)
1880 fontModule->osFontsCB->setChecked(false);
1881 forced_fontspec_activation = false;
1884 // set appropriate quotation mark style
1885 updateQuoteStyles(true);
1889 void GuiDocument::osFontsChanged(bool nontexfonts)
1891 bool const tex_fonts = !nontexfonts;
1892 // store current fonts
1893 QString const font_roman = fontModule->fontsRomanCO->itemData(
1894 fontModule->fontsRomanCO->currentIndex()).toString();
1895 QString const font_sans = fontModule->fontsSansCO->itemData(
1896 fontModule->fontsSansCO->currentIndex()).toString();
1897 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1898 fontModule->fontsTypewriterCO->currentIndex()).toString();
1899 QString const font_math = fontModule->fontsMathCO->itemData(
1900 fontModule->fontsMathCO->currentIndex()).toString();
1901 int const font_sf_scale = fontModule->scaleSansSB->value();
1902 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1905 // store default format
1906 QString const dformat = outputModule->defaultFormatCO->itemData(
1907 outputModule->defaultFormatCO->currentIndex()).toString();
1908 updateDefaultFormat();
1909 // try to restore default format
1910 int index = outputModule->defaultFormatCO->findData(dformat);
1911 // set to default if format is not found
1914 outputModule->defaultFormatCO->setCurrentIndex(index);
1916 // try to restore fonts which were selected two toggles ago
1917 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1919 fontModule->fontsRomanCO->setCurrentIndex(index);
1920 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1922 fontModule->fontsSansCO->setCurrentIndex(index);
1923 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1925 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1926 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1928 fontModule->fontsMathCO->setCurrentIndex(index);
1929 // save fonts for next next toggle
1930 fontModule->font_roman = font_roman;
1931 fontModule->font_sans = font_sans;
1932 fontModule->font_typewriter = font_typewriter;
1933 fontModule->font_math = font_math;
1934 fontModule->font_sf_scale = font_sf_scale;
1935 fontModule->font_tt_scale = font_tt_scale;
1937 langModule->encodingCO->setEnabled(tex_fonts &&
1938 !langModule->defaultencodingRB->isChecked());
1939 langModule->defaultencodingRB->setEnabled(tex_fonts);
1940 langModule->otherencodingRB->setEnabled(tex_fonts);
1942 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1943 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1944 fontModule->cjkFontLE->setEnabled(tex_fonts);
1945 fontModule->cjkFontLA->setEnabled(tex_fonts);
1947 updateFontOptions();
1949 fontModule->fontencLA->setEnabled(tex_fonts);
1950 fontModule->fontencCO->setEnabled(tex_fonts);
1952 fontModule->fontencLE->setEnabled(false);
1954 fontencChanged(fontModule->fontencCO->currentIndex());
1958 void GuiDocument::mathFontChanged(int)
1960 updateFontOptions();
1964 void GuiDocument::fontOsfToggled(bool state)
1966 if (fontModule->osFontsCB->isChecked())
1968 QString font = fontModule->fontsRomanCO->itemData(
1969 fontModule->fontsRomanCO->currentIndex()).toString();
1970 if (hasMonolithicExpertSet(font))
1971 fontModule->fontScCB->setChecked(state);
1975 void GuiDocument::fontScToggled(bool state)
1977 if (fontModule->osFontsCB->isChecked())
1979 QString font = fontModule->fontsRomanCO->itemData(
1980 fontModule->fontsRomanCO->currentIndex()).toString();
1981 if (hasMonolithicExpertSet(font))
1982 fontModule->fontOsfCB->setChecked(state);
1986 void GuiDocument::updateFontOptions()
1988 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1991 font = fontModule->fontsSansCO->itemData(
1992 fontModule->fontsSansCO->currentIndex()).toString();
1993 bool scaleable = providesScale(font);
1994 fontModule->scaleSansSB->setEnabled(scaleable);
1995 fontModule->scaleSansLA->setEnabled(scaleable);
1997 font = fontModule->fontsTypewriterCO->itemData(
1998 fontModule->fontsTypewriterCO->currentIndex()).toString();
1999 scaleable = providesScale(font);
2000 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2001 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2003 font = fontModule->fontsRomanCO->itemData(
2004 fontModule->fontsRomanCO->currentIndex()).toString();
2005 fontModule->fontScCB->setEnabled(providesSC(font));
2006 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2007 fontModule->dashesCB->setEnabled(tex_fonts);
2008 updateMathFonts(font);
2012 void GuiDocument::updateFontsize(string const & items, string const & sel)
2014 fontModule->fontsizeCO->clear();
2015 fontModule->fontsizeCO->addItem(qt_("Default"));
2017 for (int n = 0; !token(items,'|',n).empty(); ++n)
2018 fontModule->fontsizeCO->
2019 addItem(toqstr(token(items,'|',n)));
2021 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
2022 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
2023 fontModule->fontsizeCO->setCurrentIndex(n);
2030 bool GuiDocument::ot1() const
2032 QString const fontenc =
2033 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
2034 return (fontenc == "default"
2035 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
2036 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
2040 bool GuiDocument::completeFontset() const
2042 return (fontModule->fontsSansCO->itemData(
2043 fontModule->fontsSansCO->currentIndex()).toString() == "default"
2044 && fontModule->fontsSansCO->itemData(
2045 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
2049 bool GuiDocument::noMathFont() const
2051 return (fontModule->fontsMathCO->itemData(
2052 fontModule->fontsMathCO->currentIndex()).toString() == "default");
2056 void GuiDocument::updateTexFonts()
2058 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
2060 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
2061 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
2062 for (; it != end; ++it) {
2063 LaTeXFont lf = it->second;
2064 if (lf.name().empty()) {
2065 LYXERR0("Error: Unnamed font: " << it->first);
2068 docstring const family = lf.family();
2069 docstring guiname = translateIfPossible(lf.guiname());
2070 if (!lf.available(ot1(), noMathFont()))
2071 guiname += _(" (not installed)");
2073 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
2074 else if (family == "sf")
2075 sffonts_.insert(toqstr(guiname), toqstr(it->first));
2076 else if (family == "tt")
2077 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
2078 else if (family == "math")
2079 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
2084 void GuiDocument::updateFontlist()
2086 fontModule->fontsRomanCO->clear();
2087 fontModule->fontsSansCO->clear();
2088 fontModule->fontsTypewriterCO->clear();
2089 fontModule->fontsMathCO->clear();
2091 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
2092 if (fontModule->osFontsCB->isChecked()) {
2093 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2094 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2095 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2096 QString unimath = qt_("Non-TeX Fonts Default");
2097 if (!LaTeXFeatures::isAvailable("unicode-math"))
2098 unimath += qt_(" (not available)");
2099 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
2100 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2102 QFontDatabase fontdb;
2103 QStringList families(fontdb.families());
2104 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2105 fontModule->fontsRomanCO->addItem(*it, *it);
2106 fontModule->fontsSansCO->addItem(*it, *it);
2107 fontModule->fontsTypewriterCO->addItem(*it, *it);
2112 if (rmfonts_.empty())
2115 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2116 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2117 while (rmi != rmfonts_.constEnd()) {
2118 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2122 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2123 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2124 while (sfi != sffonts_.constEnd()) {
2125 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2129 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2130 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2131 while (tti != ttfonts_.constEnd()) {
2132 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2136 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2137 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2138 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2139 while (mmi != mathfonts_.constEnd()) {
2140 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2146 void GuiDocument::fontencChanged(int item)
2148 fontModule->fontencLE->setEnabled(
2149 fontModule->fontencCO->itemData(item).toString() == "custom");
2150 // The availability of TeX fonts depends on the font encoding
2152 updateFontOptions();
2156 void GuiDocument::updateMathFonts(QString const & rm)
2158 if (fontModule->osFontsCB->isChecked())
2160 QString const math =
2161 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2162 int const i = fontModule->fontsMathCO->findData("default");
2163 if (providesNoMath(rm) && i == -1)
2164 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2165 else if (!providesNoMath(rm) && i != -1) {
2166 int const c = fontModule->fontsMathCO->currentIndex();
2167 fontModule->fontsMathCO->removeItem(i);
2169 fontModule->fontsMathCO->setCurrentIndex(0);
2174 void GuiDocument::romanChanged(int item)
2176 if (fontModule->osFontsCB->isChecked())
2178 QString const font =
2179 fontModule->fontsRomanCO->itemData(item).toString();
2180 fontModule->fontScCB->setEnabled(providesSC(font));
2181 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2182 updateMathFonts(font);
2186 void GuiDocument::sansChanged(int item)
2188 if (fontModule->osFontsCB->isChecked())
2190 QString const font =
2191 fontModule->fontsSansCO->itemData(item).toString();
2192 bool scaleable = providesScale(font);
2193 fontModule->scaleSansSB->setEnabled(scaleable);
2194 fontModule->scaleSansLA->setEnabled(scaleable);
2198 void GuiDocument::ttChanged(int item)
2200 if (fontModule->osFontsCB->isChecked())
2202 QString const font =
2203 fontModule->fontsTypewriterCO->itemData(item).toString();
2204 bool scaleable = providesScale(font);
2205 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2206 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2210 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2213 pageLayoutModule->pagestyleCO->clear();
2214 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2216 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2217 string style = token(items, '|', n);
2218 QString style_gui = qt_(style);
2219 pagestyles.push_back(pair<string, QString>(style, style_gui));
2220 pageLayoutModule->pagestyleCO->addItem(style_gui);
2223 if (sel == "default") {
2224 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2230 for (size_t i = 0; i < pagestyles.size(); ++i)
2231 if (pagestyles[i].first == sel)
2232 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2235 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2239 void GuiDocument::browseLayout()
2241 QString const label1 = qt_("Layouts|#o#O");
2242 QString const dir1 = toqstr(lyxrc.document_path);
2243 QStringList const filter(qt_("LyX Layout (*.layout)"));
2244 QString file = browseRelToParent(QString(), bufferFilePath(),
2245 qt_("Local layout file"), filter, false,
2248 if (!file.endsWith(".layout"))
2251 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2252 fromqstr(bufferFilePath()));
2254 int const ret = Alert::prompt(_("Local layout file"),
2255 _("The layout file you have selected is a local layout\n"
2256 "file, not one in the system or user directory.\n"
2257 "Your document will not work with this layout if you\n"
2258 "move the layout file to a different directory."),
2259 1, 1, _("&Set Layout"), _("&Cancel"));
2263 // load the layout file
2264 LayoutFileList & bcl = LayoutFileList::get();
2265 string classname = layoutFile.onlyFileName();
2266 // this will update an existing layout if that layout has been loaded before.
2267 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2268 classname.substr(0, classname.size() - 7),
2269 layoutFile.onlyPath().absFileName()));
2272 Alert::error(_("Error"),
2273 _("Unable to read local layout file."));
2277 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2279 // do not trigger classChanged if there is no change.
2280 if (latexModule->classCO->currentText() == toqstr(name))
2284 bool const avail = latexModule->classCO->set(toqstr(name));
2286 LayoutFile const & tc = bcl[name];
2287 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2288 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2289 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2290 tooltip += '\n' + qt_("This is a local layout file.");
2291 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2292 toqstr(translateIfPossible(from_utf8(tc.category()))),
2294 true, true, true, true);
2295 latexModule->classCO->set(toqstr(name));
2302 void GuiDocument::browseMaster()
2304 QString const title = qt_("Select master document");
2305 QString const dir1 = toqstr(lyxrc.document_path);
2306 QString const old = latexModule->childDocLE->text();
2307 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2308 QStringList const filter(qt_("LyX Files (*.lyx)"));
2309 QString file = browseRelToSub(old, docpath, title, filter, false,
2310 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2312 if (!file.isEmpty())
2313 latexModule->childDocLE->setText(file);
2317 void GuiDocument::classChanged_adaptor()
2319 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2324 void GuiDocument::classChanged()
2326 int idx = latexModule->classCO->currentIndex();
2329 string const classname = fromqstr(latexModule->classCO->getData(idx));
2331 if (applyPB->isEnabled()) {
2332 int const ret = Alert::prompt(_("Unapplied changes"),
2333 _("Some changes in the dialog were not yet applied.\n"
2334 "If you do not apply now, they will be lost after this action."),
2335 1, 1, _("&Apply"), _("&Dismiss"));
2340 // We load the TextClass as soon as it is selected. This is
2341 // necessary so that other options in the dialog can be updated
2342 // according to the new class. Note, however, that, if you use
2343 // the scroll wheel when sitting on the combo box, we'll load a
2344 // lot of TextClass objects very quickly....
2345 if (!bp_.setBaseClass(classname)) {
2346 Alert::error(_("Error"), _("Unable to set document class."));
2349 if (lyxrc.auto_reset_options)
2350 bp_.useClassDefaults();
2352 // With the introduction of modules came a distinction between the base
2353 // class and the document class. The former corresponds to the main layout
2354 // file; the latter is that plus the modules (or the document-specific layout,
2355 // or whatever else there could be). Our parameters come from the document
2356 // class. So when we set the base class, we also need to recreate the document
2357 // class. Otherwise, we still have the old one.
2358 bp_.makeDocumentClass();
2363 void GuiDocument::languagePackageChanged(int i)
2365 langModule->languagePackageLE->setEnabled(
2366 langModule->languagePackageCO->itemData(i).toString() == "custom");
2370 void GuiDocument::biblioChanged()
2372 biblioChanged_ = true;
2377 void GuiDocument::rescanBibFiles()
2380 rescanTexStyles("bbx cbx");
2382 rescanTexStyles("bst");
2386 void GuiDocument::resetDefaultBibfile(string const & which)
2388 QString const engine =
2389 biblioModule->citeEngineCO->itemData(
2390 biblioModule->citeEngineCO->currentIndex()).toString();
2392 CiteEngineType const cet =
2393 CiteEngineType(biblioModule->citeStyleCO->itemData(
2394 biblioModule->citeStyleCO->currentIndex()).toInt());
2396 updateDefaultBiblio(theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet), which);
2400 void GuiDocument::resetDefaultBbxBibfile()
2402 resetDefaultBibfile("bbx");
2406 void GuiDocument::resetDefaultCbxBibfile()
2408 resetDefaultBibfile("cbx");
2412 void GuiDocument::citeEngineChanged(int n)
2414 QString const engine =
2415 biblioModule->citeEngineCO->itemData(n).toString();
2417 vector<string> const engs =
2418 theCiteEnginesList[fromqstr(engine)]->getEngineType();
2420 updateCiteStyles(engs);
2421 updateEngineDependends();
2422 resetDefaultBibfile();
2427 void GuiDocument::updateEngineDependends()
2429 bool const biblatex = isBiblatex();
2431 // These are only useful with BibTeX
2432 biblioModule->defaultBiblioCO->setEnabled(!biblatex);
2433 biblioModule->bibtexStyleLA->setEnabled(!biblatex);
2434 biblioModule->resetDefaultBiblioPB->setEnabled(!biblatex);
2435 biblioModule->bibtopicCB->setEnabled(!biblatex);
2437 // These are only useful with Biblatex
2438 biblioModule->biblatexBbxCO->setEnabled(biblatex);
2439 biblioModule->biblatexBbxLA->setEnabled(biblatex);
2440 biblioModule->biblatexCbxCO->setEnabled(biblatex);
2441 biblioModule->biblatexCbxLA->setEnabled(biblatex);
2442 biblioModule->resetBbxPB->setEnabled(biblatex);
2443 biblioModule->resetCbxPB->setEnabled(biblatex);
2444 biblioModule->matchBbxPB->setEnabled(biblatex);
2446 // These are useful with biblatex, jurabib and natbib
2447 QString const engine =
2448 biblioModule->citeEngineCO->itemData(
2449 biblioModule->citeEngineCO->currentIndex()).toString();
2450 LyXCiteEngine const * ce = theCiteEnginesList[fromqstr(engine)];
2452 bool const citepack = ce->requires("biblatex.sty") || ce->requires("jurabib.sty")
2453 || ce->requires("natbib.sty");
2454 biblioModule->citePackageOptionsLE->setEnabled(citepack);
2455 biblioModule->citePackageOptionsL->setEnabled(citepack);
2459 void GuiDocument::citeStyleChanged()
2461 QString const engine =
2462 biblioModule->citeEngineCO->itemData(
2463 biblioModule->citeEngineCO->currentIndex()).toString();
2464 QString const currentDef = isBiblatex() ?
2465 biblioModule->biblatexBbxCO->currentText()
2466 : biblioModule->defaultBiblioCO->currentText();
2467 if (theCiteEnginesList[fromqstr(engine)]->isDefaultBiblio(fromqstr(currentDef)))
2468 resetDefaultBibfile();
2474 void GuiDocument::bibtexChanged(int n)
2476 biblioModule->bibtexOptionsLE->setEnabled(
2477 biblioModule->bibtexCO->itemData(n).toString() != "default");
2482 void GuiDocument::updateCiteStyles(vector<string> const & engs, CiteEngineType const & sel)
2484 biblioModule->citeStyleCO->clear();
2486 vector<string>::const_iterator it = engs.begin();
2487 vector<string>::const_iterator end = engs.end();
2488 for (; it != end; ++it) {
2489 if (*it == "default")
2490 biblioModule->citeStyleCO->addItem(qt_("Basic numerical"),
2491 ENGINE_TYPE_DEFAULT);
2492 else if (*it == "authoryear")
2493 biblioModule->citeStyleCO->addItem(qt_("Author-year"),
2494 ENGINE_TYPE_AUTHORYEAR);
2495 else if (*it == "numerical")
2496 biblioModule->citeStyleCO->addItem(qt_("Author-number"),
2497 ENGINE_TYPE_NUMERICAL);
2499 int i = biblioModule->citeStyleCO->findData(sel);
2500 if (biblioModule->citeStyleCO->findData(sel) == -1)
2502 biblioModule->citeStyleCO->setCurrentIndex(i);
2504 biblioModule->citationStyleL->setEnabled(engs.size() > 1);
2505 biblioModule->citeStyleCO->setEnabled(engs.size() > 1);
2509 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2511 engine_types_.clear();
2515 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2517 string style = token(items, '|', n);
2518 engine_types_.push_back(style);
2521 updateCiteStyles(engine_types_, sel);
2527 // both of these should take a vector<docstring>
2529 // This is an insanely complicated attempt to make this sort of thing
2530 // work with RTL languages.
2531 docstring formatStrVec(vector<string> const & v, docstring const & s)
2533 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2537 return translateIfPossible(from_utf8(v[0]));
2538 if (v.size() == 2) {
2539 docstring retval = _("%1$s and %2$s");
2540 retval = subst(retval, _("and"), s);
2541 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2542 translateIfPossible(from_utf8(v[1])));
2544 // The idea here is to format all but the last two items...
2545 int const vSize = v.size();
2546 docstring t2 = _("%1$s, %2$s");
2547 docstring retval = translateIfPossible(from_utf8(v[0]));
2548 for (int i = 1; i < vSize - 2; ++i)
2549 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2550 //...and then to plug them, and the last two, into this schema
2551 docstring t = _("%1$s, %2$s, and %3$s");
2552 t = subst(t, _("and"), s);
2553 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2554 translateIfPossible(from_utf8(v[vSize - 1])));
2557 vector<string> idsToNames(vector<string> const & idList)
2559 vector<string> retval;
2560 vector<string>::const_iterator it = idList.begin();
2561 vector<string>::const_iterator end = idList.end();
2562 for (; it != end; ++it) {
2563 LyXModule const * const mod = theModuleList[*it];
2565 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2566 translateIfPossible(from_utf8(*it)))));
2568 retval.push_back(mod->getName());
2572 } // end anonymous namespace
2575 void GuiDocument::modulesToParams(BufferParams & bp)
2577 // update list of loaded modules
2578 bp.clearLayoutModules();
2579 int const srows = modules_sel_model_.rowCount();
2580 for (int i = 0; i < srows; ++i)
2581 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2583 // update the list of removed modules
2584 bp.clearRemovedModules();
2585 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2586 list<string>::const_iterator rit = reqmods.begin();
2587 list<string>::const_iterator ren = reqmods.end();
2589 // check each of the default modules
2590 for (; rit != ren; ++rit) {
2591 list<string>::const_iterator mit = bp.getModules().begin();
2592 list<string>::const_iterator men = bp.getModules().end();
2594 for (; mit != men; ++mit) {
2601 // the module isn't present so must have been removed by the user
2602 bp.addRemovedModule(*rit);
2607 void GuiDocument::modulesChanged()
2609 modulesToParams(bp_);
2611 if (applyPB->isEnabled() && nonModuleChanged_) {
2612 int const ret = Alert::prompt(_("Unapplied changes"),
2613 _("Some changes in the dialog were not yet applied.\n"
2614 "If you do not apply now, they will be lost after this action."),
2615 1, 1, _("&Apply"), _("&Dismiss"));
2620 bp_.makeDocumentClass();
2626 void GuiDocument::updateModuleInfo()
2628 selectionManager->update();
2630 //Module description
2631 bool const focus_on_selected = selectionManager->selectedFocused();
2632 QAbstractItemView * lv;
2633 if (focus_on_selected)
2634 lv = modulesModule->selectedLV;
2636 lv = modulesModule->availableLV;
2637 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2638 modulesModule->infoML->document()->clear();
2641 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2642 GuiIdListModel const & id_model =
2643 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2644 string const modName = id_model.getIDString(idx.row());
2645 docstring desc = getModuleDescription(modName);
2647 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2648 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2651 desc += _("Module provided by document class.");
2654 docstring cat = getModuleCategory(modName);
2658 desc += bformat(_("Category: %1$s."), cat);
2661 vector<string> pkglist = getPackageList(modName);
2662 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2663 if (!pkgdesc.empty()) {
2666 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2669 pkglist = getRequiredList(modName);
2670 if (!pkglist.empty()) {
2671 vector<string> const reqdescs = idsToNames(pkglist);
2672 pkgdesc = formatStrVec(reqdescs, _("or"));
2675 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2678 pkglist = getExcludedList(modName);
2679 if (!pkglist.empty()) {
2680 vector<string> const reqdescs = idsToNames(pkglist);
2681 pkgdesc = formatStrVec(reqdescs, _( "and"));
2684 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2687 if (!isModuleAvailable(modName)) {
2690 desc += _("WARNING: Some required packages are unavailable!");
2693 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2697 void GuiDocument::updateNumbering()
2699 DocumentClass const & tclass = documentClass();
2701 numberingModule->tocTW->setUpdatesEnabled(false);
2702 numberingModule->tocTW->clear();
2704 int const depth = numberingModule->depthSL->value();
2705 int const toc = numberingModule->tocSL->value();
2706 QString const no = qt_("No");
2707 QString const yes = qt_("Yes");
2708 QTreeWidgetItem * item = 0;
2710 DocumentClass::const_iterator lit = tclass.begin();
2711 DocumentClass::const_iterator len = tclass.end();
2712 for (; lit != len; ++lit) {
2713 int const toclevel = lit->toclevel;
2714 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2715 item = new QTreeWidgetItem(numberingModule->tocTW);
2716 item->setText(0, toqstr(translateIfPossible(lit->name())));
2717 item->setText(1, (toclevel <= depth) ? yes : no);
2718 item->setText(2, (toclevel <= toc) ? yes : no);
2722 numberingModule->tocTW->setUpdatesEnabled(true);
2723 numberingModule->tocTW->update();
2727 void GuiDocument::updateDefaultFormat()
2731 // make a copy in order to consider unapplied changes
2732 BufferParams param_copy = buffer().params();
2733 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2734 int const idx = latexModule->classCO->currentIndex();
2736 string const classname = fromqstr(latexModule->classCO->getData(idx));
2737 param_copy.setBaseClass(classname);
2738 param_copy.makeDocumentClass(true);
2740 outputModule->defaultFormatCO->blockSignals(true);
2741 outputModule->defaultFormatCO->clear();
2742 outputModule->defaultFormatCO->addItem(qt_("Default"),
2743 QVariant(QString("default")));
2744 FormatList const & formats =
2745 param_copy.exportableFormats(true);
2746 for (Format const * f : formats)
2747 outputModule->defaultFormatCO->addItem
2748 (toqstr(translateIfPossible(f->prettyname())),
2749 QVariant(toqstr(f->name())));
2750 outputModule->defaultFormatCO->blockSignals(false);
2754 bool GuiDocument::isChildIncluded(string const & child)
2756 if (includeonlys_.empty())
2758 return (std::find(includeonlys_.begin(),
2759 includeonlys_.end(), child) != includeonlys_.end());
2763 void GuiDocument::applyView()
2766 preambleModule->apply(bp_);
2767 localLayout->apply(bp_);
2770 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2771 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2774 string const engine =
2775 fromqstr(biblioModule->citeEngineCO->itemData(
2776 biblioModule->citeEngineCO->currentIndex()).toString());
2777 bp_.setCiteEngine(engine);
2779 CiteEngineType const style = CiteEngineType(biblioModule->citeStyleCO->itemData(
2780 biblioModule->citeStyleCO->currentIndex()).toInt());
2781 if (theCiteEnginesList[engine]->hasEngineType(style))
2782 bp_.setCiteEngineType(style);
2784 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2786 bp_.splitbib(biblioModule->bibtopicCB->isChecked());
2788 bp_.multibib = fromqstr(biblioModule->bibunitsCO->itemData(
2789 biblioModule->bibunitsCO->currentIndex()).toString());
2791 bp_.setDefaultBiblioStyle(fromqstr(biblioModule->defaultBiblioCO->currentText()));
2793 bp_.biblatex_bibstyle = fromqstr(biblioModule->biblatexBbxCO->currentText());
2794 bp_.biblatex_citestyle = fromqstr(biblioModule->biblatexCbxCO->currentText());
2795 bp_.biblio_opts = fromqstr(biblioModule->citePackageOptionsLE->text());
2797 string const bibtex_command =
2798 fromqstr(biblioModule->bibtexCO->itemData(
2799 biblioModule->bibtexCO->currentIndex()).toString());
2800 string const bibtex_options =
2801 fromqstr(biblioModule->bibtexOptionsLE->text());
2802 if (bibtex_command == "default" || bibtex_options.empty())
2803 bp_.bibtex_command = bibtex_command;
2805 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2807 if (biblioChanged_) {
2808 buffer().invalidateBibinfoCache();
2809 buffer().removeBiblioTempFiles();
2813 indicesModule->apply(bp_);
2815 // language & quotes
2816 if (langModule->defaultencodingRB->isChecked()) {
2817 bp_.inputenc = "auto";
2819 int i = langModule->encodingCO->currentIndex();
2821 bp_.inputenc = "default";
2823 QString const enc_gui =
2824 langModule->encodingCO->currentText();
2825 Encodings::const_iterator it = encodings.begin();
2826 Encodings::const_iterator const end = encodings.end();
2828 for (; it != end; ++it) {
2829 if (qt_(it->guiName()) == enc_gui &&
2831 bp_.inputenc = it->name();
2837 // should not happen
2838 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2839 bp_.inputenc = "default";
2844 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2845 langModule->quoteStyleCO->currentIndex()).toInt();
2846 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2848 QString const langname = langModule->languageCO->itemData(
2849 langModule->languageCO->currentIndex()).toString();
2850 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2851 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2852 // If current cursor language was the document language, then update it too.
2853 if (cur.current_font.language() == bp_.language) {
2854 cur.current_font.setLanguage(newlang);
2855 cur.real_current_font.setLanguage(newlang);
2857 bp_.language = newlang;
2859 QString const pack = langModule->languagePackageCO->itemData(
2860 langModule->languagePackageCO->currentIndex()).toString();
2861 if (pack == "custom")
2863 fromqstr(langModule->languagePackageLE->text());
2865 bp_.lang_package = fromqstr(pack);
2868 bp_.backgroundcolor = set_backgroundcolor;
2869 bp_.isbackgroundcolor = is_backgroundcolor;
2870 bp_.fontcolor = set_fontcolor;
2871 bp_.isfontcolor = is_fontcolor;
2872 bp_.notefontcolor = set_notefontcolor;
2873 bp_.boxbgcolor = set_boxbgcolor;
2876 if (bp_.documentClass().hasTocLevels()) {
2877 bp_.tocdepth = numberingModule->tocSL->value();
2878 bp_.secnumdepth = numberingModule->depthSL->value();
2882 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2883 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2884 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2885 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2888 bp_.graphics_driver =
2889 tex_graphics[latexModule->psdriverCO->currentIndex()];
2892 int idx = latexModule->classCO->currentIndex();
2894 string const classname = fromqstr(latexModule->classCO->getData(idx));
2895 bp_.setBaseClass(classname);
2899 modulesToParams(bp_);
2902 map<string, string> const & packages = BufferParams::auto_packages();
2903 for (map<string, string>::const_iterator it = packages.begin();
2904 it != packages.end(); ++it) {
2905 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2908 int row = mathsModule->packagesTW->row(item);
2909 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2910 if (rb->isChecked()) {
2911 bp_.use_package(it->first, BufferParams::package_auto);
2914 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2915 if (rb->isChecked()) {
2916 bp_.use_package(it->first, BufferParams::package_on);
2919 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2920 if (rb->isChecked())
2921 bp_.use_package(it->first, BufferParams::package_off);
2923 bp_.is_math_indent = mathsModule->MathIndentCB->isChecked();
2924 // if math is indented
2925 if (bp_.is_math_indent) {
2926 Length mathindent(widgetsToLength(mathsModule->MathIndentLE,
2927 mathsModule->MathIndentLengthCO));
2928 bp_.setMathIndent(mathindent);
2930 if (mathsModule->MathIndentCB->isChecked()) {
2931 // if formulas are indented
2932 switch (mathsModule->MathIndentCO->currentIndex()) {
2934 bp_.setMathIndent(Length());
2937 Length mathindent(widgetsToLength(mathsModule->MathIndentLE,
2938 mathsModule->MathIndentLengthCO));
2939 bp_.setMathIndent(mathindent);
2943 // this should never happen
2944 bp_.setMathIndent(Length());
2948 switch (mathsModule->MathNumberingPosCO->currentIndex()) {
2950 bp_.math_number_before = true;
2953 bp_.math_number_before = false;
2956 // this should never happen
2957 bp_.math_number_before = false;
2962 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2963 bp_.pagestyle = "default";
2965 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2966 for (size_t i = 0; i != pagestyles.size(); ++i)
2967 if (pagestyles[i].second == style_gui)
2968 bp_.pagestyle = pagestyles[i].first;
2972 switch (textLayoutModule->lspacingCO->currentIndex()) {
2974 bp_.spacing().set(Spacing::Single);
2977 bp_.spacing().set(Spacing::Onehalf);
2980 bp_.spacing().set(Spacing::Double);
2983 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2985 bp_.spacing().set(Spacing::Single);
2987 bp_.spacing().set(Spacing::Other, s);
2992 if (textLayoutModule->twoColumnCB->isChecked())
2997 bp_.justification = textLayoutModule->justCB->isChecked();
2999 if (textLayoutModule->indentRB->isChecked()) {
3000 // if paragraphs are separated by an indentation
3001 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
3002 switch (textLayoutModule->indentCO->currentIndex()) {
3004 bp_.setParIndent(Length());
3007 Length parindent(widgetsToLength(textLayoutModule->indentLE,
3008 textLayoutModule->indentLengthCO));
3009 bp_.setParIndent(parindent);
3013 // this should never happen
3014 bp_.setParIndent(Length());
3018 // if paragraphs are separated by a skip
3019 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
3020 switch (textLayoutModule->skipCO->currentIndex()) {
3022 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
3025 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
3028 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
3033 widgetsToLength(textLayoutModule->skipLE,
3034 textLayoutModule->skipLengthCO)
3040 // this should never happen
3041 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
3047 fromqstr(latexModule->optionsLE->text());
3049 bp_.use_default_options =
3050 latexModule->defaultOptionsCB->isChecked();
3052 if (latexModule->childDocGB->isChecked())
3054 fromqstr(latexModule->childDocLE->text());
3056 bp_.master = string();
3059 bp_.clearIncludedChildren();
3060 if (masterChildModule->includeonlyRB->isChecked()) {
3061 list<string>::const_iterator it = includeonlys_.begin();
3062 for (; it != includeonlys_.end() ; ++it) {
3063 bp_.addIncludedChildren(*it);
3066 bp_.maintain_unincluded_children =
3067 masterChildModule->maintainAuxCB->isChecked();
3070 bp_.float_placement = floatModule->get();
3073 // text should have passed validation
3074 bp_.listings_params =
3075 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
3078 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
3079 outputModule->defaultFormatCO->currentIndex()).toString());
3081 bool const nontexfonts = fontModule->osFontsCB->isChecked();
3082 bp_.useNonTeXFonts = nontexfonts;
3084 bp_.output_sync = outputModule->outputsyncCB->isChecked();
3086 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
3088 int mathfmt = outputModule->mathoutCB->currentIndex();
3091 BufferParams::MathOutput const mo =
3092 static_cast<BufferParams::MathOutput>(mathfmt);
3093 bp_.html_math_output = mo;
3094 bp_.html_be_strict = outputModule->strictCB->isChecked();
3095 bp_.html_css_as_file = outputModule->cssCB->isChecked();
3096 bp_.html_math_img_scale = outputModule->mathimgSB->value();
3097 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
3099 bp_.save_transient_properties =
3100 outputModule->saveTransientPropertiesCB->isChecked();
3103 bp_.fonts_roman[nontexfonts] =
3104 fromqstr(fontModule->fontsRomanCO->
3105 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
3106 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
3108 bp_.fonts_sans[nontexfonts] =
3109 fromqstr(fontModule->fontsSansCO->
3110 itemData(fontModule->fontsSansCO->currentIndex()).toString());
3111 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
3113 bp_.fonts_typewriter[nontexfonts] =
3114 fromqstr(fontModule->fontsTypewriterCO->
3115 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
3116 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
3118 bp_.fonts_math[nontexfonts] =
3119 fromqstr(fontModule->fontsMathCO->
3120 itemData(fontModule->fontsMathCO->currentIndex()).toString());
3121 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
3123 QString const fontenc =
3124 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
3125 if (fontenc == "custom")
3126 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
3128 bp_.fontenc = fromqstr(fontenc);
3131 fromqstr(fontModule->cjkFontLE->text());
3133 bp_.use_microtype = fontModule->microtypeCB->isChecked();
3134 bp_.use_dash_ligatures = fontModule->dashesCB->isChecked();
3136 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
3137 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
3139 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
3140 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
3142 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
3144 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
3147 bp_.fonts_default_family = "default";
3149 bp_.fonts_default_family = GuiDocument::fontfamilies[
3150 fontModule->fontsDefaultCO->currentIndex()];
3152 if (fontModule->fontsizeCO->currentIndex() == 0)
3153 bp_.fontsize = "default";
3156 fromqstr(fontModule->fontsizeCO->currentText());
3159 bp_.papersize = PAPER_SIZE(
3160 pageLayoutModule->papersizeCO->currentIndex());
3162 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
3163 pageLayoutModule->paperwidthUnitCO);
3165 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
3166 pageLayoutModule->paperheightUnitCO);
3168 if (pageLayoutModule->facingPagesCB->isChecked())
3169 bp_.sides = TwoSides;
3171 bp_.sides = OneSide;
3173 if (pageLayoutModule->landscapeRB->isChecked())
3174 bp_.orientation = ORIENTATION_LANDSCAPE;
3176 bp_.orientation = ORIENTATION_PORTRAIT;
3179 bp_.use_geometry = !marginsModule->marginCB->isChecked();
3181 Ui::MarginsUi const * m = marginsModule;
3183 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
3184 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
3185 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3186 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3187 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3188 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3189 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3190 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3193 branchesModule->apply(bp_);
3196 PDFOptions & pdf = bp_.pdfoptions();
3197 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3198 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3199 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3200 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3201 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3203 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3204 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3205 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3206 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3208 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3209 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3210 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3211 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3213 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3214 if (pdfSupportModule->fullscreenCB->isChecked())
3215 pdf.pagemode = pdf.pagemode_fullscreen;
3217 pdf.pagemode.clear();
3218 pdf.quoted_options = pdf.quoted_options_check(
3219 fromqstr(pdfSupportModule->optionsLE->text()));
3222 nonModuleChanged_ = false;
3226 void GuiDocument::paramsToDialog()
3228 // set the default unit
3229 Length::UNIT const default_unit = Length::defaultUnit();
3232 preambleModule->update(bp_, id());
3233 localLayout->update(bp_, id());
3236 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3237 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3240 string const cite_engine = bp_.citeEngine().list().front();
3242 biblioModule->citeEngineCO->setCurrentIndex(
3243 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3245 updateEngineType(documentClass().opt_enginetype(),
3246 bp_.citeEngineType());
3248 biblioModule->citeStyleCO->setCurrentIndex(
3249 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3251 biblioModule->bibtopicCB->setChecked(bp_.splitbib());
3253 biblioModule->bibunitsCO->clear();
3254 biblioModule->bibunitsCO->addItem(qt_("No"), QString());
3255 if (documentClass().hasLaTeXLayout("part"))
3256 biblioModule->bibunitsCO->addItem(qt_("per part"), toqstr("part"));
3257 if (documentClass().hasLaTeXLayout("chapter"))
3258 biblioModule->bibunitsCO->addItem(qt_("per chapter"), toqstr("chapter"));
3259 if (documentClass().hasLaTeXLayout("section"))
3260 biblioModule->bibunitsCO->addItem(qt_("per section"), toqstr("section"));
3261 if (documentClass().hasLaTeXLayout("subsection"))
3262 biblioModule->bibunitsCO->addItem(qt_("per subsection"), toqstr("subsection"));
3263 biblioModule->bibunitsCO->addItem(qt_("per child document"), toqstr("child"));
3265 int const mbpos = biblioModule->bibunitsCO->findData(toqstr(bp_.multibib));
3267 biblioModule->bibunitsCO->setCurrentIndex(mbpos);
3269 biblioModule->bibunitsCO->setCurrentIndex(0);
3271 updateEngineDependends();
3274 updateDefaultBiblio(bp_.biblatex_bibstyle, "bbx");
3275 updateDefaultBiblio(bp_.biblatex_citestyle, "cbx");
3277 updateDefaultBiblio(bp_.defaultBiblioStyle());
3279 biblioModule->citePackageOptionsLE->setText(toqstr(bp_.biblio_opts));
3283 split(bp_.bibtex_command, command, ' ');
3285 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3287 biblioModule->bibtexCO->setCurrentIndex(bpos);
3288 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3290 // We reset to default if we do not know the specified compiler
3291 // This is for security reasons
3292 biblioModule->bibtexCO->setCurrentIndex(
3293 biblioModule->bibtexCO->findData(toqstr("default")));
3294 biblioModule->bibtexOptionsLE->clear();
3296 biblioModule->bibtexOptionsLE->setEnabled(
3297 biblioModule->bibtexCO->currentIndex() != 0);
3299 biblioChanged_ = false;
3302 // We may be called when there is no Buffer, e.g., when
3303 // the last view has just been closed.
3304 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3305 indicesModule->update(bp_, isReadOnly);
3307 // language & quotes
3308 int const pos = langModule->languageCO->findData(toqstr(
3309 bp_.language->lang()));
3310 langModule->languageCO->setCurrentIndex(pos);
3312 updateQuoteStyles();
3314 langModule->quoteStyleCO->setCurrentIndex(
3315 langModule->quoteStyleCO->findData(bp_.quotes_style));
3316 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3318 bool default_enc = true;
3319 if (bp_.inputenc != "auto") {
3320 default_enc = false;
3321 if (bp_.inputenc == "default") {
3322 langModule->encodingCO->setCurrentIndex(0);
3325 Encodings::const_iterator it = encodings.begin();
3326 Encodings::const_iterator const end = encodings.end();
3327 for (; it != end; ++it) {
3328 if (it->name() == bp_.inputenc &&
3330 enc_gui = it->guiName();
3334 int const i = langModule->encodingCO->findText(
3337 langModule->encodingCO->setCurrentIndex(i);
3339 // unknown encoding. Set to default.
3343 langModule->defaultencodingRB->setChecked(default_enc);
3344 langModule->otherencodingRB->setChecked(!default_enc);
3346 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3348 langModule->languagePackageCO->setCurrentIndex(
3349 langModule->languagePackageCO->findData("custom"));
3350 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3352 langModule->languagePackageCO->setCurrentIndex(p);
3353 langModule->languagePackageLE->clear();
3357 if (bp_.isfontcolor) {
3358 colorModule->fontColorPB->setStyleSheet(
3359 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3361 set_fontcolor = bp_.fontcolor;
3362 is_fontcolor = bp_.isfontcolor;
3364 colorModule->noteFontColorPB->setStyleSheet(
3365 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3366 set_notefontcolor = bp_.notefontcolor;
3368 if (bp_.isbackgroundcolor) {
3369 colorModule->backgroundPB->setStyleSheet(
3370 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3372 set_backgroundcolor = bp_.backgroundcolor;
3373 is_backgroundcolor = bp_.isbackgroundcolor;
3375 colorModule->boxBackgroundPB->setStyleSheet(
3376 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3377 set_boxbgcolor = bp_.boxbgcolor;
3380 int const min_toclevel = documentClass().min_toclevel();
3381 int const max_toclevel = documentClass().max_toclevel();
3382 if (documentClass().hasTocLevels()) {
3383 numberingModule->setEnabled(true);
3384 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3385 numberingModule->depthSL->setMaximum(max_toclevel);
3386 numberingModule->depthSL->setValue(bp_.secnumdepth);
3387 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3388 numberingModule->tocSL->setMaximum(max_toclevel);
3389 numberingModule->tocSL->setValue(bp_.tocdepth);
3392 numberingModule->setEnabled(false);
3393 numberingModule->tocTW->clear();
3397 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3398 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3399 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3400 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3401 bulletsModule->init();
3404 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3406 latexModule->psdriverCO->setCurrentIndex(nitem);
3410 if (bp_.is_math_indent) {
3411 mathsModule->MathIndentCB->setChecked(bp_.is_math_indent);
3412 Length const mathindent = bp_.getMathIndent();
3414 if (!mathindent.empty()) {
3415 lengthToWidgets(mathsModule->MathIndentLE,
3416 mathsModule->MathIndentLengthCO,
3417 mathindent, default_unit);
3420 mathsModule->MathIndentCO->setCurrentIndex(indent);
3421 setMathIndent(indent);
3423 if (bp_.math_number_before)
3424 mathsModule->MathNumberingPosCO->setCurrentIndex(0);
3426 mathsModule->MathNumberingPosCO->setCurrentIndex(1);
3428 map<string, string> const & packages = BufferParams::auto_packages();
3429 for (map<string, string>::const_iterator it = packages.begin();
3430 it != packages.end(); ++it) {
3431 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3434 int row = mathsModule->packagesTW->row(item);
3435 switch (bp_.use_package(it->first)) {
3436 case BufferParams::package_off: {
3437 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3438 rb->setChecked(true);
3441 case BufferParams::package_on: {
3442 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3443 rb->setChecked(true);
3446 case BufferParams::package_auto: {
3447 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3448 rb->setChecked(true);
3454 switch (bp_.spacing().getSpace()) {
3455 case Spacing::Other: nitem = 3; break;
3456 case Spacing::Double: nitem = 2; break;
3457 case Spacing::Onehalf: nitem = 1; break;
3458 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3462 string const & layoutID = bp_.baseClassID();
3463 setLayoutComboByIDString(layoutID);
3465 updatePagestyle(documentClass().opt_pagestyle(),
3468 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3469 if (bp_.spacing().getSpace() == Spacing::Other) {
3470 doubleToWidget(textLayoutModule->lspacingLE,
3471 bp_.spacing().getValueAsString());
3475 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3476 textLayoutModule->indentRB->setChecked(true);
3477 string parindent = bp_.getParIndent().asString();
3479 if (!parindent.empty()) {
3480 lengthToWidgets(textLayoutModule->indentLE,
3481 textLayoutModule->indentLengthCO,
3482 parindent, default_unit);
3485 textLayoutModule->indentCO->setCurrentIndex(indent);
3488 textLayoutModule->skipRB->setChecked(true);
3490 switch (bp_.getDefSkip().kind()) {
3491 case VSpace::SMALLSKIP:
3494 case VSpace::MEDSKIP:
3497 case VSpace::BIGSKIP:
3500 case VSpace::LENGTH:
3503 string const length = bp_.getDefSkip().asLyXCommand();
3504 lengthToWidgets(textLayoutModule->skipLE,
3505 textLayoutModule->skipLengthCO,
3506 length, default_unit);
3513 textLayoutModule->skipCO->setCurrentIndex(skip);
3517 textLayoutModule->twoColumnCB->setChecked(
3519 textLayoutModule->justCB->setChecked(bp_.justification);
3521 if (!bp_.options.empty()) {
3522 latexModule->optionsLE->setText(
3523 toqstr(bp_.options));
3525 latexModule->optionsLE->setText(QString());
3529 latexModule->defaultOptionsCB->setChecked(
3530 bp_.use_default_options);
3531 updateSelectedModules();
3532 selectionManager->updateProvidedModules(
3533 bp_.baseClass()->providedModules());
3534 selectionManager->updateExcludedModules(
3535 bp_.baseClass()->excludedModules());
3537 if (!documentClass().options().empty()) {
3538 latexModule->defaultOptionsLE->setText(
3539 toqstr(documentClass().options()));
3541 latexModule->defaultOptionsLE->setText(
3542 toqstr(_("[No options predefined]")));
3545 latexModule->defaultOptionsLE->setEnabled(
3546 bp_.use_default_options
3547 && !documentClass().options().empty());
3549 latexModule->defaultOptionsCB->setEnabled(
3550 !documentClass().options().empty());
3552 if (!bp_.master.empty()) {
3553 latexModule->childDocGB->setChecked(true);
3554 latexModule->childDocLE->setText(
3555 toqstr(bp_.master));
3557 latexModule->childDocLE->setText(QString());
3558 latexModule->childDocGB->setChecked(false);
3562 if (!bufferview() || !buffer().hasChildren()) {
3563 masterChildModule->childrenTW->clear();
3564 includeonlys_.clear();
3565 docPS->showPanel("Child Documents", false);
3566 if (docPS->isCurrentPanel("Child Documents"))
3567 docPS->setCurrentPanel("Document Class");
3569 docPS->showPanel("Child Documents", true);
3570 masterChildModule->setEnabled(true);
3571 includeonlys_ = bp_.getIncludedChildren();
3572 updateIncludeonlys();
3574 masterChildModule->maintainAuxCB->setChecked(
3575 bp_.maintain_unincluded_children);
3578 floatModule->set(bp_.float_placement);
3581 // break listings_params to multiple lines
3583 InsetListingsParams(bp_.listings_params).separatedParams();
3584 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3587 // some languages only work with polyglossia/XeTeX
3588 Language const * lang = lyx::languages.getLanguage(
3589 fromqstr(langModule->languageCO->itemData(
3590 langModule->languageCO->currentIndex()).toString()));
3591 bool const need_fontspec =
3592 lang->babel().empty() && !lang->polyglossia().empty();
3593 bool const os_fonts_available =
3594 bp_.baseClass()->outputType() == lyx::LATEX
3595 && LaTeXFeatures::isAvailable("fontspec");
3596 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3597 fontModule->osFontsCB->setChecked(
3598 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3599 updateFontsize(documentClass().opt_fontsize(),
3602 QString font = toqstr(bp_.fontsRoman());
3603 int rpos = fontModule->fontsRomanCO->findData(font);
3605 rpos = fontModule->fontsRomanCO->count();
3606 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3608 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3609 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3611 font = toqstr(bp_.fontsSans());
3612 int spos = fontModule->fontsSansCO->findData(font);
3614 spos = fontModule->fontsSansCO->count();
3615 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3617 fontModule->fontsSansCO->setCurrentIndex(spos);
3618 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3620 font = toqstr(bp_.fontsTypewriter());
3621 int tpos = fontModule->fontsTypewriterCO->findData(font);
3623 tpos = fontModule->fontsTypewriterCO->count();
3624 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3626 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3627 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3629 font = toqstr(bp_.fontsMath());
3630 int mpos = fontModule->fontsMathCO->findData(font);
3632 mpos = fontModule->fontsMathCO->count();
3633 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3635 fontModule->fontsMathCO->setCurrentIndex(mpos);
3636 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3638 if (bp_.useNonTeXFonts && os_fonts_available) {
3639 fontModule->fontencLA->setEnabled(false);
3640 fontModule->fontencCO->setEnabled(false);
3641 fontModule->fontencLE->setEnabled(false);
3643 fontModule->fontencLA->setEnabled(true);
3644 fontModule->fontencCO->setEnabled(true);
3645 fontModule->fontencLE->setEnabled(true);
3651 if (!bp_.fonts_cjk.empty())
3652 fontModule->cjkFontLE->setText(
3653 toqstr(bp_.fonts_cjk));
3655 fontModule->cjkFontLE->setText(QString());
3657 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3658 fontModule->dashesCB->setChecked(bp_.use_dash_ligatures);
3660 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3661 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3662 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3663 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3664 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3665 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3667 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3669 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3671 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3672 fontModule->fontencCO->setCurrentIndex(
3673 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3674 fontModule->fontencLE->setEnabled(false);
3676 fontModule->fontencCO->setCurrentIndex(1);
3677 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3681 // This must be set _after_ fonts since updateDefaultFormat()
3682 // checks osFontsCB settings.
3683 // update combobox with formats
3684 updateDefaultFormat();
3685 int index = outputModule->defaultFormatCO->findData(toqstr(
3686 bp_.default_output_format));
3687 // set to default if format is not found
3690 outputModule->defaultFormatCO->setCurrentIndex(index);
3692 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3693 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3695 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3696 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3697 outputModule->strictCB->setChecked(bp_.html_be_strict);
3698 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3700 outputModule->saveTransientPropertiesCB
3701 ->setChecked(bp_.save_transient_properties);
3704 bool const extern_geometry =
3705 documentClass().provides("geometry");
3706 int const psize = bp_.papersize;
3707 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3708 setCustomPapersize(!extern_geometry && psize == 1);
3709 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3711 bool const landscape =
3712 bp_.orientation == ORIENTATION_LANDSCAPE;
3713 pageLayoutModule->landscapeRB->setChecked(landscape);
3714 pageLayoutModule->portraitRB->setChecked(!landscape);
3715 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3716 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3718 pageLayoutModule->facingPagesCB->setChecked(
3719 bp_.sides == TwoSides);
3721 lengthToWidgets(pageLayoutModule->paperwidthLE,
3722 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3723 lengthToWidgets(pageLayoutModule->paperheightLE,
3724 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3727 Ui::MarginsUi * m = marginsModule;
3731 lengthToWidgets(m->topLE, m->topUnit,
3732 bp_.topmargin, default_unit);
3734 lengthToWidgets(m->bottomLE, m->bottomUnit,
3735 bp_.bottommargin, default_unit);
3737 lengthToWidgets(m->innerLE, m->innerUnit,
3738 bp_.leftmargin, default_unit);
3740 lengthToWidgets(m->outerLE, m->outerUnit,
3741 bp_.rightmargin, default_unit);
3743 lengthToWidgets(m->headheightLE, m->headheightUnit,
3744 bp_.headheight, default_unit);
3746 lengthToWidgets(m->headsepLE, m->headsepUnit,
3747 bp_.headsep, default_unit);
3749 lengthToWidgets(m->footskipLE, m->footskipUnit,
3750 bp_.footskip, default_unit);
3752 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3753 bp_.columnsep, default_unit);
3756 updateUnknownBranches();
3757 branchesModule->update(bp_);
3760 PDFOptions const & pdf = bp_.pdfoptions();
3761 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3762 if (bp_.documentClass().provides("hyperref"))
3763 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3765 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3766 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3767 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3768 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3769 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3771 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3772 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3773 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3775 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3777 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3778 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3779 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3780 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3782 nn = findToken(backref_opts, pdf.backref);
3784 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3786 pdfSupportModule->fullscreenCB->setChecked
3787 (pdf.pagemode == pdf.pagemode_fullscreen);
3789 pdfSupportModule->optionsLE->setText(
3790 toqstr(pdf.quoted_options));
3792 // Make sure that the bc is in the INITIAL state
3793 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3796 // clear changed branches cache
3797 changedBranches_.clear();
3800 nonModuleChanged_ = false;
3804 void GuiDocument::saveDocDefault()
3806 // we have to apply the params first
3812 void GuiDocument::updateAvailableModules()
3814 modules_av_model_.clear();
3815 list<modInfoStruct> modInfoList = getModuleInfo();
3816 // Sort names according to the locale
3817 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3818 return 0 < b.name.localeAwareCompare(a.name);
3821 for (modInfoStruct const & m : modInfoList) {
3822 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3828 void GuiDocument::updateSelectedModules()
3830 modules_sel_model_.clear();
3831 list<modInfoStruct> const selModList = getSelectedModules();
3833 for (modInfoStruct const & m : selModList) {
3834 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3840 void GuiDocument::updateIncludeonlys()
3842 masterChildModule->childrenTW->clear();
3843 QString const no = qt_("No");
3844 QString const yes = qt_("Yes");
3846 if (includeonlys_.empty()) {
3847 masterChildModule->includeallRB->setChecked(true);
3848 masterChildModule->childrenTW->setEnabled(false);
3849 masterChildModule->maintainAuxCB->setEnabled(false);
3851 masterChildModule->includeonlyRB->setChecked(true);
3852 masterChildModule->childrenTW->setEnabled(true);
3853 masterChildModule->maintainAuxCB->setEnabled(true);
3855 ListOfBuffers children = buffer().getChildren();
3856 ListOfBuffers::const_iterator it = children.begin();
3857 ListOfBuffers::const_iterator end = children.end();
3858 bool has_unincluded = false;
3859 bool all_unincluded = true;
3860 for (; it != end; ++it) {
3861 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3864 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3865 from_utf8(buffer().filePath())));
3866 item->setText(0, toqstr(name));
3867 item->setText(1, isChildIncluded(name) ? yes : no);
3868 if (!isChildIncluded(name))
3869 has_unincluded = true;
3871 all_unincluded = false;
3873 // Both if all childs are included and if none is included
3874 // is equal to "include all" (i.e., ommit \includeonly).
3875 // Thus, reset the GUI.
3876 if (!has_unincluded || all_unincluded) {
3877 masterChildModule->includeallRB->setChecked(true);
3878 masterChildModule->childrenTW->setEnabled(false);
3879 includeonlys_.clear();
3881 // If all are included, we need to update again.
3882 if (!has_unincluded)
3883 updateIncludeonlys();
3887 bool GuiDocument::isBiblatex() const
3889 QString const engine =
3890 biblioModule->citeEngineCO->itemData(
3891 biblioModule->citeEngineCO->currentIndex()).toString();
3893 return theCiteEnginesList[fromqstr(engine)]->getCiteFramework() == "biblatex";
3897 void GuiDocument::updateDefaultBiblio(string const & style,
3898 string const & which)
3900 QString const bibstyle = toqstr(style);
3901 biblioModule->defaultBiblioCO->clear();
3906 if (which != "cbx") {
3907 // First the bbx styles
3908 biblioModule->biblatexBbxCO->clear();
3909 QStringList str = texFileList("bbxFiles.lst");
3910 // test whether we have a valid list, otherwise run rescan
3911 if (str.isEmpty()) {
3912 rescanTexStyles("bbx");
3913 str = texFileList("bbxFiles.lst");
3915 for (int i = 0; i != str.size(); ++i)
3916 str[i] = onlyFileName(str[i]);
3917 // sort on filename only (no path)
3920 for (int i = 0; i != str.count(); ++i) {
3921 QString item = changeExtension(str[i], "");
3922 if (item == bibstyle)
3924 biblioModule->biblatexBbxCO->addItem(item);
3927 if (item_nr == -1 && !bibstyle.isEmpty()) {
3928 biblioModule->biblatexBbxCO->addItem(bibstyle);
3929 item_nr = biblioModule->biblatexBbxCO->count() - 1;
3933 biblioModule->biblatexBbxCO->setCurrentIndex(item_nr);
3935 biblioModule->biblatexBbxCO->clearEditText();
3938 if (which != "bbx") {
3939 // now the cbx styles
3940 biblioModule->biblatexCbxCO->clear();
3941 QStringList str = texFileList("cbxFiles.lst");
3942 // test whether we have a valid list, otherwise run rescan
3943 if (str.isEmpty()) {
3944 rescanTexStyles("cbx");
3945 str = texFileList("cbxFiles.lst");
3947 for (int i = 0; i != str.size(); ++i)
3948 str[i] = onlyFileName(str[i]);
3949 // sort on filename only (no path)
3952 for (int i = 0; i != str.count(); ++i) {
3953 QString item = changeExtension(str[i], "");
3954 if (item == bibstyle)
3956 biblioModule->biblatexCbxCO->addItem(item);
3959 if (item_nr == -1 && !bibstyle.isEmpty()) {
3960 biblioModule->biblatexCbxCO->addItem(bibstyle);
3961 item_nr = biblioModule->biblatexCbxCO->count() - 1;
3965 biblioModule->biblatexCbxCO->setCurrentIndex(item_nr);
3967 biblioModule->biblatexCbxCO->clearEditText();
3970 biblioModule->biblatexBbxCO->clear();
3971 biblioModule->biblatexCbxCO->clear();
3972 QStringList str = texFileList("bstFiles.lst");
3973 // test whether we have a valid list, otherwise run rescan
3974 if (str.isEmpty()) {
3975 rescanTexStyles("bst");
3976 str = texFileList("bstFiles.lst");
3978 for (int i = 0; i != str.size(); ++i)
3979 str[i] = onlyFileName(str[i]);
3980 // sort on filename only (no path)
3983 for (int i = 0; i != str.count(); ++i) {
3984 QString item = changeExtension(str[i], "");
3985 if (item == bibstyle)
3987 biblioModule->defaultBiblioCO->addItem(item);
3990 if (item_nr == -1 && !bibstyle.isEmpty()) {
3991 biblioModule->defaultBiblioCO->addItem(bibstyle);
3992 item_nr = biblioModule->defaultBiblioCO->count() - 1;
3996 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
3998 biblioModule->defaultBiblioCO->clearEditText();
4001 updateResetDefaultBiblio();
4005 void GuiDocument::updateResetDefaultBiblio()
4007 QString const engine =
4008 biblioModule->citeEngineCO->itemData(
4009 biblioModule->citeEngineCO->currentIndex()).toString();
4010 CiteEngineType const cet =
4011 CiteEngineType(biblioModule->citeStyleCO->itemData(
4012 biblioModule->citeStyleCO->currentIndex()).toInt());
4014 string const defbib = theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet);
4016 QString const bbx = biblioModule->biblatexBbxCO->currentText();
4017 QString const cbx = biblioModule->biblatexCbxCO->currentText();
4018 biblioModule->resetCbxPB->setEnabled(defbib != fromqstr(cbx));
4019 biblioModule->resetBbxPB->setEnabled(defbib != fromqstr(bbx));
4020 biblioModule->matchBbxPB->setEnabled(bbx != cbx && !cbx.isEmpty()
4021 && biblioModule->biblatexBbxCO->findText(cbx) != -1);
4023 biblioModule->resetDefaultBiblioPB->setEnabled(
4024 defbib != fromqstr(biblioModule->defaultBiblioCO->currentText()));
4028 void GuiDocument::matchBiblatexStyles()
4030 updateDefaultBiblio(fromqstr(biblioModule->biblatexCbxCO->currentText()), "bbx");
4035 void GuiDocument::updateContents()
4037 // Nothing to do here as the document settings is not cursor dependant.
4042 void GuiDocument::useClassDefaults()
4044 if (applyPB->isEnabled()) {
4045 int const ret = Alert::prompt(_("Unapplied changes"),
4046 _("Some changes in the dialog were not yet applied.\n"
4047 "If you do not apply now, they will be lost after this action."),
4048 1, 1, _("&Apply"), _("&Dismiss"));
4053 int idx = latexModule->classCO->currentIndex();
4054 string const classname = fromqstr(latexModule->classCO->getData(idx));
4055 if (!bp_.setBaseClass(classname)) {
4056 Alert::error(_("Error"), _("Unable to set document class."));
4059 bp_.useClassDefaults();
4064 void GuiDocument::setLayoutComboByIDString(string const & idString)
4066 if (!latexModule->classCO->set(toqstr(idString)))
4067 Alert::warning(_("Can't set layout!"),
4068 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
4072 bool GuiDocument::isValid()
4075 validateListingsParameters().isEmpty() &&
4076 localLayout->isValid() &&
4078 // if we're asking for skips between paragraphs
4079 !textLayoutModule->skipRB->isChecked() ||
4080 // then either we haven't chosen custom
4081 textLayoutModule->skipCO->currentIndex() != 3 ||
4082 // or else a length has been given
4083 !textLayoutModule->skipLE->text().isEmpty()
4086 // if we're asking for indentation
4087 !textLayoutModule->indentRB->isChecked() ||
4088 // then either we haven't chosen custom
4089 textLayoutModule->indentCO->currentIndex() != 1 ||
4090 // or else a length has been given
4091 !textLayoutModule->indentLE->text().isEmpty()
4094 // if we're asking for indentation
4095 !mathsModule->MathIndentCB->isChecked() ||
4096 // then either we haven't chosen custom
4097 mathsModule->MathIndentCO->currentIndex() != 1 ||
4098 // or else a length has been given
4099 !mathsModule->MathIndentLE->text().isEmpty()
4104 char const * const GuiDocument::fontfamilies[5] = {
4105 "default", "rmdefault", "sfdefault", "ttdefault", ""
4109 char const * GuiDocument::fontfamilies_gui[5] = {
4110 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
4114 bool GuiDocument::initialiseParams(string const &)
4116 BufferView const * view = bufferview();
4118 bp_ = BufferParams();
4122 bp_ = view->buffer().params();
4124 updateAvailableModules();
4125 //FIXME It'd be nice to make sure here that the selected
4126 //modules are consistent: That required modules are actually
4127 //selected, and that we don't have conflicts. If so, we could
4128 //at least pop up a warning.
4134 void GuiDocument::clearParams()
4136 bp_ = BufferParams();
4140 BufferId GuiDocument::id() const
4142 BufferView const * const view = bufferview();
4143 return view? &view->buffer() : 0;
4147 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
4149 return moduleNames_;
4153 list<GuiDocument::modInfoStruct> const
4154 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
4156 list<modInfoStruct> mInfo;
4157 for (string const & name : mods) {
4159 LyXModule const * const mod = theModuleList[name];
4164 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
4172 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
4174 return makeModuleInfo(params().getModules());
4178 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
4180 return makeModuleInfo(params().baseClass()->providedModules());
4184 DocumentClass const & GuiDocument::documentClass() const
4186 return bp_.documentClass();
4190 static void dispatch_bufferparams(Dialog const & dialog,
4191 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
4194 ss << "\\begin_header\n";
4195 bp.writeFile(ss, buf);
4196 ss << "\\end_header\n";
4197 dialog.dispatch(FuncRequest(lfun, ss.str()));
4201 void GuiDocument::dispatchParams()
4203 // We need a non-const buffer object.
4204 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
4205 // There may be several undo records; group them (bug #8998)
4206 buf.undo().beginUndoGroup();
4208 // This must come first so that a language change is correctly noticed
4211 // Apply the BufferParams. Note that this will set the base class
4212 // and then update the buffer's layout.
4213 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
4215 if (!params().master.empty()) {
4216 FileName const master_file = support::makeAbsPath(params().master,
4217 support::onlyPath(buffer().absFileName()));
4218 if (isLyXFileName(master_file.absFileName())) {
4219 Buffer * master = checkAndLoadLyXFile(master_file);
4221 if (master->isChild(const_cast<Buffer *>(&buffer())))
4222 const_cast<Buffer &>(buffer()).setParent(master);
4224 Alert::warning(_("Assigned master does not include this file"),
4225 bformat(_("You must include this file in the document\n"
4226 "'%1$s' in order to use the master document\n"
4227 "feature."), from_utf8(params().master)));
4229 Alert::warning(_("Could not load master"),
4230 bformat(_("The master document '%1$s'\n"
4231 "could not be loaded."),
4232 from_utf8(params().master)));
4236 // Generate the colours requested by each new branch.
4237 BranchList & branchlist = params().branchlist();
4238 if (!branchlist.empty()) {
4239 BranchList::const_iterator it = branchlist.begin();
4240 BranchList::const_iterator const end = branchlist.end();
4241 for (; it != end; ++it) {
4242 docstring const & current_branch = it->branch();
4243 Branch const * branch = branchlist.find(current_branch);
4244 string const x11hexname = X11hexname(branch->color());
4245 // display the new color
4246 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
4247 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4250 // rename branches in the document
4251 executeBranchRenaming();
4252 // and clear changed branches cache
4253 changedBranches_.clear();
4255 // Generate the colours requested by indices.
4256 IndicesList & indiceslist = params().indiceslist();
4257 if (!indiceslist.empty()) {
4258 IndicesList::const_iterator it = indiceslist.begin();
4259 IndicesList::const_iterator const end = indiceslist.end();
4260 for (; it != end; ++it) {
4261 docstring const & current_index = it->shortcut();
4262 Index const * index = indiceslist.findShortcut(current_index);
4263 string const x11hexname = X11hexname(index->color());
4264 // display the new color
4265 docstring const str = current_index + ' ' + from_ascii(x11hexname);
4266 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4270 // If we used an LFUN, we would not need these two lines:
4271 BufferView * bv = const_cast<BufferView *>(bufferview());
4272 bv->processUpdateFlags(Update::Force | Update::FitCursor);
4274 // Don't forget to close the group. Note that it is important
4275 // to check that there is no early return in the method.
4276 buf.undo().endUndoGroup();
4280 void GuiDocument::setLanguage() const
4282 Language const * const newL = bp_.language;
4283 if (buffer().params().language == newL)
4286 string const & lang_name = newL->lang();
4287 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
4291 void GuiDocument::saveAsDefault() const
4293 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
4297 bool GuiDocument::providesOSF(QString const & font) const
4299 if (fontModule->osFontsCB->isChecked())
4300 // FIXME: we should check if the fonts really
4301 // have OSF support. But how?
4303 return theLaTeXFonts().getLaTeXFont(
4304 qstring_to_ucs4(font)).providesOSF(ot1(),
4310 bool GuiDocument::providesSC(QString const & font) const
4312 if (fontModule->osFontsCB->isChecked())
4314 return theLaTeXFonts().getLaTeXFont(
4315 qstring_to_ucs4(font)).providesSC(ot1(),
4321 bool GuiDocument::providesScale(QString const & font) const
4323 if (fontModule->osFontsCB->isChecked())
4325 return theLaTeXFonts().getLaTeXFont(
4326 qstring_to_ucs4(font)).providesScale(ot1(),
4332 bool GuiDocument::providesNoMath(QString const & font) const
4334 if (fontModule->osFontsCB->isChecked())
4336 return theLaTeXFonts().getLaTeXFont(
4337 qstring_to_ucs4(font)).providesNoMath(ot1(),
4342 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4344 if (fontModule->osFontsCB->isChecked())
4346 return theLaTeXFonts().getLaTeXFont(
4347 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4354 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4356 // FIXME Unicode: docstrings would be better for these parameters but this
4357 // change requires a lot of others
4360 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4361 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4362 // Find the first sentence of the description
4363 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4364 int pos = bf.toNextBoundary();
4367 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4368 // Tooltip is the desc followed by the module name
4369 m.description = QString("%1<i>%2</i>")
4370 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4376 void GuiDocument::loadModuleInfo()
4378 moduleNames_.clear();
4379 for (LyXModule const & mod : theModuleList)
4380 if (mod.category().substr(0, 8) != "Citation")
4381 moduleNames_.push_back(modInfo(mod));
4385 void GuiDocument::updateUnknownBranches()
4389 list<docstring> used_branches;
4390 buffer().getUsedBranches(used_branches);
4391 list<docstring>::const_iterator it = used_branches.begin();
4392 QStringList unknown_branches;
4393 for (; it != used_branches.end() ; ++it) {
4394 if (!buffer().params().branchlist().find(*it))
4395 unknown_branches.append(toqstr(*it));
4397 branchesModule->setUnknownBranches(unknown_branches);
4401 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4403 map<docstring, docstring>::iterator it = changedBranches_.begin();
4404 for (; it != changedBranches_.end() ; ++it) {
4405 if (it->second == oldname) {
4406 // branch has already been renamed
4407 it->second = newname;
4412 changedBranches_[oldname] = newname;
4416 void GuiDocument::executeBranchRenaming() const
4418 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4419 for (; it != changedBranches_.end() ; ++it) {
4420 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4421 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4426 void GuiDocument::allPackagesAuto()
4432 void GuiDocument::allPackagesAlways()
4438 void GuiDocument::allPackagesNot()
4444 void GuiDocument::allPackages(int col)
4446 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4447 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4448 rb->setChecked(true);
4453 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4456 } // namespace frontend
4459 #include "moc_GuiDocument.cpp"