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);
2729 bp_.bibtopic(biblioModule->bibtopicCB->isChecked());
2731 bp_.setDefaultBiblioStyle(fromqstr(biblioModule->defaultBiblioCO->currentText()));
2733 bp_.biblatex_bibstyle = fromqstr(biblioModule->biblatexBbxCO->currentText());
2734 bp_.biblatex_citestyle = fromqstr(biblioModule->biblatexCbxCO->currentText());
2735 bp_.biblio_opts = fromqstr(biblioModule->citePackageOptionsLE->text());
2737 string const bibtex_command =
2738 fromqstr(biblioModule->bibtexCO->itemData(
2739 biblioModule->bibtexCO->currentIndex()).toString());
2740 string const bibtex_options =
2741 fromqstr(biblioModule->bibtexOptionsLE->text());
2742 if (bibtex_command == "default" || bibtex_options.empty())
2743 bp_.bibtex_command = bibtex_command;
2745 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2747 if (biblioChanged_) {
2748 buffer().invalidateBibinfoCache();
2749 buffer().removeBiblioTempFiles();
2753 indicesModule->apply(bp_);
2755 // language & quotes
2756 if (langModule->defaultencodingRB->isChecked()) {
2757 bp_.inputenc = "auto";
2759 int i = langModule->encodingCO->currentIndex();
2761 bp_.inputenc = "default";
2763 QString const enc_gui =
2764 langModule->encodingCO->currentText();
2765 Encodings::const_iterator it = encodings.begin();
2766 Encodings::const_iterator const end = encodings.end();
2768 for (; it != end; ++it) {
2769 if (qt_(it->guiName()) == enc_gui &&
2771 bp_.inputenc = it->name();
2777 // should not happen
2778 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2779 bp_.inputenc = "default";
2784 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2785 langModule->quoteStyleCO->currentIndex()).toInt();
2786 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2788 QString const langname = langModule->languageCO->itemData(
2789 langModule->languageCO->currentIndex()).toString();
2790 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2791 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2792 // If current cursor language was the document language, then update it too.
2793 if (cur.current_font.language() == bp_.language) {
2794 cur.current_font.setLanguage(newlang);
2795 cur.real_current_font.setLanguage(newlang);
2797 bp_.language = newlang;
2799 QString const pack = langModule->languagePackageCO->itemData(
2800 langModule->languagePackageCO->currentIndex()).toString();
2801 if (pack == "custom")
2803 fromqstr(langModule->languagePackageLE->text());
2805 bp_.lang_package = fromqstr(pack);
2808 bp_.backgroundcolor = set_backgroundcolor;
2809 bp_.isbackgroundcolor = is_backgroundcolor;
2810 bp_.fontcolor = set_fontcolor;
2811 bp_.isfontcolor = is_fontcolor;
2812 bp_.notefontcolor = set_notefontcolor;
2813 bp_.boxbgcolor = set_boxbgcolor;
2816 if (bp_.documentClass().hasTocLevels()) {
2817 bp_.tocdepth = numberingModule->tocSL->value();
2818 bp_.secnumdepth = numberingModule->depthSL->value();
2822 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2823 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2824 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2825 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2828 bp_.graphics_driver =
2829 tex_graphics[latexModule->psdriverCO->currentIndex()];
2832 int idx = latexModule->classCO->currentIndex();
2834 string const classname = fromqstr(latexModule->classCO->getData(idx));
2835 bp_.setBaseClass(classname);
2839 modulesToParams(bp_);
2842 map<string, string> const & packages = BufferParams::auto_packages();
2843 for (map<string, string>::const_iterator it = packages.begin();
2844 it != packages.end(); ++it) {
2845 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2848 int row = mathsModule->packagesTW->row(item);
2849 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2850 if (rb->isChecked()) {
2851 bp_.use_package(it->first, BufferParams::package_auto);
2854 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2855 if (rb->isChecked()) {
2856 bp_.use_package(it->first, BufferParams::package_on);
2859 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2860 if (rb->isChecked())
2861 bp_.use_package(it->first, BufferParams::package_off);
2865 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2866 bp_.pagestyle = "default";
2868 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2869 for (size_t i = 0; i != pagestyles.size(); ++i)
2870 if (pagestyles[i].second == style_gui)
2871 bp_.pagestyle = pagestyles[i].first;
2875 switch (textLayoutModule->lspacingCO->currentIndex()) {
2877 bp_.spacing().set(Spacing::Single);
2880 bp_.spacing().set(Spacing::Onehalf);
2883 bp_.spacing().set(Spacing::Double);
2886 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2888 bp_.spacing().set(Spacing::Single);
2890 bp_.spacing().set(Spacing::Other, s);
2895 if (textLayoutModule->twoColumnCB->isChecked())
2900 bp_.justification = textLayoutModule->justCB->isChecked();
2902 if (textLayoutModule->indentRB->isChecked()) {
2903 // if paragraphs are separated by an indentation
2904 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2905 switch (textLayoutModule->indentCO->currentIndex()) {
2907 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2910 HSpace indent = HSpace(
2911 widgetsToLength(textLayoutModule->indentLE,
2912 textLayoutModule->indentLengthCO)
2914 bp_.setIndentation(indent);
2918 // this should never happen
2919 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2923 // if paragraphs are separated by a skip
2924 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2925 switch (textLayoutModule->skipCO->currentIndex()) {
2927 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2930 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2933 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2938 widgetsToLength(textLayoutModule->skipLE,
2939 textLayoutModule->skipLengthCO)
2945 // this should never happen
2946 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2952 fromqstr(latexModule->optionsLE->text());
2954 bp_.use_default_options =
2955 latexModule->defaultOptionsCB->isChecked();
2957 if (latexModule->childDocGB->isChecked())
2959 fromqstr(latexModule->childDocLE->text());
2961 bp_.master = string();
2964 bp_.clearIncludedChildren();
2965 if (masterChildModule->includeonlyRB->isChecked()) {
2966 list<string>::const_iterator it = includeonlys_.begin();
2967 for (; it != includeonlys_.end() ; ++it) {
2968 bp_.addIncludedChildren(*it);
2971 bp_.maintain_unincluded_children =
2972 masterChildModule->maintainAuxCB->isChecked();
2975 bp_.float_placement = floatModule->get();
2978 // text should have passed validation
2979 bp_.listings_params =
2980 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2983 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2984 outputModule->defaultFormatCO->currentIndex()).toString());
2986 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2987 bp_.useNonTeXFonts = nontexfonts;
2989 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2991 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2993 int mathfmt = outputModule->mathoutCB->currentIndex();
2996 BufferParams::MathOutput const mo =
2997 static_cast<BufferParams::MathOutput>(mathfmt);
2998 bp_.html_math_output = mo;
2999 bp_.html_be_strict = outputModule->strictCB->isChecked();
3000 bp_.html_css_as_file = outputModule->cssCB->isChecked();
3001 bp_.html_math_img_scale = outputModule->mathimgSB->value();
3002 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
3004 bp_.save_transient_properties =
3005 outputModule->saveTransientPropertiesCB->isChecked();
3008 bp_.fonts_roman[nontexfonts] =
3009 fromqstr(fontModule->fontsRomanCO->
3010 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
3011 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
3013 bp_.fonts_sans[nontexfonts] =
3014 fromqstr(fontModule->fontsSansCO->
3015 itemData(fontModule->fontsSansCO->currentIndex()).toString());
3016 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
3018 bp_.fonts_typewriter[nontexfonts] =
3019 fromqstr(fontModule->fontsTypewriterCO->
3020 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
3021 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
3023 bp_.fonts_math[nontexfonts] =
3024 fromqstr(fontModule->fontsMathCO->
3025 itemData(fontModule->fontsMathCO->currentIndex()).toString());
3026 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
3028 QString const fontenc =
3029 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
3030 if (fontenc == "custom")
3031 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
3033 bp_.fontenc = fromqstr(fontenc);
3036 fromqstr(fontModule->cjkFontLE->text());
3038 bp_.use_microtype = fontModule->microtypeCB->isChecked();
3040 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
3041 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
3043 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
3044 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
3046 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
3048 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
3051 bp_.fonts_default_family = "default";
3053 bp_.fonts_default_family = GuiDocument::fontfamilies[
3054 fontModule->fontsDefaultCO->currentIndex()];
3056 if (fontModule->fontsizeCO->currentIndex() == 0)
3057 bp_.fontsize = "default";
3060 fromqstr(fontModule->fontsizeCO->currentText());
3063 bp_.papersize = PAPER_SIZE(
3064 pageLayoutModule->papersizeCO->currentIndex());
3066 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
3067 pageLayoutModule->paperwidthUnitCO);
3069 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
3070 pageLayoutModule->paperheightUnitCO);
3072 if (pageLayoutModule->facingPagesCB->isChecked())
3073 bp_.sides = TwoSides;
3075 bp_.sides = OneSide;
3077 if (pageLayoutModule->landscapeRB->isChecked())
3078 bp_.orientation = ORIENTATION_LANDSCAPE;
3080 bp_.orientation = ORIENTATION_PORTRAIT;
3083 bp_.use_geometry = !marginsModule->marginCB->isChecked();
3085 Ui::MarginsUi const * m = marginsModule;
3087 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
3088 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
3089 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3090 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3091 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3092 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3093 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3094 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3097 branchesModule->apply(bp_);
3100 PDFOptions & pdf = bp_.pdfoptions();
3101 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3102 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3103 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3104 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3105 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3107 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3108 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3109 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3110 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3112 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3113 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3114 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3115 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3117 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3118 if (pdfSupportModule->fullscreenCB->isChecked())
3119 pdf.pagemode = pdf.pagemode_fullscreen;
3121 pdf.pagemode.clear();
3122 pdf.quoted_options = pdf.quoted_options_check(
3123 fromqstr(pdfSupportModule->optionsLE->text()));
3126 nonModuleChanged_ = false;
3130 void GuiDocument::paramsToDialog()
3132 // set the default unit
3133 Length::UNIT const default_unit = Length::defaultUnit();
3136 preambleModule->update(bp_, id());
3137 localLayout->update(bp_, id());
3140 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3141 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3144 string const cite_engine = bp_.citeEngine().list().front();
3146 biblioModule->citeEngineCO->setCurrentIndex(
3147 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3149 updateEngineType(documentClass().opt_enginetype(),
3150 bp_.citeEngineType());
3152 biblioModule->citeStyleCO->setCurrentIndex(
3153 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3155 biblioModule->bibtopicCB->setChecked(
3158 updateEngineDependends();
3161 updateDefaultBiblio(bp_.biblatex_bibstyle, "bbx");
3162 updateDefaultBiblio(bp_.biblatex_citestyle, "cbx");
3164 updateDefaultBiblio(bp_.defaultBiblioStyle());
3166 biblioModule->citePackageOptionsLE->setText(toqstr(bp_.biblio_opts));
3170 split(bp_.bibtex_command, command, ' ');
3172 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3174 biblioModule->bibtexCO->setCurrentIndex(bpos);
3175 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3177 // We reset to default if we do not know the specified compiler
3178 // This is for security reasons
3179 biblioModule->bibtexCO->setCurrentIndex(
3180 biblioModule->bibtexCO->findData(toqstr("default")));
3181 biblioModule->bibtexOptionsLE->clear();
3183 biblioModule->bibtexOptionsLE->setEnabled(
3184 biblioModule->bibtexCO->currentIndex() != 0);
3186 biblioChanged_ = false;
3189 // We may be called when there is no Buffer, e.g., when
3190 // the last view has just been closed.
3191 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3192 indicesModule->update(bp_, isReadOnly);
3194 // language & quotes
3195 int const pos = langModule->languageCO->findData(toqstr(
3196 bp_.language->lang()));
3197 langModule->languageCO->setCurrentIndex(pos);
3199 updateQuoteStyles();
3201 langModule->quoteStyleCO->setCurrentIndex(
3202 langModule->quoteStyleCO->findData(bp_.quotes_style));
3203 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3205 bool default_enc = true;
3206 if (bp_.inputenc != "auto") {
3207 default_enc = false;
3208 if (bp_.inputenc == "default") {
3209 langModule->encodingCO->setCurrentIndex(0);
3212 Encodings::const_iterator it = encodings.begin();
3213 Encodings::const_iterator const end = encodings.end();
3214 for (; it != end; ++it) {
3215 if (it->name() == bp_.inputenc &&
3217 enc_gui = it->guiName();
3221 int const i = langModule->encodingCO->findText(
3224 langModule->encodingCO->setCurrentIndex(i);
3226 // unknown encoding. Set to default.
3230 langModule->defaultencodingRB->setChecked(default_enc);
3231 langModule->otherencodingRB->setChecked(!default_enc);
3233 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3235 langModule->languagePackageCO->setCurrentIndex(
3236 langModule->languagePackageCO->findData("custom"));
3237 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3239 langModule->languagePackageCO->setCurrentIndex(p);
3240 langModule->languagePackageLE->clear();
3244 if (bp_.isfontcolor) {
3245 colorModule->fontColorPB->setStyleSheet(
3246 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3248 set_fontcolor = bp_.fontcolor;
3249 is_fontcolor = bp_.isfontcolor;
3251 colorModule->noteFontColorPB->setStyleSheet(
3252 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3253 set_notefontcolor = bp_.notefontcolor;
3255 if (bp_.isbackgroundcolor) {
3256 colorModule->backgroundPB->setStyleSheet(
3257 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3259 set_backgroundcolor = bp_.backgroundcolor;
3260 is_backgroundcolor = bp_.isbackgroundcolor;
3262 colorModule->boxBackgroundPB->setStyleSheet(
3263 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3264 set_boxbgcolor = bp_.boxbgcolor;
3267 int const min_toclevel = documentClass().min_toclevel();
3268 int const max_toclevel = documentClass().max_toclevel();
3269 if (documentClass().hasTocLevels()) {
3270 numberingModule->setEnabled(true);
3271 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3272 numberingModule->depthSL->setMaximum(max_toclevel);
3273 numberingModule->depthSL->setValue(bp_.secnumdepth);
3274 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3275 numberingModule->tocSL->setMaximum(max_toclevel);
3276 numberingModule->tocSL->setValue(bp_.tocdepth);
3279 numberingModule->setEnabled(false);
3280 numberingModule->tocTW->clear();
3284 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3285 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3286 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3287 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3288 bulletsModule->init();
3291 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3293 latexModule->psdriverCO->setCurrentIndex(nitem);
3296 map<string, string> const & packages = BufferParams::auto_packages();
3297 for (map<string, string>::const_iterator it = packages.begin();
3298 it != packages.end(); ++it) {
3299 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3302 int row = mathsModule->packagesTW->row(item);
3303 switch (bp_.use_package(it->first)) {
3304 case BufferParams::package_off: {
3305 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3306 rb->setChecked(true);
3309 case BufferParams::package_on: {
3310 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3311 rb->setChecked(true);
3314 case BufferParams::package_auto: {
3315 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3316 rb->setChecked(true);
3322 switch (bp_.spacing().getSpace()) {
3323 case Spacing::Other: nitem = 3; break;
3324 case Spacing::Double: nitem = 2; break;
3325 case Spacing::Onehalf: nitem = 1; break;
3326 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3330 string const & layoutID = bp_.baseClassID();
3331 setLayoutComboByIDString(layoutID);
3333 updatePagestyle(documentClass().opt_pagestyle(),
3336 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3337 if (bp_.spacing().getSpace() == Spacing::Other) {
3338 doubleToWidget(textLayoutModule->lspacingLE,
3339 bp_.spacing().getValueAsString());
3343 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3344 textLayoutModule->indentRB->setChecked(true);
3345 string indentation = bp_.getIndentation().asLyXCommand();
3347 if (indentation != "default") {
3348 lengthToWidgets(textLayoutModule->indentLE,
3349 textLayoutModule->indentLengthCO,
3350 indentation, default_unit);
3353 textLayoutModule->indentCO->setCurrentIndex(indent);
3356 textLayoutModule->skipRB->setChecked(true);
3358 switch (bp_.getDefSkip().kind()) {
3359 case VSpace::SMALLSKIP:
3362 case VSpace::MEDSKIP:
3365 case VSpace::BIGSKIP:
3368 case VSpace::LENGTH:
3371 string const length = bp_.getDefSkip().asLyXCommand();
3372 lengthToWidgets(textLayoutModule->skipLE,
3373 textLayoutModule->skipLengthCO,
3374 length, default_unit);
3381 textLayoutModule->skipCO->setCurrentIndex(skip);
3385 textLayoutModule->twoColumnCB->setChecked(
3387 textLayoutModule->justCB->setChecked(bp_.justification);
3389 if (!bp_.options.empty()) {
3390 latexModule->optionsLE->setText(
3391 toqstr(bp_.options));
3393 latexModule->optionsLE->setText(QString());
3397 latexModule->defaultOptionsCB->setChecked(
3398 bp_.use_default_options);
3399 updateSelectedModules();
3400 selectionManager->updateProvidedModules(
3401 bp_.baseClass()->providedModules());
3402 selectionManager->updateExcludedModules(
3403 bp_.baseClass()->excludedModules());
3405 if (!documentClass().options().empty()) {
3406 latexModule->defaultOptionsLE->setText(
3407 toqstr(documentClass().options()));
3409 latexModule->defaultOptionsLE->setText(
3410 toqstr(_("[No options predefined]")));
3413 latexModule->defaultOptionsLE->setEnabled(
3414 bp_.use_default_options
3415 && !documentClass().options().empty());
3417 latexModule->defaultOptionsCB->setEnabled(
3418 !documentClass().options().empty());
3420 if (!bp_.master.empty()) {
3421 latexModule->childDocGB->setChecked(true);
3422 latexModule->childDocLE->setText(
3423 toqstr(bp_.master));
3425 latexModule->childDocLE->setText(QString());
3426 latexModule->childDocGB->setChecked(false);
3430 if (!bufferview() || !buffer().hasChildren()) {
3431 masterChildModule->childrenTW->clear();
3432 includeonlys_.clear();
3433 docPS->showPanel("Child Documents", false);
3434 if (docPS->isCurrentPanel("Child Documents"))
3435 docPS->setCurrentPanel("Document Class");
3437 docPS->showPanel("Child Documents", true);
3438 masterChildModule->setEnabled(true);
3439 includeonlys_ = bp_.getIncludedChildren();
3440 updateIncludeonlys();
3442 masterChildModule->maintainAuxCB->setChecked(
3443 bp_.maintain_unincluded_children);
3446 floatModule->set(bp_.float_placement);
3449 // break listings_params to multiple lines
3451 InsetListingsParams(bp_.listings_params).separatedParams();
3452 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3455 // some languages only work with polyglossia/XeTeX
3456 Language const * lang = lyx::languages.getLanguage(
3457 fromqstr(langModule->languageCO->itemData(
3458 langModule->languageCO->currentIndex()).toString()));
3459 bool const need_fontspec =
3460 lang->babel().empty() && !lang->polyglossia().empty();
3461 bool const os_fonts_available =
3462 bp_.baseClass()->outputType() == lyx::LATEX
3463 && LaTeXFeatures::isAvailable("fontspec");
3464 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3465 fontModule->osFontsCB->setChecked(
3466 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3467 updateFontsize(documentClass().opt_fontsize(),
3470 QString font = toqstr(bp_.fontsRoman());
3471 int rpos = fontModule->fontsRomanCO->findData(font);
3473 rpos = fontModule->fontsRomanCO->count();
3474 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3476 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3477 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3479 font = toqstr(bp_.fontsSans());
3480 int spos = fontModule->fontsSansCO->findData(font);
3482 spos = fontModule->fontsSansCO->count();
3483 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3485 fontModule->fontsSansCO->setCurrentIndex(spos);
3486 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3488 font = toqstr(bp_.fontsTypewriter());
3489 int tpos = fontModule->fontsTypewriterCO->findData(font);
3491 tpos = fontModule->fontsTypewriterCO->count();
3492 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3494 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3495 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3497 font = toqstr(bp_.fontsMath());
3498 int mpos = fontModule->fontsMathCO->findData(font);
3500 mpos = fontModule->fontsMathCO->count();
3501 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3503 fontModule->fontsMathCO->setCurrentIndex(mpos);
3504 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3506 if (bp_.useNonTeXFonts && os_fonts_available) {
3507 fontModule->fontencLA->setEnabled(false);
3508 fontModule->fontencCO->setEnabled(false);
3509 fontModule->fontencLE->setEnabled(false);
3511 fontModule->fontencLA->setEnabled(true);
3512 fontModule->fontencCO->setEnabled(true);
3513 fontModule->fontencLE->setEnabled(true);
3519 if (!bp_.fonts_cjk.empty())
3520 fontModule->cjkFontLE->setText(
3521 toqstr(bp_.fonts_cjk));
3523 fontModule->cjkFontLE->setText(QString());
3525 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3527 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3528 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3529 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3530 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3531 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3532 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3534 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3536 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3538 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3539 fontModule->fontencCO->setCurrentIndex(
3540 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3541 fontModule->fontencLE->setEnabled(false);
3543 fontModule->fontencCO->setCurrentIndex(1);
3544 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3548 // This must be set _after_ fonts since updateDefaultFormat()
3549 // checks osFontsCB settings.
3550 // update combobox with formats
3551 updateDefaultFormat();
3552 int index = outputModule->defaultFormatCO->findData(toqstr(
3553 bp_.default_output_format));
3554 // set to default if format is not found
3557 outputModule->defaultFormatCO->setCurrentIndex(index);
3559 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3560 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3562 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3563 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3564 outputModule->strictCB->setChecked(bp_.html_be_strict);
3565 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3567 outputModule->saveTransientPropertiesCB
3568 ->setChecked(bp_.save_transient_properties);
3571 bool const extern_geometry =
3572 documentClass().provides("geometry");
3573 int const psize = bp_.papersize;
3574 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3575 setCustomPapersize(!extern_geometry && psize == 1);
3576 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3578 bool const landscape =
3579 bp_.orientation == ORIENTATION_LANDSCAPE;
3580 pageLayoutModule->landscapeRB->setChecked(landscape);
3581 pageLayoutModule->portraitRB->setChecked(!landscape);
3582 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3583 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3585 pageLayoutModule->facingPagesCB->setChecked(
3586 bp_.sides == TwoSides);
3588 lengthToWidgets(pageLayoutModule->paperwidthLE,
3589 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3590 lengthToWidgets(pageLayoutModule->paperheightLE,
3591 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3594 Ui::MarginsUi * m = marginsModule;
3598 lengthToWidgets(m->topLE, m->topUnit,
3599 bp_.topmargin, default_unit);
3601 lengthToWidgets(m->bottomLE, m->bottomUnit,
3602 bp_.bottommargin, default_unit);
3604 lengthToWidgets(m->innerLE, m->innerUnit,
3605 bp_.leftmargin, default_unit);
3607 lengthToWidgets(m->outerLE, m->outerUnit,
3608 bp_.rightmargin, default_unit);
3610 lengthToWidgets(m->headheightLE, m->headheightUnit,
3611 bp_.headheight, default_unit);
3613 lengthToWidgets(m->headsepLE, m->headsepUnit,
3614 bp_.headsep, default_unit);
3616 lengthToWidgets(m->footskipLE, m->footskipUnit,
3617 bp_.footskip, default_unit);
3619 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3620 bp_.columnsep, default_unit);
3623 updateUnknownBranches();
3624 branchesModule->update(bp_);
3627 PDFOptions const & pdf = bp_.pdfoptions();
3628 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3629 if (bp_.documentClass().provides("hyperref"))
3630 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3632 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3633 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3634 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3635 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3636 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3638 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3639 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3640 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3642 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3644 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3645 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3646 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3647 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3649 nn = findToken(backref_opts, pdf.backref);
3651 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3653 pdfSupportModule->fullscreenCB->setChecked
3654 (pdf.pagemode == pdf.pagemode_fullscreen);
3656 pdfSupportModule->optionsLE->setText(
3657 toqstr(pdf.quoted_options));
3659 // Make sure that the bc is in the INITIAL state
3660 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3663 // clear changed branches cache
3664 changedBranches_.clear();
3667 nonModuleChanged_ = false;
3671 void GuiDocument::saveDocDefault()
3673 // we have to apply the params first
3679 void GuiDocument::updateAvailableModules()
3681 modules_av_model_.clear();
3682 list<modInfoStruct> modInfoList = getModuleInfo();
3683 // Sort names according to the locale
3684 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3685 return 0 < b.name.localeAwareCompare(a.name);
3688 for (modInfoStruct const & m : modInfoList) {
3689 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3695 void GuiDocument::updateSelectedModules()
3697 modules_sel_model_.clear();
3698 list<modInfoStruct> const selModList = getSelectedModules();
3700 for (modInfoStruct const & m : selModList) {
3701 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3707 void GuiDocument::updateIncludeonlys()
3709 masterChildModule->childrenTW->clear();
3710 QString const no = qt_("No");
3711 QString const yes = qt_("Yes");
3713 if (includeonlys_.empty()) {
3714 masterChildModule->includeallRB->setChecked(true);
3715 masterChildModule->childrenTW->setEnabled(false);
3716 masterChildModule->maintainAuxCB->setEnabled(false);
3718 masterChildModule->includeonlyRB->setChecked(true);
3719 masterChildModule->childrenTW->setEnabled(true);
3720 masterChildModule->maintainAuxCB->setEnabled(true);
3722 ListOfBuffers children = buffer().getChildren();
3723 ListOfBuffers::const_iterator it = children.begin();
3724 ListOfBuffers::const_iterator end = children.end();
3725 bool has_unincluded = false;
3726 bool all_unincluded = true;
3727 for (; it != end; ++it) {
3728 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3731 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3732 from_utf8(buffer().filePath())));
3733 item->setText(0, toqstr(name));
3734 item->setText(1, isChildIncluded(name) ? yes : no);
3735 if (!isChildIncluded(name))
3736 has_unincluded = true;
3738 all_unincluded = false;
3740 // Both if all childs are included and if none is included
3741 // is equal to "include all" (i.e., ommit \includeonly).
3742 // Thus, reset the GUI.
3743 if (!has_unincluded || all_unincluded) {
3744 masterChildModule->includeallRB->setChecked(true);
3745 masterChildModule->childrenTW->setEnabled(false);
3746 includeonlys_.clear();
3748 // If all are included, we need to update again.
3749 if (!has_unincluded)
3750 updateIncludeonlys();
3754 bool GuiDocument::isBiblatex() const
3756 QString const engine =
3757 biblioModule->citeEngineCO->itemData(
3758 biblioModule->citeEngineCO->currentIndex()).toString();
3760 return theCiteEnginesList[fromqstr(engine)]->getCiteFramework() == "biblatex";
3764 void GuiDocument::updateDefaultBiblio(string const & style,
3765 string const & which)
3767 QString const bibstyle = toqstr(style);
3768 biblioModule->defaultBiblioCO->clear();
3773 if (which != "cbx") {
3774 // First the bbx styles
3775 biblioModule->biblatexBbxCO->clear();
3776 QStringList str = texFileList("bbxFiles.lst");
3777 // test whether we have a valid list, otherwise run rescan
3778 if (str.isEmpty()) {
3779 rescanTexStyles("bbx");
3780 str = texFileList("bbxFiles.lst");
3782 for (int i = 0; i != str.size(); ++i)
3783 str[i] = onlyFileName(str[i]);
3784 // sort on filename only (no path)
3787 for (int i = 0; i != str.count(); ++i) {
3788 QString item = changeExtension(str[i], "");
3789 if (item == bibstyle)
3791 biblioModule->biblatexBbxCO->addItem(item);
3794 if (item_nr == -1 && !bibstyle.isEmpty()) {
3795 biblioModule->biblatexBbxCO->addItem(bibstyle);
3796 item_nr = biblioModule->biblatexBbxCO->count() - 1;
3800 biblioModule->biblatexBbxCO->setCurrentIndex(item_nr);
3802 biblioModule->biblatexBbxCO->clearEditText();
3805 if (which != "bbx") {
3806 // now the cbx styles
3807 biblioModule->biblatexCbxCO->clear();
3808 QStringList str = texFileList("cbxFiles.lst");
3809 // test whether we have a valid list, otherwise run rescan
3810 if (str.isEmpty()) {
3811 rescanTexStyles("cbx");
3812 str = texFileList("cbxFiles.lst");
3814 for (int i = 0; i != str.size(); ++i)
3815 str[i] = onlyFileName(str[i]);
3816 // sort on filename only (no path)
3819 for (int i = 0; i != str.count(); ++i) {
3820 QString item = changeExtension(str[i], "");
3821 if (item == bibstyle)
3823 biblioModule->biblatexCbxCO->addItem(item);
3826 if (item_nr == -1 && !bibstyle.isEmpty()) {
3827 biblioModule->biblatexCbxCO->addItem(bibstyle);
3828 item_nr = biblioModule->biblatexCbxCO->count() - 1;
3832 biblioModule->biblatexCbxCO->setCurrentIndex(item_nr);
3834 biblioModule->biblatexCbxCO->clearEditText();
3837 biblioModule->biblatexBbxCO->clear();
3838 biblioModule->biblatexCbxCO->clear();
3839 QStringList str = texFileList("bstFiles.lst");
3840 // test whether we have a valid list, otherwise run rescan
3841 if (str.isEmpty()) {
3842 rescanTexStyles("bst");
3843 str = texFileList("bstFiles.lst");
3845 for (int i = 0; i != str.size(); ++i)
3846 str[i] = onlyFileName(str[i]);
3847 // sort on filename only (no path)
3850 for (int i = 0; i != str.count(); ++i) {
3851 QString item = changeExtension(str[i], "");
3852 if (item == bibstyle)
3854 biblioModule->defaultBiblioCO->addItem(item);
3857 if (item_nr == -1 && !bibstyle.isEmpty()) {
3858 biblioModule->defaultBiblioCO->addItem(bibstyle);
3859 item_nr = biblioModule->defaultBiblioCO->count() - 1;
3863 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
3865 biblioModule->defaultBiblioCO->clearEditText();
3868 updateResetDefaultBiblio();
3872 void GuiDocument::updateResetDefaultBiblio()
3874 QString const engine =
3875 biblioModule->citeEngineCO->itemData(
3876 biblioModule->citeEngineCO->currentIndex()).toString();
3877 CiteEngineType const cet =
3878 CiteEngineType(biblioModule->citeStyleCO->itemData(
3879 biblioModule->citeStyleCO->currentIndex()).toInt());
3881 string const defbib = theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet);
3883 QString const bbx = biblioModule->biblatexBbxCO->currentText();
3884 QString const cbx = biblioModule->biblatexCbxCO->currentText();
3885 biblioModule->resetCbxPB->setEnabled(defbib != fromqstr(cbx));
3886 biblioModule->resetBbxPB->setEnabled(defbib != fromqstr(bbx));
3887 biblioModule->matchBbxPB->setEnabled(bbx != cbx && !cbx.isEmpty()
3888 && biblioModule->biblatexBbxCO->findText(cbx) != -1);
3890 biblioModule->resetDefaultBiblioPB->setEnabled(
3891 defbib != fromqstr(biblioModule->defaultBiblioCO->currentText()));
3895 void GuiDocument::matchBiblatexStyles()
3897 updateDefaultBiblio(fromqstr(biblioModule->biblatexCbxCO->currentText()), "bbx");
3902 void GuiDocument::updateContents()
3904 // Nothing to do here as the document settings is not cursor dependant.
3909 void GuiDocument::useClassDefaults()
3911 if (applyPB->isEnabled()) {
3912 int const ret = Alert::prompt(_("Unapplied changes"),
3913 _("Some changes in the dialog were not yet applied.\n"
3914 "If you do not apply now, they will be lost after this action."),
3915 1, 1, _("&Apply"), _("&Dismiss"));
3920 int idx = latexModule->classCO->currentIndex();
3921 string const classname = fromqstr(latexModule->classCO->getData(idx));
3922 if (!bp_.setBaseClass(classname)) {
3923 Alert::error(_("Error"), _("Unable to set document class."));
3926 bp_.useClassDefaults();
3931 void GuiDocument::setLayoutComboByIDString(string const & idString)
3933 if (!latexModule->classCO->set(toqstr(idString)))
3934 Alert::warning(_("Can't set layout!"),
3935 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3939 bool GuiDocument::isValid()
3942 validateListingsParameters().isEmpty() &&
3943 localLayout->isValid() &&
3945 // if we're asking for skips between paragraphs
3946 !textLayoutModule->skipRB->isChecked() ||
3947 // then either we haven't chosen custom
3948 textLayoutModule->skipCO->currentIndex() != 3 ||
3949 // or else a length has been given
3950 !textLayoutModule->skipLE->text().isEmpty()
3953 // if we're asking for indentation
3954 !textLayoutModule->indentRB->isChecked() ||
3955 // then either we haven't chosen custom
3956 textLayoutModule->indentCO->currentIndex() != 1 ||
3957 // or else a length has been given
3958 !textLayoutModule->indentLE->text().isEmpty()
3963 char const * const GuiDocument::fontfamilies[5] = {
3964 "default", "rmdefault", "sfdefault", "ttdefault", ""
3968 char const * GuiDocument::fontfamilies_gui[5] = {
3969 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3973 bool GuiDocument::initialiseParams(string const &)
3975 BufferView const * view = bufferview();
3977 bp_ = BufferParams();
3981 bp_ = view->buffer().params();
3983 updateAvailableModules();
3984 //FIXME It'd be nice to make sure here that the selected
3985 //modules are consistent: That required modules are actually
3986 //selected, and that we don't have conflicts. If so, we could
3987 //at least pop up a warning.
3993 void GuiDocument::clearParams()
3995 bp_ = BufferParams();
3999 BufferId GuiDocument::id() const
4001 BufferView const * const view = bufferview();
4002 return view? &view->buffer() : 0;
4006 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
4008 return moduleNames_;
4012 list<GuiDocument::modInfoStruct> const
4013 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
4015 list<modInfoStruct> mInfo;
4016 for (string const & name : mods) {
4018 LyXModule const * const mod = theModuleList[name];
4023 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
4031 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
4033 return makeModuleInfo(params().getModules());
4037 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
4039 return makeModuleInfo(params().baseClass()->providedModules());
4043 DocumentClass const & GuiDocument::documentClass() const
4045 return bp_.documentClass();
4049 static void dispatch_bufferparams(Dialog const & dialog,
4050 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
4053 ss << "\\begin_header\n";
4054 bp.writeFile(ss, buf);
4055 ss << "\\end_header\n";
4056 dialog.dispatch(FuncRequest(lfun, ss.str()));
4060 void GuiDocument::dispatchParams()
4062 // We need a non-const buffer object.
4063 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
4064 // There may be several undo records; group them (bug #8998)
4065 buf.undo().beginUndoGroup();
4067 // This must come first so that a language change is correctly noticed
4070 // Apply the BufferParams. Note that this will set the base class
4071 // and then update the buffer's layout.
4072 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
4074 if (!params().master.empty()) {
4075 FileName const master_file = support::makeAbsPath(params().master,
4076 support::onlyPath(buffer().absFileName()));
4077 if (isLyXFileName(master_file.absFileName())) {
4078 Buffer * master = checkAndLoadLyXFile(master_file);
4080 if (master->isChild(const_cast<Buffer *>(&buffer())))
4081 const_cast<Buffer &>(buffer()).setParent(master);
4083 Alert::warning(_("Assigned master does not include this file"),
4084 bformat(_("You must include this file in the document\n"
4085 "'%1$s' in order to use the master document\n"
4086 "feature."), from_utf8(params().master)));
4088 Alert::warning(_("Could not load master"),
4089 bformat(_("The master document '%1$s'\n"
4090 "could not be loaded."),
4091 from_utf8(params().master)));
4095 // Generate the colours requested by each new branch.
4096 BranchList & branchlist = params().branchlist();
4097 if (!branchlist.empty()) {
4098 BranchList::const_iterator it = branchlist.begin();
4099 BranchList::const_iterator const end = branchlist.end();
4100 for (; it != end; ++it) {
4101 docstring const & current_branch = it->branch();
4102 Branch const * branch = branchlist.find(current_branch);
4103 string const x11hexname = X11hexname(branch->color());
4104 // display the new color
4105 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
4106 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4109 // Open insets of selected branches, close deselected ones
4110 dispatch(FuncRequest(LFUN_INSET_FORALL,
4111 "Branch inset-toggle assign"));
4113 // rename branches in the document
4114 executeBranchRenaming();
4115 // and clear changed branches cache
4116 changedBranches_.clear();
4118 // Generate the colours requested by indices.
4119 IndicesList & indiceslist = params().indiceslist();
4120 if (!indiceslist.empty()) {
4121 IndicesList::const_iterator it = indiceslist.begin();
4122 IndicesList::const_iterator const end = indiceslist.end();
4123 for (; it != end; ++it) {
4124 docstring const & current_index = it->shortcut();
4125 Index const * index = indiceslist.findShortcut(current_index);
4126 string const x11hexname = X11hexname(index->color());
4127 // display the new color
4128 docstring const str = current_index + ' ' + from_ascii(x11hexname);
4129 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4133 // If we used an LFUN, we would not need these two lines:
4134 BufferView * bv = const_cast<BufferView *>(bufferview());
4135 bv->processUpdateFlags(Update::Force | Update::FitCursor);
4137 // Don't forget to close the group. Note that it is important
4138 // to check that there is no early return in the method.
4139 buf.undo().endUndoGroup();
4143 void GuiDocument::setLanguage() const
4145 Language const * const newL = bp_.language;
4146 if (buffer().params().language == newL)
4149 string const & lang_name = newL->lang();
4150 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
4154 void GuiDocument::saveAsDefault() const
4156 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
4160 bool GuiDocument::providesOSF(QString const & font) const
4162 if (fontModule->osFontsCB->isChecked())
4163 // FIXME: we should check if the fonts really
4164 // have OSF support. But how?
4166 return theLaTeXFonts().getLaTeXFont(
4167 qstring_to_ucs4(font)).providesOSF(ot1(),
4173 bool GuiDocument::providesSC(QString const & font) const
4175 if (fontModule->osFontsCB->isChecked())
4177 return theLaTeXFonts().getLaTeXFont(
4178 qstring_to_ucs4(font)).providesSC(ot1(),
4184 bool GuiDocument::providesScale(QString const & font) const
4186 if (fontModule->osFontsCB->isChecked())
4188 return theLaTeXFonts().getLaTeXFont(
4189 qstring_to_ucs4(font)).providesScale(ot1(),
4195 bool GuiDocument::providesNoMath(QString const & font) const
4197 if (fontModule->osFontsCB->isChecked())
4199 return theLaTeXFonts().getLaTeXFont(
4200 qstring_to_ucs4(font)).providesNoMath(ot1(),
4205 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4207 if (fontModule->osFontsCB->isChecked())
4209 return theLaTeXFonts().getLaTeXFont(
4210 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4217 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4219 // FIXME Unicode: docstrings would be better for these parameters but this
4220 // change requires a lot of others
4223 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4224 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4225 // Find the first sentence of the description
4226 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4227 int pos = bf.toNextBoundary();
4230 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4231 // Tooltip is the desc followed by the module name
4232 m.description = QString("%1<i>%2</i>")
4233 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4239 void GuiDocument::loadModuleInfo()
4241 moduleNames_.clear();
4242 for (LyXModule const & mod : theModuleList)
4243 if (mod.category().substr(0, 8) != "Citation")
4244 moduleNames_.push_back(modInfo(mod));
4248 void GuiDocument::updateUnknownBranches()
4252 list<docstring> used_branches;
4253 buffer().getUsedBranches(used_branches);
4254 list<docstring>::const_iterator it = used_branches.begin();
4255 QStringList unknown_branches;
4256 for (; it != used_branches.end() ; ++it) {
4257 if (!buffer().params().branchlist().find(*it))
4258 unknown_branches.append(toqstr(*it));
4260 branchesModule->setUnknownBranches(unknown_branches);
4264 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4266 map<docstring, docstring>::iterator it = changedBranches_.begin();
4267 for (; it != changedBranches_.end() ; ++it) {
4268 if (it->second == oldname) {
4269 // branch has already been renamed
4270 it->second = newname;
4275 changedBranches_[oldname] = newname;
4279 void GuiDocument::executeBranchRenaming() const
4281 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4282 for (; it != changedBranches_.end() ; ++it) {
4283 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4284 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4289 void GuiDocument::allPackagesAuto()
4295 void GuiDocument::allPackagesAlways()
4301 void GuiDocument::allPackagesNot()
4307 void GuiDocument::allPackages(int col)
4309 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4310 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4311 rb->setChecked(true);
4316 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4319 } // namespace frontend
4322 #include "moc_GuiDocument.cpp"