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"
42 #include "IndicesList.h"
44 #include "LaTeXFeatures.h"
45 #include "LaTeXFonts.h"
47 #include "LayoutEnums.h"
48 #include "LayoutModuleList.h"
50 #include "ModuleList.h"
51 #include "OutputParams.h"
52 #include "PDFOptions.h"
53 #include "qt_helpers.h"
55 #include "TextClass.h"
59 #include "insets/InsetListingsParams.h"
61 #include "support/debug.h"
62 #include "support/FileName.h"
63 #include "support/filetools.h"
64 #include "support/gettext.h"
65 #include "support/lassert.h"
66 #include "support/lstrings.h"
68 #include "frontends/alert.h"
70 #include <QAbstractItemModel>
71 #include <QHeaderView>
73 #include <QColorDialog>
74 #include <QCloseEvent>
75 #include <QFontDatabase>
77 #include <QTextBoundaryFinder>
78 #include <QTextCursor>
88 // a style sheet for buttons
89 // this is for example used for the background color setting button
90 static inline QString colorButtonStyleSheet(QColor const & bgColor)
92 if (bgColor.isValid()) {
93 QString rc = QLatin1String("background-color:");
102 using namespace lyx::support;
107 char const * const tex_graphics[] =
109 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
110 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
111 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
112 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
117 char const * const tex_graphics_gui[] =
119 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
120 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
121 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
122 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
123 "XeTeX", N_("None"), ""
127 char const * backref_opts[] =
129 "false", "section", "slide", "page", ""
133 char const * backref_opts_gui[] =
135 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
139 vector<string> engine_types_;
140 vector<pair<string, QString> > pagestyles;
142 QMap<QString, QString> rmfonts_;
143 QMap<QString, QString> sffonts_;
144 QMap<QString, QString> ttfonts_;
145 QMap<QString, QString> mathfonts_;
148 } // anonymous namespace
152 RGBColor set_backgroundcolor;
153 bool is_backgroundcolor;
154 RGBColor set_fontcolor;
156 RGBColor set_notefontcolor;
157 RGBColor set_boxbgcolor;
158 bool forced_fontspec_activation;
161 // used when sorting the textclass list.
162 class less_textclass_avail_desc
163 : public binary_function<string, string, int>
166 bool operator()(string const & lhs, string const & rhs) const
168 // Ordering criteria:
169 // 1. Availability of text class
170 // 2. Description (lexicographic)
171 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
172 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
173 int const order = compare_no_case(
174 translateIfPossible(from_utf8(tc1.description())),
175 translateIfPossible(from_utf8(tc2.description())));
176 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
177 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
186 vector<string> getRequiredList(string const & modName)
188 LyXModule const * const mod = theModuleList[modName];
190 return vector<string>(); //empty such thing
191 return mod->getRequiredModules();
195 vector<string> getExcludedList(string const & modName)
197 LyXModule const * const mod = theModuleList[modName];
199 return vector<string>(); //empty such thing
200 return mod->getExcludedModules();
204 docstring getModuleCategory(string const & modName)
206 LyXModule const * const mod = theModuleList[modName];
209 return from_utf8(mod->category());
213 docstring getModuleDescription(string const & modName)
215 LyXModule const * const mod = theModuleList[modName];
217 return _("Module not found!");
219 return translateIfPossible(from_utf8(mod->getDescription()));
223 vector<string> getPackageList(string const & modName)
225 LyXModule const * const mod = theModuleList[modName];
227 return vector<string>(); //empty such thing
228 return mod->getPackageList();
232 bool isModuleAvailable(string const & modName)
234 LyXModule const * const mod = theModuleList[modName];
237 return mod->isAvailable();
240 } // anonymous namespace
243 /////////////////////////////////////////////////////////////////////
245 // ModuleSelectionManager
247 /////////////////////////////////////////////////////////////////////
249 /// SelectionManager for use with modules
250 class ModuleSelectionManager : public GuiSelectionManager
254 ModuleSelectionManager(
255 QTreeView * availableLV,
256 QListView * selectedLV,
260 QPushButton * downPB,
261 GuiIdListModel * availableModel,
262 GuiIdListModel * selectedModel,
263 GuiDocument const * container)
264 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
265 upPB, downPB, availableModel, selectedModel), 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() : current_id_(0)
456 // This is not a memory leak. The object will be destroyed
458 // @ is letter in the LyX user preamble
459 (void) new LaTeXHighlighter(preambleTE->document(), true);
460 preambleTE->setFont(guiApp->typewriterSystemFont());
461 preambleTE->setWordWrapMode(QTextOption::NoWrap);
462 setFocusProxy(preambleTE);
463 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
467 void PreambleModule::update(BufferParams const & params, BufferId id)
469 QString preamble = toqstr(params.preamble);
470 // Nothing to do if the params and preamble are unchanged.
471 if (id == current_id_
472 && preamble == preambleTE->document()->toPlainText())
475 QTextCursor cur = preambleTE->textCursor();
476 // Save the coords before switching to the new one.
477 preamble_coords_[current_id_] =
478 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
480 // Save the params address for further use.
482 preambleTE->document()->setPlainText(preamble);
483 Coords::const_iterator it = preamble_coords_.find(current_id_);
484 if (it == preamble_coords_.end())
485 // First time we open this one.
486 preamble_coords_[current_id_] = make_pair(0, 0);
488 // Restore saved coords.
489 QTextCursor cur = preambleTE->textCursor();
490 cur.setPosition(it->second.first);
491 preambleTE->setTextCursor(cur);
492 preambleTE->verticalScrollBar()->setValue(it->second.second);
497 void PreambleModule::apply(BufferParams & params)
499 params.preamble = qstring_to_ucs4(preambleTE->document()->toPlainText());
503 void PreambleModule::closeEvent(QCloseEvent * e)
505 // Save the coords before closing.
506 QTextCursor cur = preambleTE->textCursor();
507 preamble_coords_[current_id_] =
508 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
513 /////////////////////////////////////////////////////////////////////
517 /////////////////////////////////////////////////////////////////////
520 LocalLayout::LocalLayout() : current_id_(0), validated_(false)
522 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
523 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
524 connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
528 void LocalLayout::update(BufferParams const & params, BufferId id)
530 QString layout = toqstr(params.getLocalLayout(false));
531 // Nothing to do if the params and preamble are unchanged.
532 if (id == current_id_
533 && layout == locallayoutTE->document()->toPlainText())
536 // Save the params address for further use.
538 locallayoutTE->document()->setPlainText(layout);
543 void LocalLayout::apply(BufferParams & params)
545 docstring const layout =
546 qstring_to_ucs4(locallayoutTE->document()->toPlainText());
547 params.setLocalLayout(layout, false);
551 void LocalLayout::hideConvert()
553 convertPB->setEnabled(false);
554 convertLB->setText("");
560 void LocalLayout::textChanged()
562 static const QString message =
563 qt_("Press button to check validity...");
564 string const layout =
565 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
567 if (layout.empty()) {
569 validatePB->setEnabled(false);
570 validLB->setText("");
573 } else if (!validatePB->isEnabled()) {
574 // if that's already enabled, we shouldn't need to do anything.
576 validLB->setText(message);
577 validatePB->setEnabled(true);
584 void LocalLayout::convert() {
585 string const layout =
586 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
587 string const newlayout = TextClass::convert(layout);
588 if (!newlayout.empty())
589 locallayoutTE->setPlainText(toqstr(newlayout));
594 void LocalLayout::convertPressed() {
601 void LocalLayout::validate() {
603 static const QString vpar("<p style=\"font-weight: bold;\">%1</p>");
604 // Flashy red bold text
605 static const QString ivpar("<p style=\"color: #c00000; font-weight: bold; \">"
607 string const layout =
608 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
609 if (!layout.empty()) {
610 TextClass::ReturnValues const ret = TextClass::validate(layout);
611 validated_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
612 validatePB->setEnabled(false);
613 validLB->setText(validated_ ? vpar.arg(qt_("Layout is valid!"))
614 : ivpar.arg(qt_("Layout is invalid!")));
615 if (ret == TextClass::OK_OLDFORMAT) {
617 // Testing conversion to LYXFILE_LAYOUT_FORMAT at this point
619 if (TextClass::convert(layout).empty()) {
620 // Conversion failed. If LAYOUT_FORMAT > LYXFILE_LAYOUT_FORMAT,
621 // then maybe the layout is still valid, but its format is more
622 // recent than LYXFILE_LAYOUT_FORMAT. However, if LAYOUT_FORMAT
623 // == LYXFILE_LAYOUT_FORMAT then something is definitely wrong.
624 convertPB->setEnabled(false);
625 const QString text = (LAYOUT_FORMAT == LYXFILE_LAYOUT_FORMAT)
626 ? ivpar.arg(qt_("Conversion to current format impossible!"))
627 : vpar.arg(qt_("Conversion to current stable format "
629 convertLB->setText(text);
631 convertPB->setEnabled(true);
632 convertLB->setText(qt_("Convert to current format"));
643 void LocalLayout::validatePressed() {
649 /////////////////////////////////////////////////////////////////////
653 /////////////////////////////////////////////////////////////////////
656 GuiDocument::GuiDocument(GuiView & lv)
657 : GuiDialog(lv, "document", qt_("Document Settings")),
658 biblioChanged_(false), nonModuleChanged_(false)
662 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
663 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
664 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
665 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
667 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
668 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
670 // Manage the restore, ok, apply, restore and cancel/close buttons
671 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
673 bc().setApply(applyPB);
674 bc().setCancel(closePB);
675 bc().setRestore(restorePB);
679 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
680 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
681 this, SLOT(change_adaptor()));
682 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
683 this, SLOT(setLSpacing(int)));
684 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
685 this, SLOT(change_adaptor()));
687 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
688 this, SLOT(change_adaptor()));
689 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
690 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
691 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
692 this, SLOT(change_adaptor()));
693 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
694 this, SLOT(setIndent(int)));
695 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
696 this, SLOT(change_adaptor()));
697 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
698 this, SLOT(change_adaptor()));
700 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
701 this, SLOT(change_adaptor()));
702 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
703 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
704 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
705 this, SLOT(change_adaptor()));
706 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
707 this, SLOT(setSkip(int)));
708 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
709 this, SLOT(change_adaptor()));
710 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
711 this, SLOT(change_adaptor()));
713 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
714 this, SLOT(enableIndent(bool)));
715 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
716 this, SLOT(enableSkip(bool)));
718 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
719 this, SLOT(change_adaptor()));
720 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
721 this, SLOT(setColSep()));
722 connect(textLayoutModule->justCB, SIGNAL(clicked()),
723 this, SLOT(change_adaptor()));
725 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
726 textLayoutModule->lspacingLE));
727 textLayoutModule->indentLE->setValidator(new LengthValidator(
728 textLayoutModule->indentLE));
729 textLayoutModule->skipLE->setValidator(new LengthValidator(
730 textLayoutModule->skipLE));
732 textLayoutModule->indentCO->addItem(qt_("Default"));
733 textLayoutModule->indentCO->addItem(qt_("Custom"));
734 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
735 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
736 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
737 textLayoutModule->skipCO->addItem(qt_("Custom"));
738 textLayoutModule->lspacingCO->insertItem(
739 Spacing::Single, qt_("Single"));
740 textLayoutModule->lspacingCO->insertItem(
741 Spacing::Onehalf, qt_("OneHalf"));
742 textLayoutModule->lspacingCO->insertItem(
743 Spacing::Double, qt_("Double"));
744 textLayoutModule->lspacingCO->insertItem(
745 Spacing::Other, qt_("Custom"));
746 // initialize the length validator
747 bc().addCheckedLineEdit(textLayoutModule->indentLE);
748 bc().addCheckedLineEdit(textLayoutModule->skipLE);
751 // master/child handling
752 masterChildModule = new UiWidget<Ui::MasterChildUi>;
754 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
755 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
756 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
757 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
758 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
759 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
760 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
761 this, SLOT(change_adaptor()));
762 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
763 this, SLOT(change_adaptor()));
764 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
765 this, SLOT(change_adaptor()));
766 masterChildModule->childrenTW->setColumnCount(2);
767 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
768 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
769 masterChildModule->childrenTW->resizeColumnToContents(1);
770 masterChildModule->childrenTW->resizeColumnToContents(2);
774 outputModule = new UiWidget<Ui::OutputUi>;
776 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
777 this, SLOT(change_adaptor()));
778 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
779 this, SLOT(change_adaptor()));
780 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
781 this, SLOT(change_adaptor()));
782 connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
783 this, SLOT(change_adaptor()));
784 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
785 this, SLOT(change_adaptor()));
787 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
788 this, SLOT(change_adaptor()));
789 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
790 this, SLOT(change_adaptor()));
791 outputModule->synccustomCB->addItem("");
792 outputModule->synccustomCB->addItem("\\synctex=1");
793 outputModule->synccustomCB->addItem("\\synctex=-1");
794 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
796 outputModule->synccustomCB->setValidator(new NoNewLineValidator(
797 outputModule->synccustomCB));
799 connect(outputModule->saveTransientPropertiesCB, SIGNAL(clicked()),
800 this, SLOT(change_adaptor()));
803 fontModule = new FontModule;
804 connect(fontModule->osFontsCB, SIGNAL(clicked()),
805 this, SLOT(change_adaptor()));
806 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
807 this, SLOT(osFontsChanged(bool)));
808 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
809 this, SLOT(change_adaptor()));
810 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
811 this, SLOT(romanChanged(int)));
812 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
813 this, SLOT(change_adaptor()));
814 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
815 this, SLOT(sansChanged(int)));
816 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
817 this, SLOT(change_adaptor()));
818 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
819 this, SLOT(ttChanged(int)));
820 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
821 this, SLOT(change_adaptor()));
822 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
823 this, SLOT(mathFontChanged(int)));
824 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
825 this, SLOT(change_adaptor()));
826 connect(fontModule->fontencCO, SIGNAL(activated(int)),
827 this, SLOT(change_adaptor()));
828 connect(fontModule->fontencCO, SIGNAL(activated(int)),
829 this, SLOT(fontencChanged(int)));
830 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
831 this, SLOT(change_adaptor()));
832 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
833 this, SLOT(change_adaptor()));
834 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
835 this, SLOT(change_adaptor()));
836 connect(fontModule->microtypeCB, SIGNAL(clicked()),
837 this, SLOT(change_adaptor()));
838 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
839 this, SLOT(change_adaptor()));
840 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
841 this, SLOT(change_adaptor()));
842 connect(fontModule->fontScCB, SIGNAL(clicked()),
843 this, SLOT(change_adaptor()));
844 connect(fontModule->fontScCB, SIGNAL(toggled(bool)),
845 this, SLOT(fontScToggled(bool)));
846 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
847 this, SLOT(change_adaptor()));
848 connect(fontModule->fontOsfCB, SIGNAL(toggled(bool)),
849 this, SLOT(fontOsfToggled(bool)));
851 fontModule->fontencLE->setValidator(new NoNewLineValidator(
852 fontModule->fontencLE));
853 fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
854 fontModule->cjkFontLE));
858 fontModule->fontsizeCO->addItem(qt_("Default"));
859 fontModule->fontsizeCO->addItem(qt_("10"));
860 fontModule->fontsizeCO->addItem(qt_("11"));
861 fontModule->fontsizeCO->addItem(qt_("12"));
863 fontModule->fontencCO->addItem(qt_("Default"), QString("global"));
864 fontModule->fontencCO->addItem(qt_("Custom"), QString("custom"));
865 fontModule->fontencCO->addItem(qt_("None (no fontenc)"), QString("default"));
867 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
868 fontModule->fontsDefaultCO->addItem(
869 qt_(GuiDocument::fontfamilies_gui[n]));
871 if (!LaTeXFeatures::isAvailable("fontspec"))
872 fontModule->osFontsCB->setToolTip(
873 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
874 "You need to install the package \"fontspec\" to use this feature"));
878 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
879 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
880 this, SLOT(papersizeChanged(int)));
881 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
882 this, SLOT(papersizeChanged(int)));
883 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
884 this, SLOT(change_adaptor()));
885 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
886 this, SLOT(change_adaptor()));
887 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
888 this, SLOT(change_adaptor()));
889 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
890 this, SLOT(change_adaptor()));
891 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
892 this, SLOT(change_adaptor()));
893 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
894 this, SLOT(change_adaptor()));
895 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
896 this, SLOT(change_adaptor()));
897 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
898 this, SLOT(change_adaptor()));
899 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
900 this, SLOT(change_adaptor()));
901 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
902 this, SLOT(change_adaptor()));
904 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
905 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
906 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
907 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
908 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
909 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
910 pageLayoutModule->paperheightL);
911 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
912 pageLayoutModule->paperwidthL);
914 QComboBox * cb = pageLayoutModule->papersizeCO;
915 cb->addItem(qt_("Default"));
916 cb->addItem(qt_("Custom"));
917 cb->addItem(qt_("US letter"));
918 cb->addItem(qt_("US legal"));
919 cb->addItem(qt_("US executive"));
920 cb->addItem(qt_("A0"));
921 cb->addItem(qt_("A1"));
922 cb->addItem(qt_("A2"));
923 cb->addItem(qt_("A3"));
924 cb->addItem(qt_("A4"));
925 cb->addItem(qt_("A5"));
926 cb->addItem(qt_("A6"));
927 cb->addItem(qt_("B0"));
928 cb->addItem(qt_("B1"));
929 cb->addItem(qt_("B2"));
930 cb->addItem(qt_("B3"));
931 cb->addItem(qt_("B4"));
932 cb->addItem(qt_("B5"));
933 cb->addItem(qt_("B6"));
934 cb->addItem(qt_("C0"));
935 cb->addItem(qt_("C1"));
936 cb->addItem(qt_("C2"));
937 cb->addItem(qt_("C3"));
938 cb->addItem(qt_("C4"));
939 cb->addItem(qt_("C5"));
940 cb->addItem(qt_("C6"));
941 cb->addItem(qt_("JIS B0"));
942 cb->addItem(qt_("JIS B1"));
943 cb->addItem(qt_("JIS B2"));
944 cb->addItem(qt_("JIS B3"));
945 cb->addItem(qt_("JIS B4"));
946 cb->addItem(qt_("JIS B5"));
947 cb->addItem(qt_("JIS B6"));
948 // remove the %-items from the unit choice
949 pageLayoutModule->paperwidthUnitCO->noPercents();
950 pageLayoutModule->paperheightUnitCO->noPercents();
951 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
952 pageLayoutModule->paperheightLE));
953 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
954 pageLayoutModule->paperwidthLE));
958 marginsModule = new UiWidget<Ui::MarginsUi>;
959 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
960 this, SLOT(setCustomMargins(bool)));
961 connect(marginsModule->marginCB, SIGNAL(clicked()),
962 this, SLOT(change_adaptor()));
963 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
964 this, SLOT(change_adaptor()));
965 connect(marginsModule->topUnit, SIGNAL(activated(int)),
966 this, SLOT(change_adaptor()));
967 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
968 this, SLOT(change_adaptor()));
969 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
970 this, SLOT(change_adaptor()));
971 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
972 this, SLOT(change_adaptor()));
973 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
974 this, SLOT(change_adaptor()));
975 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
976 this, SLOT(change_adaptor()));
977 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
978 this, SLOT(change_adaptor()));
979 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
980 this, SLOT(change_adaptor()));
981 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
982 this, SLOT(change_adaptor()));
983 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
984 this, SLOT(change_adaptor()));
985 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
986 this, SLOT(change_adaptor()));
987 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
988 this, SLOT(change_adaptor()));
989 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
990 this, SLOT(change_adaptor()));
991 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
992 this, SLOT(change_adaptor()));
993 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
994 this, SLOT(change_adaptor()));
995 marginsModule->topLE->setValidator(new LengthValidator(
996 marginsModule->topLE));
997 marginsModule->bottomLE->setValidator(new LengthValidator(
998 marginsModule->bottomLE));
999 marginsModule->innerLE->setValidator(new LengthValidator(
1000 marginsModule->innerLE));
1001 marginsModule->outerLE->setValidator(new LengthValidator(
1002 marginsModule->outerLE));
1003 marginsModule->headsepLE->setValidator(new LengthValidator(
1004 marginsModule->headsepLE));
1005 marginsModule->headheightLE->setValidator(new LengthValidator(
1006 marginsModule->headheightLE));
1007 marginsModule->footskipLE->setValidator(new LengthValidator(
1008 marginsModule->footskipLE));
1009 marginsModule->columnsepLE->setValidator(new LengthValidator(
1010 marginsModule->columnsepLE));
1012 bc().addCheckedLineEdit(marginsModule->topLE,
1013 marginsModule->topL);
1014 bc().addCheckedLineEdit(marginsModule->bottomLE,
1015 marginsModule->bottomL);
1016 bc().addCheckedLineEdit(marginsModule->innerLE,
1017 marginsModule->innerL);
1018 bc().addCheckedLineEdit(marginsModule->outerLE,
1019 marginsModule->outerL);
1020 bc().addCheckedLineEdit(marginsModule->headsepLE,
1021 marginsModule->headsepL);
1022 bc().addCheckedLineEdit(marginsModule->headheightLE,
1023 marginsModule->headheightL);
1024 bc().addCheckedLineEdit(marginsModule->footskipLE,
1025 marginsModule->footskipL);
1026 bc().addCheckedLineEdit(marginsModule->columnsepLE,
1027 marginsModule->columnsepL);
1031 langModule = new UiWidget<Ui::LanguageUi>;
1032 connect(langModule->languageCO, SIGNAL(activated(int)),
1033 this, SLOT(change_adaptor()));
1034 connect(langModule->languageCO, SIGNAL(activated(int)),
1035 this, SLOT(languageChanged(int)));
1036 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1037 this, SLOT(change_adaptor()));
1038 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1039 this, SLOT(change_adaptor()));
1040 connect(langModule->encodingCO, SIGNAL(activated(int)),
1041 this, SLOT(change_adaptor()));
1042 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1043 this, SLOT(change_adaptor()));
1044 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1045 this, SLOT(change_adaptor()));
1046 connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1047 this, SLOT(change_adaptor()));
1048 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1049 this, SLOT(languagePackageChanged(int)));
1050 connect(langModule->dynamicQuotesCB, SIGNAL(clicked()),
1051 this, SLOT(change_adaptor()));
1053 langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1054 langModule->languagePackageLE));
1056 QAbstractItemModel * language_model = guiApp->languageModel();
1057 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1058 language_model->sort(0);
1059 langModule->languageCO->setModel(language_model);
1060 langModule->languageCO->setModelColumn(0);
1062 // Always put the default encoding in the first position.
1063 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1064 QStringList encodinglist;
1065 Encodings::const_iterator it = encodings.begin();
1066 Encodings::const_iterator const end = encodings.end();
1067 for (; it != end; ++it)
1069 encodinglist.append(qt_(it->guiName()));
1070 encodinglist.sort();
1071 langModule->encodingCO->addItems(encodinglist);
1073 langModule->languagePackageCO->addItem(
1074 qt_("Default"), toqstr("default"));
1075 langModule->languagePackageCO->addItem(
1076 qt_("Automatic"), toqstr("auto"));
1077 langModule->languagePackageCO->addItem(
1078 qt_("Always Babel"), toqstr("babel"));
1079 langModule->languagePackageCO->addItem(
1080 qt_("Custom"), toqstr("custom"));
1081 langModule->languagePackageCO->addItem(
1082 qt_("None[[language package]]"), toqstr("none"));
1086 colorModule = new UiWidget<Ui::ColorUi>;
1087 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1088 this, SLOT(changeFontColor()));
1089 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1090 this, SLOT(deleteFontColor()));
1091 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1092 this, SLOT(changeNoteFontColor()));
1093 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1094 this, SLOT(deleteNoteFontColor()));
1095 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1096 this, SLOT(changeBackgroundColor()));
1097 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1098 this, SLOT(deleteBackgroundColor()));
1099 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1100 this, SLOT(changeBoxBackgroundColor()));
1101 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1102 this, SLOT(deleteBoxBackgroundColor()));
1106 numberingModule = new UiWidget<Ui::NumberingUi>;
1107 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1108 this, SLOT(change_adaptor()));
1109 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1110 this, SLOT(change_adaptor()));
1111 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1112 this, SLOT(updateNumbering()));
1113 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1114 this, SLOT(updateNumbering()));
1115 numberingModule->tocTW->setColumnCount(3);
1116 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1117 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1118 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1119 setSectionResizeMode(numberingModule->tocTW->header(), QHeaderView::ResizeToContents);
1122 biblioModule = new UiWidget<Ui::BiblioUi>;
1123 connect(biblioModule->citeEngineCO, SIGNAL(activated(int)),
1124 this, SLOT(citeEngineChanged(int)));
1125 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1126 this, SLOT(citeStyleChanged()));
1127 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1128 this, SLOT(biblioChanged()));
1129 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1130 this, SLOT(bibtexChanged(int)));
1131 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1132 this, SLOT(biblioChanged()));
1133 connect(biblioModule->citePackageOptionsLE, SIGNAL(textChanged(QString)),
1134 this, SLOT(biblioChanged()));
1135 connect(biblioModule->defaultBiblioCO, SIGNAL(activated(int)),
1136 this, SLOT(biblioChanged()));
1137 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1138 this, SLOT(biblioChanged()));
1139 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1140 this, SLOT(updateResetDefaultBiblio()));
1141 connect(biblioModule->biblatexBbxCO, SIGNAL(activated(int)),
1142 this, SLOT(biblioChanged()));
1143 connect(biblioModule->biblatexBbxCO, SIGNAL(editTextChanged(QString)),
1144 this, SLOT(updateResetDefaultBiblio()));
1145 connect(biblioModule->biblatexCbxCO, SIGNAL(activated(int)),
1146 this, SLOT(biblioChanged()));
1147 connect(biblioModule->biblatexCbxCO, SIGNAL(editTextChanged(QString)),
1148 this, SLOT(updateResetDefaultBiblio()));
1149 connect(biblioModule->rescanBibliosPB, SIGNAL(clicked()),
1150 this, SLOT(rescanBibFiles()));
1151 connect(biblioModule->resetDefaultBiblioPB, SIGNAL(clicked()),
1152 this, SLOT(resetDefaultBibfile()));
1153 connect(biblioModule->resetCbxPB, SIGNAL(clicked()),
1154 this, SLOT(resetDefaultCbxBibfile()));
1155 connect(biblioModule->resetBbxPB, SIGNAL(clicked()),
1156 this, SLOT(resetDefaultBbxBibfile()));
1157 connect(biblioModule->matchBbxPB, SIGNAL(clicked()),
1158 this, SLOT(matchBiblatexStyles()));
1160 biblioModule->citeEngineCO->clear();
1161 for (LyXCiteEngine const & cet : theCiteEnginesList) {
1162 biblioModule->citeEngineCO->addItem(qt_(cet.getName()), toqstr(cet.getID()));
1163 int const i = biblioModule->citeEngineCO->findData(toqstr(cet.getID()));
1164 biblioModule->citeEngineCO->setItemData(i, qt_(cet.getDescription()),
1168 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1169 biblioModule->bibtexOptionsLE));
1170 biblioModule->defaultBiblioCO->lineEdit()->setValidator(new NoNewLineValidator(
1171 biblioModule->defaultBiblioCO->lineEdit()));
1173 // NOTE: we do not provide "custom" here for security reasons!
1174 biblioModule->bibtexCO->clear();
1175 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1176 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1177 it != lyxrc.bibtex_alternatives.end(); ++it) {
1178 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1179 biblioModule->bibtexCO->addItem(command, command);
1184 indicesModule = new GuiIndices;
1185 connect(indicesModule, SIGNAL(changed()),
1186 this, SLOT(change_adaptor()));
1190 mathsModule = new UiWidget<Ui::MathsUi>;
1191 QStringList headers;
1192 headers << qt_("Package") << qt_("Load automatically")
1193 << qt_("Load always") << qt_("Do not load");
1194 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1195 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1196 map<string, string> const & packages = BufferParams::auto_packages();
1197 mathsModule->packagesTW->setRowCount(packages.size());
1199 for (map<string, string>::const_iterator it = packages.begin();
1200 it != packages.end(); ++it) {
1201 docstring const package = from_ascii(it->first);
1202 QString autoTooltip = qt_(it->second);
1203 QString alwaysTooltip;
1204 if (package == "amsmath")
1206 qt_("The AMS LaTeX packages are always used");
1208 alwaysTooltip = toqstr(bformat(
1209 _("The LaTeX package %1$s is always used"),
1211 QString neverTooltip;
1212 if (package == "amsmath")
1214 qt_("The AMS LaTeX packages are never used");
1216 neverTooltip = toqstr(bformat(
1217 _("The LaTeX package %1$s is never used"),
1219 QRadioButton * autoRB = new QRadioButton(mathsModule);
1220 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1221 QRadioButton * neverRB = new QRadioButton(mathsModule);
1222 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1223 packageGroup->addButton(autoRB);
1224 packageGroup->addButton(alwaysRB);
1225 packageGroup->addButton(neverRB);
1226 autoRB->setToolTip(autoTooltip);
1227 alwaysRB->setToolTip(alwaysTooltip);
1228 neverRB->setToolTip(neverTooltip);
1229 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1230 mathsModule->packagesTW->setItem(i, 0, pack);
1231 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1232 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1233 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1235 connect(autoRB, SIGNAL(clicked()),
1236 this, SLOT(change_adaptor()));
1237 connect(alwaysRB, SIGNAL(clicked()),
1238 this, SLOT(change_adaptor()));
1239 connect(neverRB, SIGNAL(clicked()),
1240 this, SLOT(change_adaptor()));
1243 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1244 this, SLOT(allPackagesAuto()));
1245 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1246 this, SLOT(allPackagesAlways()));
1247 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1248 this, SLOT(allPackagesNot()));
1249 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1250 this, SLOT(change_adaptor()));
1251 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1252 this, SLOT(change_adaptor()));
1253 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1254 this, SLOT(change_adaptor()));
1258 latexModule = new UiWidget<Ui::LaTeXUi>;
1259 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1260 this, SLOT(change_adaptor()));
1261 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1262 this, SLOT(change_adaptor()));
1263 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1264 this, SLOT(change_adaptor()));
1265 connect(latexModule->classCO, SIGNAL(activated(int)),
1266 this, SLOT(classChanged_adaptor()));
1267 connect(latexModule->classCO, SIGNAL(activated(int)),
1268 this, SLOT(change_adaptor()));
1269 connect(latexModule->layoutPB, SIGNAL(clicked()),
1270 this, SLOT(browseLayout()));
1271 connect(latexModule->layoutPB, SIGNAL(clicked()),
1272 this, SLOT(change_adaptor()));
1273 connect(latexModule->childDocGB, SIGNAL(clicked()),
1274 this, SLOT(change_adaptor()));
1275 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1276 this, SLOT(change_adaptor()));
1277 connect(latexModule->childDocPB, SIGNAL(clicked()),
1278 this, SLOT(browseMaster()));
1279 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1280 this, SLOT(change_adaptor()));
1281 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1282 this, SLOT(change_adaptor()));
1284 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1285 latexModule->optionsLE));
1286 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1287 latexModule->childDocLE));
1289 // postscript drivers
1290 for (int n = 0; tex_graphics[n][0]; ++n) {
1291 QString enc = qt_(tex_graphics_gui[n]);
1292 latexModule->psdriverCO->addItem(enc);
1295 LayoutFileList const & bcl = LayoutFileList::get();
1296 vector<LayoutFileIndex> classList = bcl.classList();
1297 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1299 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1300 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1301 for (int i = 0; cit != cen; ++cit, ++i) {
1302 LayoutFile const & tc = bcl[*cit];
1303 bool const available = tc.isTeXClassAvailable();
1304 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1305 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1306 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1308 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1309 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1310 "Please check if you have the matching %1$s class "
1311 "and all required packages (%2$s) installed."),
1312 output_type, from_utf8(tc.prerequisites(", "))));
1314 latexModule->classCO->addItemSort(toqstr(tc.name()),
1316 toqstr(translateIfPossible(from_utf8(tc.category()))),
1318 true, true, true, available);
1323 branchesModule = new GuiBranches;
1324 connect(branchesModule, SIGNAL(changed()),
1325 this, SLOT(change_adaptor()));
1326 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1327 this, SLOT(branchesRename(docstring const &, docstring const &)));
1328 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1329 updateUnknownBranches();
1333 preambleModule = new PreambleModule;
1334 connect(preambleModule, SIGNAL(changed()),
1335 this, SLOT(change_adaptor()));
1337 localLayout = new LocalLayout;
1338 connect(localLayout, SIGNAL(changed()),
1339 this, SLOT(change_adaptor()));
1343 bulletsModule = new BulletsModule;
1344 connect(bulletsModule, SIGNAL(changed()),
1345 this, SLOT(change_adaptor()));
1349 modulesModule = new UiWidget<Ui::ModulesUi>;
1350 modulesModule->availableLV->header()->setVisible(false);
1351 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1352 modulesModule->availableLV->header()->setStretchLastSection(false);
1354 new ModuleSelectionManager(modulesModule->availableLV,
1355 modulesModule->selectedLV,
1356 modulesModule->addPB, modulesModule->deletePB,
1357 modulesModule->upPB, modulesModule->downPB,
1358 availableModel(), selectedModel(), this);
1359 connect(selectionManager, SIGNAL(updateHook()),
1360 this, SLOT(updateModuleInfo()));
1361 connect(selectionManager, SIGNAL(selectionChanged()),
1362 this, SLOT(modulesChanged()));
1366 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1367 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1368 this, SLOT(change_adaptor()));
1369 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1370 this, SLOT(change_adaptor()));
1371 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1372 this, SLOT(change_adaptor()));
1373 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1374 this, SLOT(change_adaptor()));
1375 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1376 this, SLOT(change_adaptor()));
1377 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1378 this, SLOT(change_adaptor()));
1379 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1380 this, SLOT(change_adaptor()));
1381 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1382 this, SLOT(change_adaptor()));
1383 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1384 this, SLOT(change_adaptor()));
1385 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1386 this, SLOT(change_adaptor()));
1387 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1388 this, SLOT(change_adaptor()));
1389 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1390 this, SLOT(change_adaptor()));
1391 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1392 this, SLOT(change_adaptor()));
1393 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1394 this, SLOT(change_adaptor()));
1395 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1396 this, SLOT(change_adaptor()));
1397 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1398 this, SLOT(change_adaptor()));
1400 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1401 pdfSupportModule->titleLE));
1402 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1403 pdfSupportModule->authorLE));
1404 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1405 pdfSupportModule->subjectLE));
1406 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1407 pdfSupportModule->keywordsLE));
1408 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1409 pdfSupportModule->optionsLE));
1411 for (int i = 0; backref_opts[i][0]; ++i)
1412 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1416 floatModule = new FloatPlacement;
1417 connect(floatModule, SIGNAL(changed()),
1418 this, SLOT(change_adaptor()));
1422 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1423 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1424 this, SLOT(change_adaptor()));
1425 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1426 this, SLOT(change_adaptor()));
1427 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1428 this, SLOT(setListingsMessage()));
1429 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1430 this, SLOT(setListingsMessage()));
1431 listingsModule->listingsTB->setPlainText(
1432 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1436 docPS->addPanel(latexModule, N_("Document Class"));
1437 docPS->addPanel(masterChildModule, N_("Child Documents"));
1438 docPS->addPanel(modulesModule, N_("Modules"));
1439 docPS->addPanel(localLayout, N_("Local Layout"));
1440 docPS->addPanel(fontModule, N_("Fonts"));
1441 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1442 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1443 docPS->addPanel(marginsModule, N_("Page Margins"));
1444 docPS->addPanel(langModule, N_("Language"));
1445 docPS->addPanel(colorModule, N_("Colors"));
1446 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1447 docPS->addPanel(biblioModule, N_("Bibliography"));
1448 docPS->addPanel(indicesModule, N_("Indexes"));
1449 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1450 docPS->addPanel(mathsModule, N_("Math Options"));
1451 docPS->addPanel(floatModule, N_("Float Placement"));
1452 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1453 docPS->addPanel(bulletsModule, N_("Bullets"));
1454 docPS->addPanel(branchesModule, N_("Branches"));
1455 docPS->addPanel(outputModule, N_("Formats[[output]]"));
1456 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1457 docPS->setCurrentPanel("Document Class");
1458 // FIXME: hack to work around resizing bug in Qt >= 4.2
1459 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1460 #if QT_VERSION >= 0x040200
1461 docPS->updateGeometry();
1466 void GuiDocument::onBufferViewChanged()
1468 if (isVisibleView())
1469 initialiseParams("");
1473 void GuiDocument::saveDefaultClicked()
1479 void GuiDocument::useDefaultsClicked()
1485 void GuiDocument::change_adaptor()
1487 nonModuleChanged_ = true;
1492 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1497 string child = fromqstr(item->text(0));
1501 if (std::find(includeonlys_.begin(),
1502 includeonlys_.end(), child) != includeonlys_.end())
1503 includeonlys_.remove(child);
1505 includeonlys_.push_back(child);
1507 updateIncludeonlys();
1512 QString GuiDocument::validateListingsParameters()
1514 if (listingsModule->bypassCB->isChecked())
1516 string params = fromqstr(listingsModule->listingsED->toPlainText());
1517 return toqstr(InsetListingsParams(params).validate());
1521 void GuiDocument::setListingsMessage()
1524 static bool isOK = true;
1525 QString msg = validateListingsParameters();
1526 if (msg.isEmpty()) {
1530 // listingsTB->setTextColor("black");
1531 listingsModule->listingsTB->setPlainText(
1532 qt_("Input listings parameters below. "
1533 "Enter ? for a list of parameters."));
1536 // listingsTB->setTextColor("red");
1537 listingsModule->listingsTB->setPlainText(msg);
1542 void GuiDocument::setLSpacing(int item)
1544 textLayoutModule->lspacingLE->setEnabled(item == 3);
1548 void GuiDocument::setIndent(int item)
1550 bool const enable = (item == 1);
1551 textLayoutModule->indentLE->setEnabled(enable);
1552 textLayoutModule->indentLengthCO->setEnabled(enable);
1553 textLayoutModule->skipLE->setEnabled(false);
1554 textLayoutModule->skipLengthCO->setEnabled(false);
1559 void GuiDocument::enableIndent(bool indent)
1561 textLayoutModule->skipLE->setEnabled(!indent);
1562 textLayoutModule->skipLengthCO->setEnabled(!indent);
1564 setIndent(textLayoutModule->indentCO->currentIndex());
1568 void GuiDocument::setSkip(int item)
1570 bool const enable = (item == 3);
1571 textLayoutModule->skipLE->setEnabled(enable);
1572 textLayoutModule->skipLengthCO->setEnabled(enable);
1577 void GuiDocument::enableSkip(bool skip)
1579 textLayoutModule->indentLE->setEnabled(!skip);
1580 textLayoutModule->indentLengthCO->setEnabled(!skip);
1582 setSkip(textLayoutModule->skipCO->currentIndex());
1586 void GuiDocument::setMargins()
1588 bool const extern_geometry =
1589 documentClass().provides("geometry");
1590 marginsModule->marginCB->setEnabled(!extern_geometry);
1591 if (extern_geometry) {
1592 marginsModule->marginCB->setChecked(false);
1593 setCustomMargins(true);
1595 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1596 setCustomMargins(!bp_.use_geometry);
1601 void GuiDocument::papersizeChanged(int paper_size)
1603 setCustomPapersize(paper_size == 1);
1607 void GuiDocument::setCustomPapersize(bool custom)
1609 pageLayoutModule->paperwidthL->setEnabled(custom);
1610 pageLayoutModule->paperwidthLE->setEnabled(custom);
1611 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1612 pageLayoutModule->paperheightL->setEnabled(custom);
1613 pageLayoutModule->paperheightLE->setEnabled(custom);
1614 pageLayoutModule->paperheightLE->setFocus();
1615 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1619 void GuiDocument::setColSep()
1621 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1625 void GuiDocument::setCustomMargins(bool custom)
1627 marginsModule->topL->setEnabled(!custom);
1628 marginsModule->topLE->setEnabled(!custom);
1629 marginsModule->topUnit->setEnabled(!custom);
1631 marginsModule->bottomL->setEnabled(!custom);
1632 marginsModule->bottomLE->setEnabled(!custom);
1633 marginsModule->bottomUnit->setEnabled(!custom);
1635 marginsModule->innerL->setEnabled(!custom);
1636 marginsModule->innerLE->setEnabled(!custom);
1637 marginsModule->innerUnit->setEnabled(!custom);
1639 marginsModule->outerL->setEnabled(!custom);
1640 marginsModule->outerLE->setEnabled(!custom);
1641 marginsModule->outerUnit->setEnabled(!custom);
1643 marginsModule->headheightL->setEnabled(!custom);
1644 marginsModule->headheightLE->setEnabled(!custom);
1645 marginsModule->headheightUnit->setEnabled(!custom);
1647 marginsModule->headsepL->setEnabled(!custom);
1648 marginsModule->headsepLE->setEnabled(!custom);
1649 marginsModule->headsepUnit->setEnabled(!custom);
1651 marginsModule->footskipL->setEnabled(!custom);
1652 marginsModule->footskipLE->setEnabled(!custom);
1653 marginsModule->footskipUnit->setEnabled(!custom);
1655 bool const enableColSep = !custom &&
1656 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1657 marginsModule->columnsepL->setEnabled(enableColSep);
1658 marginsModule->columnsepLE->setEnabled(enableColSep);
1659 marginsModule->columnsepUnit->setEnabled(enableColSep);
1663 void GuiDocument::changeBackgroundColor()
1665 QColor const & newColor = QColorDialog::getColor(
1666 rgb2qcolor(set_backgroundcolor), asQWidget());
1667 if (!newColor.isValid())
1669 // set the button color and text
1670 colorModule->backgroundPB->setStyleSheet(
1671 colorButtonStyleSheet(newColor));
1672 colorModule->backgroundPB->setText(qt_("&Change..."));
1674 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1675 is_backgroundcolor = true;
1680 void GuiDocument::deleteBackgroundColor()
1682 // set the button color back to default by setting an empty StyleSheet
1683 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1684 // change button text
1685 colorModule->backgroundPB->setText(qt_("&Default..."));
1686 // save default color (white)
1687 set_backgroundcolor = rgbFromHexName("#ffffff");
1688 is_backgroundcolor = false;
1693 void GuiDocument::changeFontColor()
1695 QColor const & newColor = QColorDialog::getColor(
1696 rgb2qcolor(set_fontcolor), asQWidget());
1697 if (!newColor.isValid())
1699 // set the button color and text
1700 colorModule->fontColorPB->setStyleSheet(
1701 colorButtonStyleSheet(newColor));
1702 colorModule->fontColorPB->setText(qt_("&Change..."));
1704 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1705 is_fontcolor = true;
1710 void GuiDocument::deleteFontColor()
1712 // set the button color back to default by setting an empty StyleSheet
1713 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1714 // change button text
1715 colorModule->fontColorPB->setText(qt_("&Default..."));
1716 // save default color (black)
1717 set_fontcolor = rgbFromHexName("#000000");
1718 is_fontcolor = false;
1723 void GuiDocument::changeNoteFontColor()
1725 QColor const & newColor = QColorDialog::getColor(
1726 rgb2qcolor(set_notefontcolor), asQWidget());
1727 if (!newColor.isValid())
1729 // set the button color
1730 colorModule->noteFontColorPB->setStyleSheet(
1731 colorButtonStyleSheet(newColor));
1733 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1738 void GuiDocument::deleteNoteFontColor()
1740 // set the button color back to pref
1741 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1742 colorModule->noteFontColorPB->setStyleSheet(
1743 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1748 void GuiDocument::changeBoxBackgroundColor()
1750 QColor const & newColor = QColorDialog::getColor(
1751 rgb2qcolor(set_boxbgcolor), asQWidget());
1752 if (!newColor.isValid())
1754 // set the button color
1755 colorModule->boxBackgroundPB->setStyleSheet(
1756 colorButtonStyleSheet(newColor));
1758 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1763 void GuiDocument::deleteBoxBackgroundColor()
1765 // set the button color back to pref
1766 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1767 colorModule->boxBackgroundPB->setStyleSheet(
1768 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1773 void GuiDocument::updateQuoteStyles(bool const set)
1775 Language const * lang = lyx::languages.getLanguage(
1776 fromqstr(langModule->languageCO->itemData(
1777 langModule->languageCO->currentIndex()).toString()));
1779 InsetQuotesParams::QuoteStyle def = bp_.getQuoteStyle(lang->quoteStyle());
1781 langModule->quoteStyleCO->clear();
1783 bool has_default = false;
1784 for (int i = 0; i < quoteparams.stylescount(); ++i) {
1785 InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::QuoteStyle(i);
1786 if (qs == InsetQuotesParams::DynamicQuotes)
1788 bool const langdef = (qs == def);
1790 // add the default style on top
1791 langModule->quoteStyleCO->insertItem(0,
1792 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1796 langModule->quoteStyleCO->addItem(
1797 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1799 if (set && has_default)
1800 // (re)set to the default style
1801 langModule->quoteStyleCO->setCurrentIndex(0);
1805 void GuiDocument::languageChanged(int i)
1807 // some languages only work with polyglossia
1808 Language const * lang = lyx::languages.getLanguage(
1809 fromqstr(langModule->languageCO->itemData(i).toString()));
1810 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1811 // If we force to switch fontspec on, store
1812 // current state (#8717)
1813 if (fontModule->osFontsCB->isEnabled())
1814 forced_fontspec_activation =
1815 !fontModule->osFontsCB->isChecked();
1816 fontModule->osFontsCB->setChecked(true);
1817 fontModule->osFontsCB->setEnabled(false);
1820 fontModule->osFontsCB->setEnabled(true);
1821 // If we have forced to switch fontspec on,
1822 // restore previous state (#8717)
1823 if (forced_fontspec_activation)
1824 fontModule->osFontsCB->setChecked(false);
1825 forced_fontspec_activation = false;
1828 // set appropriate quotation mark style
1829 updateQuoteStyles(true);
1833 void GuiDocument::osFontsChanged(bool nontexfonts)
1835 bool const tex_fonts = !nontexfonts;
1836 // store current fonts
1837 QString const font_roman = fontModule->fontsRomanCO->itemData(
1838 fontModule->fontsRomanCO->currentIndex()).toString();
1839 QString const font_sans = fontModule->fontsSansCO->itemData(
1840 fontModule->fontsSansCO->currentIndex()).toString();
1841 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1842 fontModule->fontsTypewriterCO->currentIndex()).toString();
1843 QString const font_math = fontModule->fontsMathCO->itemData(
1844 fontModule->fontsMathCO->currentIndex()).toString();
1845 int const font_sf_scale = fontModule->scaleSansSB->value();
1846 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1849 // store default format
1850 QString const dformat = outputModule->defaultFormatCO->itemData(
1851 outputModule->defaultFormatCO->currentIndex()).toString();
1852 updateDefaultFormat();
1853 // try to restore default format
1854 int index = outputModule->defaultFormatCO->findData(dformat);
1855 // set to default if format is not found
1858 outputModule->defaultFormatCO->setCurrentIndex(index);
1860 // try to restore fonts which were selected two toggles ago
1861 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1863 fontModule->fontsRomanCO->setCurrentIndex(index);
1864 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1866 fontModule->fontsSansCO->setCurrentIndex(index);
1867 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1869 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1870 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1872 fontModule->fontsMathCO->setCurrentIndex(index);
1873 // save fonts for next next toggle
1874 fontModule->font_roman = font_roman;
1875 fontModule->font_sans = font_sans;
1876 fontModule->font_typewriter = font_typewriter;
1877 fontModule->font_math = font_math;
1878 fontModule->font_sf_scale = font_sf_scale;
1879 fontModule->font_tt_scale = font_tt_scale;
1881 langModule->encodingCO->setEnabled(tex_fonts &&
1882 !langModule->defaultencodingRB->isChecked());
1883 langModule->defaultencodingRB->setEnabled(tex_fonts);
1884 langModule->otherencodingRB->setEnabled(tex_fonts);
1886 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1887 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1888 fontModule->cjkFontLE->setEnabled(tex_fonts);
1889 fontModule->cjkFontLA->setEnabled(tex_fonts);
1891 updateFontOptions();
1893 fontModule->fontencLA->setEnabled(tex_fonts);
1894 fontModule->fontencCO->setEnabled(tex_fonts);
1896 fontModule->fontencLE->setEnabled(false);
1898 fontencChanged(fontModule->fontencCO->currentIndex());
1902 void GuiDocument::mathFontChanged(int)
1904 updateFontOptions();
1908 void GuiDocument::fontOsfToggled(bool state)
1910 if (fontModule->osFontsCB->isChecked())
1912 QString font = fontModule->fontsRomanCO->itemData(
1913 fontModule->fontsRomanCO->currentIndex()).toString();
1914 if (hasMonolithicExpertSet(font))
1915 fontModule->fontScCB->setChecked(state);
1919 void GuiDocument::fontScToggled(bool state)
1921 if (fontModule->osFontsCB->isChecked())
1923 QString font = fontModule->fontsRomanCO->itemData(
1924 fontModule->fontsRomanCO->currentIndex()).toString();
1925 if (hasMonolithicExpertSet(font))
1926 fontModule->fontOsfCB->setChecked(state);
1930 void GuiDocument::updateFontOptions()
1932 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1935 font = fontModule->fontsSansCO->itemData(
1936 fontModule->fontsSansCO->currentIndex()).toString();
1937 bool scaleable = providesScale(font);
1938 fontModule->scaleSansSB->setEnabled(scaleable);
1939 fontModule->scaleSansLA->setEnabled(scaleable);
1941 font = fontModule->fontsTypewriterCO->itemData(
1942 fontModule->fontsTypewriterCO->currentIndex()).toString();
1943 scaleable = providesScale(font);
1944 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1945 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1947 font = fontModule->fontsRomanCO->itemData(
1948 fontModule->fontsRomanCO->currentIndex()).toString();
1949 fontModule->fontScCB->setEnabled(providesSC(font));
1950 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1951 updateMathFonts(font);
1955 void GuiDocument::updateFontsize(string const & items, string const & sel)
1957 fontModule->fontsizeCO->clear();
1958 fontModule->fontsizeCO->addItem(qt_("Default"));
1960 for (int n = 0; !token(items,'|',n).empty(); ++n)
1961 fontModule->fontsizeCO->
1962 addItem(toqstr(token(items,'|',n)));
1964 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1965 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1966 fontModule->fontsizeCO->setCurrentIndex(n);
1973 bool GuiDocument::ot1() const
1975 QString const fontenc =
1976 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
1977 return (fontenc == "default"
1978 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
1979 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
1983 bool GuiDocument::completeFontset() const
1985 return (fontModule->fontsSansCO->itemData(
1986 fontModule->fontsSansCO->currentIndex()).toString() == "default"
1987 && fontModule->fontsSansCO->itemData(
1988 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
1992 bool GuiDocument::noMathFont() const
1994 return (fontModule->fontsMathCO->itemData(
1995 fontModule->fontsMathCO->currentIndex()).toString() == "default");
1999 void GuiDocument::updateTexFonts()
2001 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
2003 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
2004 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
2005 for (; it != end; ++it) {
2006 LaTeXFont lf = it->second;
2007 if (lf.name().empty()) {
2008 LYXERR0("Error: Unnamed font: " << it->first);
2011 docstring const family = lf.family();
2012 docstring guiname = translateIfPossible(lf.guiname());
2013 if (!lf.available(ot1(), noMathFont()))
2014 guiname += _(" (not installed)");
2016 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
2017 else if (family == "sf")
2018 sffonts_.insert(toqstr(guiname), toqstr(it->first));
2019 else if (family == "tt")
2020 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
2021 else if (family == "math")
2022 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
2027 void GuiDocument::updateFontlist()
2029 fontModule->fontsRomanCO->clear();
2030 fontModule->fontsSansCO->clear();
2031 fontModule->fontsTypewriterCO->clear();
2032 fontModule->fontsMathCO->clear();
2034 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
2035 if (fontModule->osFontsCB->isChecked()) {
2036 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2037 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2038 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2039 QString unimath = qt_("Non-TeX Fonts Default");
2040 if (!LaTeXFeatures::isAvailable("unicode-math"))
2041 unimath += qt_(" (not available)");
2042 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
2043 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2045 QFontDatabase fontdb;
2046 QStringList families(fontdb.families());
2047 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2048 fontModule->fontsRomanCO->addItem(*it, *it);
2049 fontModule->fontsSansCO->addItem(*it, *it);
2050 fontModule->fontsTypewriterCO->addItem(*it, *it);
2055 if (rmfonts_.empty())
2058 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2059 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2060 while (rmi != rmfonts_.constEnd()) {
2061 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2065 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2066 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2067 while (sfi != sffonts_.constEnd()) {
2068 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2072 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2073 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2074 while (tti != ttfonts_.constEnd()) {
2075 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2079 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2080 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2081 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2082 while (mmi != mathfonts_.constEnd()) {
2083 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2089 void GuiDocument::fontencChanged(int item)
2091 fontModule->fontencLE->setEnabled(
2092 fontModule->fontencCO->itemData(item).toString() == "custom");
2093 // The availability of TeX fonts depends on the font encoding
2095 updateFontOptions();
2099 void GuiDocument::updateMathFonts(QString const & rm)
2101 if (fontModule->osFontsCB->isChecked())
2103 QString const math =
2104 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2105 int const i = fontModule->fontsMathCO->findData("default");
2106 if (providesNoMath(rm) && i == -1)
2107 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2108 else if (!providesNoMath(rm) && i != -1) {
2109 int const c = fontModule->fontsMathCO->currentIndex();
2110 fontModule->fontsMathCO->removeItem(i);
2112 fontModule->fontsMathCO->setCurrentIndex(0);
2117 void GuiDocument::romanChanged(int item)
2119 if (fontModule->osFontsCB->isChecked())
2121 QString const font =
2122 fontModule->fontsRomanCO->itemData(item).toString();
2123 fontModule->fontScCB->setEnabled(providesSC(font));
2124 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2125 updateMathFonts(font);
2129 void GuiDocument::sansChanged(int item)
2131 if (fontModule->osFontsCB->isChecked())
2133 QString const font =
2134 fontModule->fontsSansCO->itemData(item).toString();
2135 bool scaleable = providesScale(font);
2136 fontModule->scaleSansSB->setEnabled(scaleable);
2137 fontModule->scaleSansLA->setEnabled(scaleable);
2141 void GuiDocument::ttChanged(int item)
2143 if (fontModule->osFontsCB->isChecked())
2145 QString const font =
2146 fontModule->fontsTypewriterCO->itemData(item).toString();
2147 bool scaleable = providesScale(font);
2148 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2149 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2153 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2156 pageLayoutModule->pagestyleCO->clear();
2157 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2159 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2160 string style = token(items, '|', n);
2161 QString style_gui = qt_(style);
2162 pagestyles.push_back(pair<string, QString>(style, style_gui));
2163 pageLayoutModule->pagestyleCO->addItem(style_gui);
2166 if (sel == "default") {
2167 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2173 for (size_t i = 0; i < pagestyles.size(); ++i)
2174 if (pagestyles[i].first == sel)
2175 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2178 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2182 void GuiDocument::browseLayout()
2184 QString const label1 = qt_("Layouts|#o#O");
2185 QString const dir1 = toqstr(lyxrc.document_path);
2186 QStringList const filter(qt_("LyX Layout (*.layout)"));
2187 QString file = browseRelToParent(QString(), bufferFilePath(),
2188 qt_("Local layout file"), filter, false,
2191 if (!file.endsWith(".layout"))
2194 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2195 fromqstr(bufferFilePath()));
2197 int const ret = Alert::prompt(_("Local layout file"),
2198 _("The layout file you have selected is a local layout\n"
2199 "file, not one in the system or user directory.\n"
2200 "Your document will not work with this layout if you\n"
2201 "move the layout file to a different directory."),
2202 1, 1, _("&Set Layout"), _("&Cancel"));
2206 // load the layout file
2207 LayoutFileList & bcl = LayoutFileList::get();
2208 string classname = layoutFile.onlyFileName();
2209 // this will update an existing layout if that layout has been loaded before.
2210 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2211 classname.substr(0, classname.size() - 7),
2212 layoutFile.onlyPath().absFileName()));
2215 Alert::error(_("Error"),
2216 _("Unable to read local layout file."));
2220 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2222 // do not trigger classChanged if there is no change.
2223 if (latexModule->classCO->currentText() == toqstr(name))
2227 bool const avail = latexModule->classCO->set(toqstr(name));
2229 LayoutFile const & tc = bcl[name];
2230 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2231 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2232 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2233 tooltip += '\n' + qt_("This is a local layout file.");
2234 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2235 toqstr(translateIfPossible(from_utf8(tc.category()))),
2237 true, true, true, true);
2238 latexModule->classCO->set(toqstr(name));
2245 void GuiDocument::browseMaster()
2247 QString const title = qt_("Select master document");
2248 QString const dir1 = toqstr(lyxrc.document_path);
2249 QString const old = latexModule->childDocLE->text();
2250 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2251 QStringList const filter(qt_("LyX Files (*.lyx)"));
2252 QString file = browseRelToSub(old, docpath, title, filter, false,
2253 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2255 if (!file.isEmpty())
2256 latexModule->childDocLE->setText(file);
2260 void GuiDocument::classChanged_adaptor()
2262 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2267 void GuiDocument::classChanged()
2269 int idx = latexModule->classCO->currentIndex();
2272 string const classname = fromqstr(latexModule->classCO->getData(idx));
2274 if (applyPB->isEnabled()) {
2275 int const ret = Alert::prompt(_("Unapplied changes"),
2276 _("Some changes in the dialog were not yet applied.\n"
2277 "If you do not apply now, they will be lost after this action."),
2278 1, 1, _("&Apply"), _("&Dismiss"));
2283 // We load the TextClass as soon as it is selected. This is
2284 // necessary so that other options in the dialog can be updated
2285 // according to the new class. Note, however, that, if you use
2286 // the scroll wheel when sitting on the combo box, we'll load a
2287 // lot of TextClass objects very quickly....
2288 if (!bp_.setBaseClass(classname)) {
2289 Alert::error(_("Error"), _("Unable to set document class."));
2292 if (lyxrc.auto_reset_options)
2293 bp_.useClassDefaults();
2295 // With the introduction of modules came a distinction between the base
2296 // class and the document class. The former corresponds to the main layout
2297 // file; the latter is that plus the modules (or the document-specific layout,
2298 // or whatever else there could be). Our parameters come from the document
2299 // class. So when we set the base class, we also need to recreate the document
2300 // class. Otherwise, we still have the old one.
2301 bp_.makeDocumentClass();
2306 void GuiDocument::languagePackageChanged(int i)
2308 langModule->languagePackageLE->setEnabled(
2309 langModule->languagePackageCO->itemData(i).toString() == "custom");
2313 void GuiDocument::biblioChanged()
2315 biblioChanged_ = true;
2320 void GuiDocument::rescanBibFiles()
2323 rescanTexStyles("bbx cbx");
2325 rescanTexStyles("bst");
2329 void GuiDocument::resetDefaultBibfile(string const & which)
2331 QString const engine =
2332 biblioModule->citeEngineCO->itemData(
2333 biblioModule->citeEngineCO->currentIndex()).toString();
2335 CiteEngineType const cet =
2336 CiteEngineType(biblioModule->citeStyleCO->itemData(
2337 biblioModule->citeStyleCO->currentIndex()).toInt());
2339 updateDefaultBiblio(theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet), which);
2343 void GuiDocument::resetDefaultBbxBibfile()
2345 resetDefaultBibfile("bbx");
2349 void GuiDocument::resetDefaultCbxBibfile()
2351 resetDefaultBibfile("cbx");
2355 void GuiDocument::citeEngineChanged(int n)
2357 QString const engine =
2358 biblioModule->citeEngineCO->itemData(n).toString();
2360 vector<string> const engs =
2361 theCiteEnginesList[fromqstr(engine)]->getEngineType();
2363 updateCiteStyles(engs);
2364 updateEngineDependends();
2365 resetDefaultBibfile();
2370 void GuiDocument::updateEngineDependends()
2372 bool const biblatex = isBiblatex();
2374 // These are only useful with BibTeX
2375 biblioModule->defaultBiblioCO->setEnabled(!biblatex);
2376 biblioModule->bibtexStyleLA->setEnabled(!biblatex);
2377 biblioModule->resetDefaultBiblioPB->setEnabled(!biblatex);
2378 biblioModule->bibtopicCB->setEnabled(!biblatex);
2380 // These are only useful with Biblatex
2381 biblioModule->biblatexBbxCO->setEnabled(biblatex);
2382 biblioModule->biblatexBbxLA->setEnabled(biblatex);
2383 biblioModule->biblatexCbxCO->setEnabled(biblatex);
2384 biblioModule->biblatexCbxLA->setEnabled(biblatex);
2385 biblioModule->resetBbxPB->setEnabled(biblatex);
2386 biblioModule->resetCbxPB->setEnabled(biblatex);
2387 biblioModule->matchBbxPB->setEnabled(biblatex);
2389 // These are useful with biblatex, jurabib and natbib
2390 QString const engine =
2391 biblioModule->citeEngineCO->itemData(
2392 biblioModule->citeEngineCO->currentIndex()).toString();
2393 LyXCiteEngine const * ce = theCiteEnginesList[fromqstr(engine)];
2395 bool const citepack = ce->requires("biblatex.sty") || ce->requires("jurabib.sty")
2396 || ce->requires("natbib.sty");
2397 biblioModule->citePackageOptionsLE->setEnabled(citepack);
2398 biblioModule->citePackageOptionsL->setEnabled(citepack);
2402 void GuiDocument::citeStyleChanged()
2404 QString const engine =
2405 biblioModule->citeEngineCO->itemData(
2406 biblioModule->citeEngineCO->currentIndex()).toString();
2407 QString const currentDef = isBiblatex() ?
2408 biblioModule->biblatexBbxCO->currentText()
2409 : biblioModule->defaultBiblioCO->currentText();
2410 if (theCiteEnginesList[fromqstr(engine)]->isDefaultBiblio(fromqstr(currentDef)))
2411 resetDefaultBibfile();
2417 void GuiDocument::bibtexChanged(int n)
2419 biblioModule->bibtexOptionsLE->setEnabled(
2420 biblioModule->bibtexCO->itemData(n).toString() != "default");
2425 void GuiDocument::updateCiteStyles(vector<string> const & engs, CiteEngineType const & sel)
2427 biblioModule->citeStyleCO->clear();
2429 vector<string>::const_iterator it = engs.begin();
2430 vector<string>::const_iterator end = engs.end();
2431 for (; it != end; ++it) {
2432 if (*it == "default")
2433 biblioModule->citeStyleCO->addItem(qt_("Basic numerical"),
2434 ENGINE_TYPE_DEFAULT);
2435 else if (*it == "authoryear")
2436 biblioModule->citeStyleCO->addItem(qt_("Author-year"),
2437 ENGINE_TYPE_AUTHORYEAR);
2438 else if (*it == "numerical")
2439 biblioModule->citeStyleCO->addItem(qt_("Author-number"),
2440 ENGINE_TYPE_NUMERICAL);
2442 int i = biblioModule->citeStyleCO->findData(sel);
2443 if (biblioModule->citeStyleCO->findData(sel) == -1)
2445 biblioModule->citeStyleCO->setCurrentIndex(i);
2447 biblioModule->citationStyleL->setEnabled(engs.size() > 1);
2448 biblioModule->citeStyleCO->setEnabled(engs.size() > 1);
2452 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2454 engine_types_.clear();
2458 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2460 string style = token(items, '|', n);
2461 engine_types_.push_back(style);
2464 updateCiteStyles(engine_types_, sel);
2470 // both of these should take a vector<docstring>
2472 // This is an insanely complicated attempt to make this sort of thing
2473 // work with RTL languages.
2474 docstring formatStrVec(vector<string> const & v, docstring const & s)
2476 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2480 return translateIfPossible(from_utf8(v[0]));
2481 if (v.size() == 2) {
2482 docstring retval = _("%1$s and %2$s");
2483 retval = subst(retval, _("and"), s);
2484 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2485 translateIfPossible(from_utf8(v[1])));
2487 // The idea here is to format all but the last two items...
2488 int const vSize = v.size();
2489 docstring t2 = _("%1$s, %2$s");
2490 docstring retval = translateIfPossible(from_utf8(v[0]));
2491 for (int i = 1; i < vSize - 2; ++i)
2492 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2493 //...and then to plug them, and the last two, into this schema
2494 docstring t = _("%1$s, %2$s, and %3$s");
2495 t = subst(t, _("and"), s);
2496 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2497 translateIfPossible(from_utf8(v[vSize - 1])));
2500 vector<string> idsToNames(vector<string> const & idList)
2502 vector<string> retval;
2503 vector<string>::const_iterator it = idList.begin();
2504 vector<string>::const_iterator end = idList.end();
2505 for (; it != end; ++it) {
2506 LyXModule const * const mod = theModuleList[*it];
2508 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2509 translateIfPossible(from_utf8(*it)))));
2511 retval.push_back(mod->getName());
2515 } // end anonymous namespace
2518 void GuiDocument::modulesToParams(BufferParams & bp)
2520 // update list of loaded modules
2521 bp.clearLayoutModules();
2522 int const srows = modules_sel_model_.rowCount();
2523 for (int i = 0; i < srows; ++i)
2524 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2526 // update the list of removed modules
2527 bp.clearRemovedModules();
2528 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2529 list<string>::const_iterator rit = reqmods.begin();
2530 list<string>::const_iterator ren = reqmods.end();
2532 // check each of the default modules
2533 for (; rit != ren; ++rit) {
2534 list<string>::const_iterator mit = bp.getModules().begin();
2535 list<string>::const_iterator men = bp.getModules().end();
2537 for (; mit != men; ++mit) {
2544 // the module isn't present so must have been removed by the user
2545 bp.addRemovedModule(*rit);
2550 void GuiDocument::modulesChanged()
2552 modulesToParams(bp_);
2554 if (applyPB->isEnabled() && nonModuleChanged_) {
2555 int const ret = Alert::prompt(_("Unapplied changes"),
2556 _("Some changes in the dialog were not yet applied.\n"
2557 "If you do not apply now, they will be lost after this action."),
2558 1, 1, _("&Apply"), _("&Dismiss"));
2563 bp_.makeDocumentClass();
2569 void GuiDocument::updateModuleInfo()
2571 selectionManager->update();
2573 //Module description
2574 bool const focus_on_selected = selectionManager->selectedFocused();
2575 QAbstractItemView * lv;
2576 if (focus_on_selected)
2577 lv = modulesModule->selectedLV;
2579 lv = modulesModule->availableLV;
2580 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2581 modulesModule->infoML->document()->clear();
2584 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2585 GuiIdListModel const & id_model =
2586 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2587 string const modName = id_model.getIDString(idx.row());
2588 docstring desc = getModuleDescription(modName);
2590 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2591 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2594 desc += _("Module provided by document class.");
2597 docstring cat = getModuleCategory(modName);
2601 desc += bformat(_("Category: %1$s."), cat);
2604 vector<string> pkglist = getPackageList(modName);
2605 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2606 if (!pkgdesc.empty()) {
2609 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2612 pkglist = getRequiredList(modName);
2613 if (!pkglist.empty()) {
2614 vector<string> const reqdescs = idsToNames(pkglist);
2615 pkgdesc = formatStrVec(reqdescs, _("or"));
2618 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2621 pkglist = getExcludedList(modName);
2622 if (!pkglist.empty()) {
2623 vector<string> const reqdescs = idsToNames(pkglist);
2624 pkgdesc = formatStrVec(reqdescs, _( "and"));
2627 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2630 if (!isModuleAvailable(modName)) {
2633 desc += _("WARNING: Some required packages are unavailable!");
2636 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2640 void GuiDocument::updateNumbering()
2642 DocumentClass const & tclass = documentClass();
2644 numberingModule->tocTW->setUpdatesEnabled(false);
2645 numberingModule->tocTW->clear();
2647 int const depth = numberingModule->depthSL->value();
2648 int const toc = numberingModule->tocSL->value();
2649 QString const no = qt_("No");
2650 QString const yes = qt_("Yes");
2651 QTreeWidgetItem * item = 0;
2653 DocumentClass::const_iterator lit = tclass.begin();
2654 DocumentClass::const_iterator len = tclass.end();
2655 for (; lit != len; ++lit) {
2656 int const toclevel = lit->toclevel;
2657 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2658 item = new QTreeWidgetItem(numberingModule->tocTW);
2659 item->setText(0, toqstr(translateIfPossible(lit->name())));
2660 item->setText(1, (toclevel <= depth) ? yes : no);
2661 item->setText(2, (toclevel <= toc) ? yes : no);
2665 numberingModule->tocTW->setUpdatesEnabled(true);
2666 numberingModule->tocTW->update();
2670 void GuiDocument::updateDefaultFormat()
2674 // make a copy in order to consider unapplied changes
2675 BufferParams param_copy = buffer().params();
2676 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2677 int const idx = latexModule->classCO->currentIndex();
2679 string const classname = fromqstr(latexModule->classCO->getData(idx));
2680 param_copy.setBaseClass(classname);
2681 param_copy.makeDocumentClass(true);
2683 outputModule->defaultFormatCO->blockSignals(true);
2684 outputModule->defaultFormatCO->clear();
2685 outputModule->defaultFormatCO->addItem(qt_("Default"),
2686 QVariant(QString("default")));
2687 FormatList const & formats =
2688 param_copy.exportableFormats(true);
2689 for (Format const * f : formats)
2690 outputModule->defaultFormatCO->addItem
2691 (toqstr(translateIfPossible(f->prettyname())),
2692 QVariant(toqstr(f->name())));
2693 outputModule->defaultFormatCO->blockSignals(false);
2697 bool GuiDocument::isChildIncluded(string const & child)
2699 if (includeonlys_.empty())
2701 return (std::find(includeonlys_.begin(),
2702 includeonlys_.end(), child) != includeonlys_.end());
2706 void GuiDocument::applyView()
2709 preambleModule->apply(bp_);
2710 localLayout->apply(bp_);
2713 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2714 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2717 string const engine =
2718 fromqstr(biblioModule->citeEngineCO->itemData(
2719 biblioModule->citeEngineCO->currentIndex()).toString());
2720 bp_.setCiteEngine(engine);
2722 CiteEngineType const style = CiteEngineType(biblioModule->citeStyleCO->itemData(
2723 biblioModule->citeStyleCO->currentIndex()).toInt());
2724 if (theCiteEnginesList[engine]->hasEngineType(style))
2725 bp_.setCiteEngineType(style);
2727 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2730 biblioModule->bibtopicCB->isChecked();
2732 bp_.setDefaultBiblioStyle(fromqstr(biblioModule->defaultBiblioCO->currentText()));
2734 bp_.biblatex_bibstyle = fromqstr(biblioModule->biblatexBbxCO->currentText());
2735 bp_.biblatex_citestyle = fromqstr(biblioModule->biblatexCbxCO->currentText());
2736 bp_.biblio_opts = fromqstr(biblioModule->citePackageOptionsLE->text());
2738 string const bibtex_command =
2739 fromqstr(biblioModule->bibtexCO->itemData(
2740 biblioModule->bibtexCO->currentIndex()).toString());
2741 string const bibtex_options =
2742 fromqstr(biblioModule->bibtexOptionsLE->text());
2743 if (bibtex_command == "default" || bibtex_options.empty())
2744 bp_.bibtex_command = bibtex_command;
2746 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2748 if (biblioChanged_) {
2749 buffer().invalidateBibinfoCache();
2750 buffer().removeBiblioTempFiles();
2754 indicesModule->apply(bp_);
2756 // language & quotes
2757 if (langModule->defaultencodingRB->isChecked()) {
2758 bp_.inputenc = "auto";
2760 int i = langModule->encodingCO->currentIndex();
2762 bp_.inputenc = "default";
2764 QString const enc_gui =
2765 langModule->encodingCO->currentText();
2766 Encodings::const_iterator it = encodings.begin();
2767 Encodings::const_iterator const end = encodings.end();
2769 for (; it != end; ++it) {
2770 if (qt_(it->guiName()) == enc_gui &&
2772 bp_.inputenc = it->name();
2778 // should not happen
2779 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2780 bp_.inputenc = "default";
2785 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2786 langModule->quoteStyleCO->currentIndex()).toInt();
2787 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2789 QString const langname = langModule->languageCO->itemData(
2790 langModule->languageCO->currentIndex()).toString();
2791 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2792 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2793 // If current cursor language was the document language, then update it too.
2794 if (cur.current_font.language() == bp_.language) {
2795 cur.current_font.setLanguage(newlang);
2796 cur.real_current_font.setLanguage(newlang);
2798 bp_.language = newlang;
2800 QString const pack = langModule->languagePackageCO->itemData(
2801 langModule->languagePackageCO->currentIndex()).toString();
2802 if (pack == "custom")
2804 fromqstr(langModule->languagePackageLE->text());
2806 bp_.lang_package = fromqstr(pack);
2809 bp_.backgroundcolor = set_backgroundcolor;
2810 bp_.isbackgroundcolor = is_backgroundcolor;
2811 bp_.fontcolor = set_fontcolor;
2812 bp_.isfontcolor = is_fontcolor;
2813 bp_.notefontcolor = set_notefontcolor;
2814 bp_.boxbgcolor = set_boxbgcolor;
2817 if (bp_.documentClass().hasTocLevels()) {
2818 bp_.tocdepth = numberingModule->tocSL->value();
2819 bp_.secnumdepth = numberingModule->depthSL->value();
2823 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2824 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2825 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2826 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2829 bp_.graphics_driver =
2830 tex_graphics[latexModule->psdriverCO->currentIndex()];
2833 int idx = latexModule->classCO->currentIndex();
2835 string const classname = fromqstr(latexModule->classCO->getData(idx));
2836 bp_.setBaseClass(classname);
2840 modulesToParams(bp_);
2843 map<string, string> const & packages = BufferParams::auto_packages();
2844 for (map<string, string>::const_iterator it = packages.begin();
2845 it != packages.end(); ++it) {
2846 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2849 int row = mathsModule->packagesTW->row(item);
2850 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2851 if (rb->isChecked()) {
2852 bp_.use_package(it->first, BufferParams::package_auto);
2855 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2856 if (rb->isChecked()) {
2857 bp_.use_package(it->first, BufferParams::package_on);
2860 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2861 if (rb->isChecked())
2862 bp_.use_package(it->first, BufferParams::package_off);
2866 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2867 bp_.pagestyle = "default";
2869 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2870 for (size_t i = 0; i != pagestyles.size(); ++i)
2871 if (pagestyles[i].second == style_gui)
2872 bp_.pagestyle = pagestyles[i].first;
2876 switch (textLayoutModule->lspacingCO->currentIndex()) {
2878 bp_.spacing().set(Spacing::Single);
2881 bp_.spacing().set(Spacing::Onehalf);
2884 bp_.spacing().set(Spacing::Double);
2887 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2889 bp_.spacing().set(Spacing::Single);
2891 bp_.spacing().set(Spacing::Other, s);
2896 if (textLayoutModule->twoColumnCB->isChecked())
2901 bp_.justification = textLayoutModule->justCB->isChecked();
2903 if (textLayoutModule->indentRB->isChecked()) {
2904 // if paragraphs are separated by an indentation
2905 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2906 switch (textLayoutModule->indentCO->currentIndex()) {
2908 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2911 HSpace indent = HSpace(
2912 widgetsToLength(textLayoutModule->indentLE,
2913 textLayoutModule->indentLengthCO)
2915 bp_.setIndentation(indent);
2919 // this should never happen
2920 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2924 // if paragraphs are separated by a skip
2925 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2926 switch (textLayoutModule->skipCO->currentIndex()) {
2928 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2931 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2934 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2939 widgetsToLength(textLayoutModule->skipLE,
2940 textLayoutModule->skipLengthCO)
2946 // this should never happen
2947 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2953 fromqstr(latexModule->optionsLE->text());
2955 bp_.use_default_options =
2956 latexModule->defaultOptionsCB->isChecked();
2958 if (latexModule->childDocGB->isChecked())
2960 fromqstr(latexModule->childDocLE->text());
2962 bp_.master = string();
2965 bp_.clearIncludedChildren();
2966 if (masterChildModule->includeonlyRB->isChecked()) {
2967 list<string>::const_iterator it = includeonlys_.begin();
2968 for (; it != includeonlys_.end() ; ++it) {
2969 bp_.addIncludedChildren(*it);
2972 bp_.maintain_unincluded_children =
2973 masterChildModule->maintainAuxCB->isChecked();
2976 bp_.float_placement = floatModule->get();
2979 // text should have passed validation
2980 bp_.listings_params =
2981 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2984 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2985 outputModule->defaultFormatCO->currentIndex()).toString());
2987 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2988 bp_.useNonTeXFonts = nontexfonts;
2990 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2992 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2994 int mathfmt = outputModule->mathoutCB->currentIndex();
2997 BufferParams::MathOutput const mo =
2998 static_cast<BufferParams::MathOutput>(mathfmt);
2999 bp_.html_math_output = mo;
3000 bp_.html_be_strict = outputModule->strictCB->isChecked();
3001 bp_.html_css_as_file = outputModule->cssCB->isChecked();
3002 bp_.html_math_img_scale = outputModule->mathimgSB->value();
3003 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
3005 bp_.save_transient_properties =
3006 outputModule->saveTransientPropertiesCB->isChecked();
3009 bp_.fonts_roman[nontexfonts] =
3010 fromqstr(fontModule->fontsRomanCO->
3011 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
3012 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
3014 bp_.fonts_sans[nontexfonts] =
3015 fromqstr(fontModule->fontsSansCO->
3016 itemData(fontModule->fontsSansCO->currentIndex()).toString());
3017 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
3019 bp_.fonts_typewriter[nontexfonts] =
3020 fromqstr(fontModule->fontsTypewriterCO->
3021 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
3022 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
3024 bp_.fonts_math[nontexfonts] =
3025 fromqstr(fontModule->fontsMathCO->
3026 itemData(fontModule->fontsMathCO->currentIndex()).toString());
3027 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
3029 QString const fontenc =
3030 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
3031 if (fontenc == "custom")
3032 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
3034 bp_.fontenc = fromqstr(fontenc);
3037 fromqstr(fontModule->cjkFontLE->text());
3039 bp_.use_microtype = fontModule->microtypeCB->isChecked();
3041 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
3042 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
3044 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
3045 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
3047 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
3049 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
3052 bp_.fonts_default_family = "default";
3054 bp_.fonts_default_family = GuiDocument::fontfamilies[
3055 fontModule->fontsDefaultCO->currentIndex()];
3057 if (fontModule->fontsizeCO->currentIndex() == 0)
3058 bp_.fontsize = "default";
3061 fromqstr(fontModule->fontsizeCO->currentText());
3064 bp_.papersize = PAPER_SIZE(
3065 pageLayoutModule->papersizeCO->currentIndex());
3067 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
3068 pageLayoutModule->paperwidthUnitCO);
3070 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
3071 pageLayoutModule->paperheightUnitCO);
3073 if (pageLayoutModule->facingPagesCB->isChecked())
3074 bp_.sides = TwoSides;
3076 bp_.sides = OneSide;
3078 if (pageLayoutModule->landscapeRB->isChecked())
3079 bp_.orientation = ORIENTATION_LANDSCAPE;
3081 bp_.orientation = ORIENTATION_PORTRAIT;
3084 bp_.use_geometry = !marginsModule->marginCB->isChecked();
3086 Ui::MarginsUi const * m = marginsModule;
3088 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
3089 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
3090 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3091 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3092 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3093 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3094 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3095 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3098 branchesModule->apply(bp_);
3101 PDFOptions & pdf = bp_.pdfoptions();
3102 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3103 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3104 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3105 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3106 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3108 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3109 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3110 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3111 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3113 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3114 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3115 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3116 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3118 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3119 if (pdfSupportModule->fullscreenCB->isChecked())
3120 pdf.pagemode = pdf.pagemode_fullscreen;
3122 pdf.pagemode.clear();
3123 pdf.quoted_options = pdf.quoted_options_check(
3124 fromqstr(pdfSupportModule->optionsLE->text()));
3127 nonModuleChanged_ = false;
3131 void GuiDocument::paramsToDialog()
3133 // set the default unit
3134 Length::UNIT const default_unit = Length::defaultUnit();
3137 preambleModule->update(bp_, id());
3138 localLayout->update(bp_, id());
3141 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3142 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3145 string const cite_engine = bp_.citeEngine().list().front();
3147 biblioModule->citeEngineCO->setCurrentIndex(
3148 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3150 updateEngineType(documentClass().opt_enginetype(),
3151 bp_.citeEngineType());
3153 biblioModule->citeStyleCO->setCurrentIndex(
3154 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3156 biblioModule->bibtopicCB->setChecked(
3159 updateEngineDependends();
3162 updateDefaultBiblio(bp_.biblatex_bibstyle, "bbx");
3163 updateDefaultBiblio(bp_.biblatex_citestyle, "cbx");
3165 updateDefaultBiblio(bp_.defaultBiblioStyle());
3167 biblioModule->citePackageOptionsLE->setText(toqstr(bp_.biblio_opts));
3171 split(bp_.bibtex_command, command, ' ');
3173 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3175 biblioModule->bibtexCO->setCurrentIndex(bpos);
3176 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3178 // We reset to default if we do not know the specified compiler
3179 // This is for security reasons
3180 biblioModule->bibtexCO->setCurrentIndex(
3181 biblioModule->bibtexCO->findData(toqstr("default")));
3182 biblioModule->bibtexOptionsLE->clear();
3184 biblioModule->bibtexOptionsLE->setEnabled(
3185 biblioModule->bibtexCO->currentIndex() != 0);
3187 biblioChanged_ = false;
3190 // We may be called when there is no Buffer, e.g., when
3191 // the last view has just been closed.
3192 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3193 indicesModule->update(bp_, isReadOnly);
3195 // language & quotes
3196 int const pos = langModule->languageCO->findData(toqstr(
3197 bp_.language->lang()));
3198 langModule->languageCO->setCurrentIndex(pos);
3200 updateQuoteStyles();
3202 langModule->quoteStyleCO->setCurrentIndex(
3203 langModule->quoteStyleCO->findData(bp_.quotes_style));
3204 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3206 bool default_enc = true;
3207 if (bp_.inputenc != "auto") {
3208 default_enc = false;
3209 if (bp_.inputenc == "default") {
3210 langModule->encodingCO->setCurrentIndex(0);
3213 Encodings::const_iterator it = encodings.begin();
3214 Encodings::const_iterator const end = encodings.end();
3215 for (; it != end; ++it) {
3216 if (it->name() == bp_.inputenc &&
3218 enc_gui = it->guiName();
3222 int const i = langModule->encodingCO->findText(
3225 langModule->encodingCO->setCurrentIndex(i);
3227 // unknown encoding. Set to default.
3231 langModule->defaultencodingRB->setChecked(default_enc);
3232 langModule->otherencodingRB->setChecked(!default_enc);
3234 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3236 langModule->languagePackageCO->setCurrentIndex(
3237 langModule->languagePackageCO->findData("custom"));
3238 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3240 langModule->languagePackageCO->setCurrentIndex(p);
3241 langModule->languagePackageLE->clear();
3245 if (bp_.isfontcolor) {
3246 colorModule->fontColorPB->setStyleSheet(
3247 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3249 set_fontcolor = bp_.fontcolor;
3250 is_fontcolor = bp_.isfontcolor;
3252 colorModule->noteFontColorPB->setStyleSheet(
3253 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3254 set_notefontcolor = bp_.notefontcolor;
3256 if (bp_.isbackgroundcolor) {
3257 colorModule->backgroundPB->setStyleSheet(
3258 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3260 set_backgroundcolor = bp_.backgroundcolor;
3261 is_backgroundcolor = bp_.isbackgroundcolor;
3263 colorModule->boxBackgroundPB->setStyleSheet(
3264 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3265 set_boxbgcolor = bp_.boxbgcolor;
3268 int const min_toclevel = documentClass().min_toclevel();
3269 int const max_toclevel = documentClass().max_toclevel();
3270 if (documentClass().hasTocLevels()) {
3271 numberingModule->setEnabled(true);
3272 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3273 numberingModule->depthSL->setMaximum(max_toclevel);
3274 numberingModule->depthSL->setValue(bp_.secnumdepth);
3275 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3276 numberingModule->tocSL->setMaximum(max_toclevel);
3277 numberingModule->tocSL->setValue(bp_.tocdepth);
3280 numberingModule->setEnabled(false);
3281 numberingModule->tocTW->clear();
3285 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3286 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3287 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3288 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3289 bulletsModule->init();
3292 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3294 latexModule->psdriverCO->setCurrentIndex(nitem);
3297 map<string, string> const & packages = BufferParams::auto_packages();
3298 for (map<string, string>::const_iterator it = packages.begin();
3299 it != packages.end(); ++it) {
3300 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3303 int row = mathsModule->packagesTW->row(item);
3304 switch (bp_.use_package(it->first)) {
3305 case BufferParams::package_off: {
3306 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3307 rb->setChecked(true);
3310 case BufferParams::package_on: {
3311 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3312 rb->setChecked(true);
3315 case BufferParams::package_auto: {
3316 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3317 rb->setChecked(true);
3323 switch (bp_.spacing().getSpace()) {
3324 case Spacing::Other: nitem = 3; break;
3325 case Spacing::Double: nitem = 2; break;
3326 case Spacing::Onehalf: nitem = 1; break;
3327 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3331 string const & layoutID = bp_.baseClassID();
3332 setLayoutComboByIDString(layoutID);
3334 updatePagestyle(documentClass().opt_pagestyle(),
3337 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3338 if (bp_.spacing().getSpace() == Spacing::Other) {
3339 doubleToWidget(textLayoutModule->lspacingLE,
3340 bp_.spacing().getValueAsString());
3344 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3345 textLayoutModule->indentRB->setChecked(true);
3346 string indentation = bp_.getIndentation().asLyXCommand();
3348 if (indentation != "default") {
3349 lengthToWidgets(textLayoutModule->indentLE,
3350 textLayoutModule->indentLengthCO,
3351 indentation, default_unit);
3354 textLayoutModule->indentCO->setCurrentIndex(indent);
3357 textLayoutModule->skipRB->setChecked(true);
3359 switch (bp_.getDefSkip().kind()) {
3360 case VSpace::SMALLSKIP:
3363 case VSpace::MEDSKIP:
3366 case VSpace::BIGSKIP:
3369 case VSpace::LENGTH:
3372 string const length = bp_.getDefSkip().asLyXCommand();
3373 lengthToWidgets(textLayoutModule->skipLE,
3374 textLayoutModule->skipLengthCO,
3375 length, default_unit);
3382 textLayoutModule->skipCO->setCurrentIndex(skip);
3386 textLayoutModule->twoColumnCB->setChecked(
3388 textLayoutModule->justCB->setChecked(bp_.justification);
3390 if (!bp_.options.empty()) {
3391 latexModule->optionsLE->setText(
3392 toqstr(bp_.options));
3394 latexModule->optionsLE->setText(QString());
3398 latexModule->defaultOptionsCB->setChecked(
3399 bp_.use_default_options);
3400 updateSelectedModules();
3401 selectionManager->updateProvidedModules(
3402 bp_.baseClass()->providedModules());
3403 selectionManager->updateExcludedModules(
3404 bp_.baseClass()->excludedModules());
3406 if (!documentClass().options().empty()) {
3407 latexModule->defaultOptionsLE->setText(
3408 toqstr(documentClass().options()));
3410 latexModule->defaultOptionsLE->setText(
3411 toqstr(_("[No options predefined]")));
3414 latexModule->defaultOptionsLE->setEnabled(
3415 bp_.use_default_options
3416 && !documentClass().options().empty());
3418 latexModule->defaultOptionsCB->setEnabled(
3419 !documentClass().options().empty());
3421 if (!bp_.master.empty()) {
3422 latexModule->childDocGB->setChecked(true);
3423 latexModule->childDocLE->setText(
3424 toqstr(bp_.master));
3426 latexModule->childDocLE->setText(QString());
3427 latexModule->childDocGB->setChecked(false);
3431 if (!bufferview() || !buffer().hasChildren()) {
3432 masterChildModule->childrenTW->clear();
3433 includeonlys_.clear();
3434 docPS->showPanel("Child Documents", false);
3435 if (docPS->isCurrentPanel("Child Documents"))
3436 docPS->setCurrentPanel("Document Class");
3438 docPS->showPanel("Child Documents", true);
3439 masterChildModule->setEnabled(true);
3440 includeonlys_ = bp_.getIncludedChildren();
3441 updateIncludeonlys();
3443 masterChildModule->maintainAuxCB->setChecked(
3444 bp_.maintain_unincluded_children);
3447 floatModule->set(bp_.float_placement);
3450 // break listings_params to multiple lines
3452 InsetListingsParams(bp_.listings_params).separatedParams();
3453 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3456 // some languages only work with polyglossia/XeTeX
3457 Language const * lang = lyx::languages.getLanguage(
3458 fromqstr(langModule->languageCO->itemData(
3459 langModule->languageCO->currentIndex()).toString()));
3460 bool const need_fontspec =
3461 lang->babel().empty() && !lang->polyglossia().empty();
3462 bool const os_fonts_available =
3463 bp_.baseClass()->outputType() == lyx::LATEX
3464 && LaTeXFeatures::isAvailable("fontspec");
3465 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3466 fontModule->osFontsCB->setChecked(
3467 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3468 updateFontsize(documentClass().opt_fontsize(),
3471 QString font = toqstr(bp_.fontsRoman());
3472 int rpos = fontModule->fontsRomanCO->findData(font);
3474 rpos = fontModule->fontsRomanCO->count();
3475 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3477 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3478 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3480 font = toqstr(bp_.fontsSans());
3481 int spos = fontModule->fontsSansCO->findData(font);
3483 spos = fontModule->fontsSansCO->count();
3484 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3486 fontModule->fontsSansCO->setCurrentIndex(spos);
3487 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3489 font = toqstr(bp_.fontsTypewriter());
3490 int tpos = fontModule->fontsTypewriterCO->findData(font);
3492 tpos = fontModule->fontsTypewriterCO->count();
3493 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3495 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3496 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3498 font = toqstr(bp_.fontsMath());
3499 int mpos = fontModule->fontsMathCO->findData(font);
3501 mpos = fontModule->fontsMathCO->count();
3502 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3504 fontModule->fontsMathCO->setCurrentIndex(mpos);
3505 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3507 if (bp_.useNonTeXFonts && os_fonts_available) {
3508 fontModule->fontencLA->setEnabled(false);
3509 fontModule->fontencCO->setEnabled(false);
3510 fontModule->fontencLE->setEnabled(false);
3512 fontModule->fontencLA->setEnabled(true);
3513 fontModule->fontencCO->setEnabled(true);
3514 fontModule->fontencLE->setEnabled(true);
3520 if (!bp_.fonts_cjk.empty())
3521 fontModule->cjkFontLE->setText(
3522 toqstr(bp_.fonts_cjk));
3524 fontModule->cjkFontLE->setText(QString());
3526 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3528 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3529 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3530 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3531 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3532 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3533 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3535 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3537 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3539 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3540 fontModule->fontencCO->setCurrentIndex(
3541 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3542 fontModule->fontencLE->setEnabled(false);
3544 fontModule->fontencCO->setCurrentIndex(1);
3545 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3549 // This must be set _after_ fonts since updateDefaultFormat()
3550 // checks osFontsCB settings.
3551 // update combobox with formats
3552 updateDefaultFormat();
3553 int index = outputModule->defaultFormatCO->findData(toqstr(
3554 bp_.default_output_format));
3555 // set to default if format is not found
3558 outputModule->defaultFormatCO->setCurrentIndex(index);
3560 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3561 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3563 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3564 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3565 outputModule->strictCB->setChecked(bp_.html_be_strict);
3566 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3568 outputModule->saveTransientPropertiesCB
3569 ->setChecked(bp_.save_transient_properties);
3572 bool const extern_geometry =
3573 documentClass().provides("geometry");
3574 int const psize = bp_.papersize;
3575 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3576 setCustomPapersize(!extern_geometry && psize == 1);
3577 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3579 bool const landscape =
3580 bp_.orientation == ORIENTATION_LANDSCAPE;
3581 pageLayoutModule->landscapeRB->setChecked(landscape);
3582 pageLayoutModule->portraitRB->setChecked(!landscape);
3583 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3584 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3586 pageLayoutModule->facingPagesCB->setChecked(
3587 bp_.sides == TwoSides);
3589 lengthToWidgets(pageLayoutModule->paperwidthLE,
3590 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3591 lengthToWidgets(pageLayoutModule->paperheightLE,
3592 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3595 Ui::MarginsUi * m = marginsModule;
3599 lengthToWidgets(m->topLE, m->topUnit,
3600 bp_.topmargin, default_unit);
3602 lengthToWidgets(m->bottomLE, m->bottomUnit,
3603 bp_.bottommargin, default_unit);
3605 lengthToWidgets(m->innerLE, m->innerUnit,
3606 bp_.leftmargin, default_unit);
3608 lengthToWidgets(m->outerLE, m->outerUnit,
3609 bp_.rightmargin, default_unit);
3611 lengthToWidgets(m->headheightLE, m->headheightUnit,
3612 bp_.headheight, default_unit);
3614 lengthToWidgets(m->headsepLE, m->headsepUnit,
3615 bp_.headsep, default_unit);
3617 lengthToWidgets(m->footskipLE, m->footskipUnit,
3618 bp_.footskip, default_unit);
3620 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3621 bp_.columnsep, default_unit);
3624 updateUnknownBranches();
3625 branchesModule->update(bp_);
3628 PDFOptions const & pdf = bp_.pdfoptions();
3629 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3630 if (bp_.documentClass().provides("hyperref"))
3631 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3633 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3634 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3635 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3636 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3637 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3639 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3640 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3641 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3643 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3645 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3646 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3647 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3648 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3650 nn = findToken(backref_opts, pdf.backref);
3652 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3654 pdfSupportModule->fullscreenCB->setChecked
3655 (pdf.pagemode == pdf.pagemode_fullscreen);
3657 pdfSupportModule->optionsLE->setText(
3658 toqstr(pdf.quoted_options));
3660 // Make sure that the bc is in the INITIAL state
3661 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3664 // clear changed branches cache
3665 changedBranches_.clear();
3668 nonModuleChanged_ = false;
3672 void GuiDocument::saveDocDefault()
3674 // we have to apply the params first
3680 void GuiDocument::updateAvailableModules()
3682 modules_av_model_.clear();
3683 list<modInfoStruct> modInfoList = getModuleInfo();
3684 // Sort names according to the locale
3685 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3686 return 0 < b.name.localeAwareCompare(a.name);
3689 for (modInfoStruct const & m : modInfoList) {
3690 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3696 void GuiDocument::updateSelectedModules()
3698 modules_sel_model_.clear();
3699 list<modInfoStruct> const selModList = getSelectedModules();
3701 for (modInfoStruct const & m : selModList) {
3702 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3708 void GuiDocument::updateIncludeonlys()
3710 masterChildModule->childrenTW->clear();
3711 QString const no = qt_("No");
3712 QString const yes = qt_("Yes");
3714 if (includeonlys_.empty()) {
3715 masterChildModule->includeallRB->setChecked(true);
3716 masterChildModule->childrenTW->setEnabled(false);
3717 masterChildModule->maintainAuxCB->setEnabled(false);
3719 masterChildModule->includeonlyRB->setChecked(true);
3720 masterChildModule->childrenTW->setEnabled(true);
3721 masterChildModule->maintainAuxCB->setEnabled(true);
3723 ListOfBuffers children = buffer().getChildren();
3724 ListOfBuffers::const_iterator it = children.begin();
3725 ListOfBuffers::const_iterator end = children.end();
3726 bool has_unincluded = false;
3727 bool all_unincluded = true;
3728 for (; it != end; ++it) {
3729 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3732 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3733 from_utf8(buffer().filePath())));
3734 item->setText(0, toqstr(name));
3735 item->setText(1, isChildIncluded(name) ? yes : no);
3736 if (!isChildIncluded(name))
3737 has_unincluded = true;
3739 all_unincluded = false;
3741 // Both if all childs are included and if none is included
3742 // is equal to "include all" (i.e., ommit \includeonly).
3743 // Thus, reset the GUI.
3744 if (!has_unincluded || all_unincluded) {
3745 masterChildModule->includeallRB->setChecked(true);
3746 masterChildModule->childrenTW->setEnabled(false);
3747 includeonlys_.clear();
3749 // If all are included, we need to update again.
3750 if (!has_unincluded)
3751 updateIncludeonlys();
3755 bool GuiDocument::isBiblatex() const
3757 QString const engine =
3758 biblioModule->citeEngineCO->itemData(
3759 biblioModule->citeEngineCO->currentIndex()).toString();
3761 return theCiteEnginesList[fromqstr(engine)]->getCiteFramework() == "biblatex";
3765 void GuiDocument::updateDefaultBiblio(string const & style,
3766 string const & which)
3768 QString const bibstyle = toqstr(style);
3769 biblioModule->defaultBiblioCO->clear();
3774 if (which != "cbx") {
3775 // First the bbx styles
3776 biblioModule->biblatexBbxCO->clear();
3777 QStringList str = texFileList("bbxFiles.lst");
3778 // test whether we have a valid list, otherwise run rescan
3779 if (str.isEmpty()) {
3780 rescanTexStyles("bbx");
3781 str = texFileList("bbxFiles.lst");
3783 for (int i = 0; i != str.size(); ++i)
3784 str[i] = onlyFileName(str[i]);
3785 // sort on filename only (no path)
3788 for (int i = 0; i != str.count(); ++i) {
3789 QString item = changeExtension(str[i], "");
3790 if (item == bibstyle)
3792 biblioModule->biblatexBbxCO->addItem(item);
3795 if (item_nr == -1 && !bibstyle.isEmpty()) {
3796 biblioModule->biblatexBbxCO->addItem(bibstyle);
3797 item_nr = biblioModule->biblatexBbxCO->count() - 1;
3801 biblioModule->biblatexBbxCO->setCurrentIndex(item_nr);
3803 biblioModule->biblatexBbxCO->clearEditText();
3806 if (which != "bbx") {
3807 // now the cbx styles
3808 biblioModule->biblatexCbxCO->clear();
3809 QStringList str = texFileList("cbxFiles.lst");
3810 // test whether we have a valid list, otherwise run rescan
3811 if (str.isEmpty()) {
3812 rescanTexStyles("cbx");
3813 str = texFileList("cbxFiles.lst");
3815 for (int i = 0; i != str.size(); ++i)
3816 str[i] = onlyFileName(str[i]);
3817 // sort on filename only (no path)
3820 for (int i = 0; i != str.count(); ++i) {
3821 QString item = changeExtension(str[i], "");
3822 if (item == bibstyle)
3824 biblioModule->biblatexCbxCO->addItem(item);
3827 if (item_nr == -1 && !bibstyle.isEmpty()) {
3828 biblioModule->biblatexCbxCO->addItem(bibstyle);
3829 item_nr = biblioModule->biblatexCbxCO->count() - 1;
3833 biblioModule->biblatexCbxCO->setCurrentIndex(item_nr);
3835 biblioModule->biblatexCbxCO->clearEditText();
3838 biblioModule->biblatexBbxCO->clear();
3839 biblioModule->biblatexCbxCO->clear();
3840 QStringList str = texFileList("bstFiles.lst");
3841 // test whether we have a valid list, otherwise run rescan
3842 if (str.isEmpty()) {
3843 rescanTexStyles("bst");
3844 str = texFileList("bstFiles.lst");
3846 for (int i = 0; i != str.size(); ++i)
3847 str[i] = onlyFileName(str[i]);
3848 // sort on filename only (no path)
3851 for (int i = 0; i != str.count(); ++i) {
3852 QString item = changeExtension(str[i], "");
3853 if (item == bibstyle)
3855 biblioModule->defaultBiblioCO->addItem(item);
3858 if (item_nr == -1 && !bibstyle.isEmpty()) {
3859 biblioModule->defaultBiblioCO->addItem(bibstyle);
3860 item_nr = biblioModule->defaultBiblioCO->count() - 1;
3864 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
3866 biblioModule->defaultBiblioCO->clearEditText();
3869 updateResetDefaultBiblio();
3873 void GuiDocument::updateResetDefaultBiblio()
3875 QString const engine =
3876 biblioModule->citeEngineCO->itemData(
3877 biblioModule->citeEngineCO->currentIndex()).toString();
3878 CiteEngineType const cet =
3879 CiteEngineType(biblioModule->citeStyleCO->itemData(
3880 biblioModule->citeStyleCO->currentIndex()).toInt());
3882 string const defbib = theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet);
3884 QString const bbx = biblioModule->biblatexBbxCO->currentText();
3885 QString const cbx = biblioModule->biblatexCbxCO->currentText();
3886 biblioModule->resetCbxPB->setEnabled(defbib != fromqstr(cbx));
3887 biblioModule->resetBbxPB->setEnabled(defbib != fromqstr(bbx));
3888 biblioModule->matchBbxPB->setEnabled(bbx != cbx && !cbx.isEmpty()
3889 && biblioModule->biblatexBbxCO->findText(cbx) != -1);
3891 biblioModule->resetDefaultBiblioPB->setEnabled(
3892 defbib != fromqstr(biblioModule->defaultBiblioCO->currentText()));
3896 void GuiDocument::matchBiblatexStyles()
3898 updateDefaultBiblio(fromqstr(biblioModule->biblatexCbxCO->currentText()), "bbx");
3903 void GuiDocument::updateContents()
3905 // Nothing to do here as the document settings is not cursor dependant.
3910 void GuiDocument::useClassDefaults()
3912 if (applyPB->isEnabled()) {
3913 int const ret = Alert::prompt(_("Unapplied changes"),
3914 _("Some changes in the dialog were not yet applied.\n"
3915 "If you do not apply now, they will be lost after this action."),
3916 1, 1, _("&Apply"), _("&Dismiss"));
3921 int idx = latexModule->classCO->currentIndex();
3922 string const classname = fromqstr(latexModule->classCO->getData(idx));
3923 if (!bp_.setBaseClass(classname)) {
3924 Alert::error(_("Error"), _("Unable to set document class."));
3927 bp_.useClassDefaults();
3932 void GuiDocument::setLayoutComboByIDString(string const & idString)
3934 if (!latexModule->classCO->set(toqstr(idString)))
3935 Alert::warning(_("Can't set layout!"),
3936 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3940 bool GuiDocument::isValid()
3943 validateListingsParameters().isEmpty() &&
3944 localLayout->isValid() &&
3946 // if we're asking for skips between paragraphs
3947 !textLayoutModule->skipRB->isChecked() ||
3948 // then either we haven't chosen custom
3949 textLayoutModule->skipCO->currentIndex() != 3 ||
3950 // or else a length has been given
3951 !textLayoutModule->skipLE->text().isEmpty()
3954 // if we're asking for indentation
3955 !textLayoutModule->indentRB->isChecked() ||
3956 // then either we haven't chosen custom
3957 textLayoutModule->indentCO->currentIndex() != 1 ||
3958 // or else a length has been given
3959 !textLayoutModule->indentLE->text().isEmpty()
3964 char const * const GuiDocument::fontfamilies[5] = {
3965 "default", "rmdefault", "sfdefault", "ttdefault", ""
3969 char const * GuiDocument::fontfamilies_gui[5] = {
3970 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3974 bool GuiDocument::initialiseParams(string const &)
3976 BufferView const * view = bufferview();
3978 bp_ = BufferParams();
3982 bp_ = view->buffer().params();
3984 updateAvailableModules();
3985 //FIXME It'd be nice to make sure here that the selected
3986 //modules are consistent: That required modules are actually
3987 //selected, and that we don't have conflicts. If so, we could
3988 //at least pop up a warning.
3994 void GuiDocument::clearParams()
3996 bp_ = BufferParams();
4000 BufferId GuiDocument::id() const
4002 BufferView const * const view = bufferview();
4003 return view? &view->buffer() : 0;
4007 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
4009 return moduleNames_;
4013 list<GuiDocument::modInfoStruct> const
4014 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
4016 list<modInfoStruct> mInfo;
4017 for (string const & name : mods) {
4019 LyXModule const * const mod = theModuleList[name];
4024 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
4032 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
4034 return makeModuleInfo(params().getModules());
4038 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
4040 return makeModuleInfo(params().baseClass()->providedModules());
4044 DocumentClass const & GuiDocument::documentClass() const
4046 return bp_.documentClass();
4050 static void dispatch_bufferparams(Dialog const & dialog,
4051 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
4054 ss << "\\begin_header\n";
4055 bp.writeFile(ss, buf);
4056 ss << "\\end_header\n";
4057 dialog.dispatch(FuncRequest(lfun, ss.str()));
4061 void GuiDocument::dispatchParams()
4063 // We need a non-const buffer object.
4064 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
4065 // There may be several undo records; group them (bug #8998)
4066 buf.undo().beginUndoGroup();
4068 // This must come first so that a language change is correctly noticed
4071 // Apply the BufferParams. Note that this will set the base class
4072 // and then update the buffer's layout.
4073 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
4075 if (!params().master.empty()) {
4076 FileName const master_file = support::makeAbsPath(params().master,
4077 support::onlyPath(buffer().absFileName()));
4078 if (isLyXFileName(master_file.absFileName())) {
4079 Buffer * master = checkAndLoadLyXFile(master_file);
4081 if (master->isChild(const_cast<Buffer *>(&buffer())))
4082 const_cast<Buffer &>(buffer()).setParent(master);
4084 Alert::warning(_("Assigned master does not include this file"),
4085 bformat(_("You must include this file in the document\n"
4086 "'%1$s' in order to use the master document\n"
4087 "feature."), from_utf8(params().master)));
4089 Alert::warning(_("Could not load master"),
4090 bformat(_("The master document '%1$s'\n"
4091 "could not be loaded."),
4092 from_utf8(params().master)));
4096 // Generate the colours requested by each new branch.
4097 BranchList & branchlist = params().branchlist();
4098 if (!branchlist.empty()) {
4099 BranchList::const_iterator it = branchlist.begin();
4100 BranchList::const_iterator const end = branchlist.end();
4101 for (; it != end; ++it) {
4102 docstring const & current_branch = it->branch();
4103 Branch const * branch = branchlist.find(current_branch);
4104 string const x11hexname = X11hexname(branch->color());
4105 // display the new color
4106 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
4107 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4110 // Open insets of selected branches, close deselected ones
4111 dispatch(FuncRequest(LFUN_INSET_FORALL,
4112 "Branch inset-toggle assign"));
4114 // rename branches in the document
4115 executeBranchRenaming();
4116 // and clear changed branches cache
4117 changedBranches_.clear();
4119 // Generate the colours requested by indices.
4120 IndicesList & indiceslist = params().indiceslist();
4121 if (!indiceslist.empty()) {
4122 IndicesList::const_iterator it = indiceslist.begin();
4123 IndicesList::const_iterator const end = indiceslist.end();
4124 for (; it != end; ++it) {
4125 docstring const & current_index = it->shortcut();
4126 Index const * index = indiceslist.findShortcut(current_index);
4127 string const x11hexname = X11hexname(index->color());
4128 // display the new color
4129 docstring const str = current_index + ' ' + from_ascii(x11hexname);
4130 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4134 // If we used an LFUN, we would not need these two lines:
4135 BufferView * bv = const_cast<BufferView *>(bufferview());
4136 bv->processUpdateFlags(Update::Force | Update::FitCursor);
4138 // Don't forget to close the group. Note that it is important
4139 // to check that there is no early return in the method.
4140 buf.undo().endUndoGroup();
4144 void GuiDocument::setLanguage() const
4146 Language const * const newL = bp_.language;
4147 if (buffer().params().language == newL)
4150 string const & lang_name = newL->lang();
4151 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
4155 void GuiDocument::saveAsDefault() const
4157 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
4161 bool GuiDocument::providesOSF(QString const & font) const
4163 if (fontModule->osFontsCB->isChecked())
4164 // FIXME: we should check if the fonts really
4165 // have OSF support. But how?
4167 return theLaTeXFonts().getLaTeXFont(
4168 qstring_to_ucs4(font)).providesOSF(ot1(),
4174 bool GuiDocument::providesSC(QString const & font) const
4176 if (fontModule->osFontsCB->isChecked())
4178 return theLaTeXFonts().getLaTeXFont(
4179 qstring_to_ucs4(font)).providesSC(ot1(),
4185 bool GuiDocument::providesScale(QString const & font) const
4187 if (fontModule->osFontsCB->isChecked())
4189 return theLaTeXFonts().getLaTeXFont(
4190 qstring_to_ucs4(font)).providesScale(ot1(),
4196 bool GuiDocument::providesNoMath(QString const & font) const
4198 if (fontModule->osFontsCB->isChecked())
4200 return theLaTeXFonts().getLaTeXFont(
4201 qstring_to_ucs4(font)).providesNoMath(ot1(),
4206 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4208 if (fontModule->osFontsCB->isChecked())
4210 return theLaTeXFonts().getLaTeXFont(
4211 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4218 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4220 // FIXME Unicode: docstrings would be better for these parameters but this
4221 // change requires a lot of others
4224 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4225 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4226 // Find the first sentence of the description
4227 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4228 int pos = bf.toNextBoundary();
4231 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4232 // Tooltip is the desc followed by the module name
4233 m.description = QString("%1<i>%2</i>")
4234 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4240 void GuiDocument::loadModuleInfo()
4242 moduleNames_.clear();
4243 for (LyXModule const & mod : theModuleList)
4244 if (mod.category().substr(0, 8) != "Citation")
4245 moduleNames_.push_back(modInfo(mod));
4249 void GuiDocument::updateUnknownBranches()
4253 list<docstring> used_branches;
4254 buffer().getUsedBranches(used_branches);
4255 list<docstring>::const_iterator it = used_branches.begin();
4256 QStringList unknown_branches;
4257 for (; it != used_branches.end() ; ++it) {
4258 if (!buffer().params().branchlist().find(*it))
4259 unknown_branches.append(toqstr(*it));
4261 branchesModule->setUnknownBranches(unknown_branches);
4265 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4267 map<docstring, docstring>::iterator it = changedBranches_.begin();
4268 for (; it != changedBranches_.end() ; ++it) {
4269 if (it->second == oldname) {
4270 // branch has already been renamed
4271 it->second = newname;
4276 changedBranches_[oldname] = newname;
4280 void GuiDocument::executeBranchRenaming() const
4282 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4283 for (; it != changedBranches_.end() ; ++it) {
4284 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4285 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4290 void GuiDocument::allPackagesAuto()
4296 void GuiDocument::allPackagesAlways()
4302 void GuiDocument::allPackagesNot()
4308 void GuiDocument::allPackages(int col)
4310 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4311 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4312 rb->setChecked(true);
4317 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4320 } // namespace frontend
4323 #include "moc_GuiDocument.cpp"