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->bibunitsCO, SIGNAL(activated(int)),
1130 this, SLOT(biblioChanged()));
1131 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1132 this, SLOT(bibtexChanged(int)));
1133 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1134 this, SLOT(biblioChanged()));
1135 connect(biblioModule->citePackageOptionsLE, SIGNAL(textChanged(QString)),
1136 this, SLOT(biblioChanged()));
1137 connect(biblioModule->defaultBiblioCO, SIGNAL(activated(int)),
1138 this, SLOT(biblioChanged()));
1139 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1140 this, SLOT(biblioChanged()));
1141 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1142 this, SLOT(updateResetDefaultBiblio()));
1143 connect(biblioModule->biblatexBbxCO, SIGNAL(activated(int)),
1144 this, SLOT(biblioChanged()));
1145 connect(biblioModule->biblatexBbxCO, SIGNAL(editTextChanged(QString)),
1146 this, SLOT(updateResetDefaultBiblio()));
1147 connect(biblioModule->biblatexCbxCO, SIGNAL(activated(int)),
1148 this, SLOT(biblioChanged()));
1149 connect(biblioModule->biblatexCbxCO, SIGNAL(editTextChanged(QString)),
1150 this, SLOT(updateResetDefaultBiblio()));
1151 connect(biblioModule->rescanBibliosPB, SIGNAL(clicked()),
1152 this, SLOT(rescanBibFiles()));
1153 connect(biblioModule->resetDefaultBiblioPB, SIGNAL(clicked()),
1154 this, SLOT(resetDefaultBibfile()));
1155 connect(biblioModule->resetCbxPB, SIGNAL(clicked()),
1156 this, SLOT(resetDefaultCbxBibfile()));
1157 connect(biblioModule->resetBbxPB, SIGNAL(clicked()),
1158 this, SLOT(resetDefaultBbxBibfile()));
1159 connect(biblioModule->matchBbxPB, SIGNAL(clicked()),
1160 this, SLOT(matchBiblatexStyles()));
1162 biblioModule->citeEngineCO->clear();
1163 for (LyXCiteEngine const & cet : theCiteEnginesList) {
1164 biblioModule->citeEngineCO->addItem(qt_(cet.getName()), toqstr(cet.getID()));
1165 int const i = biblioModule->citeEngineCO->findData(toqstr(cet.getID()));
1166 biblioModule->citeEngineCO->setItemData(i, qt_(cet.getDescription()),
1170 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1171 biblioModule->bibtexOptionsLE));
1172 biblioModule->defaultBiblioCO->lineEdit()->setValidator(new NoNewLineValidator(
1173 biblioModule->defaultBiblioCO->lineEdit()));
1175 // NOTE: we do not provide "custom" here for security reasons!
1176 biblioModule->bibtexCO->clear();
1177 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1178 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1179 it != lyxrc.bibtex_alternatives.end(); ++it) {
1180 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1181 biblioModule->bibtexCO->addItem(command, command);
1186 indicesModule = new GuiIndices;
1187 connect(indicesModule, SIGNAL(changed()),
1188 this, SLOT(change_adaptor()));
1192 mathsModule = new UiWidget<Ui::MathsUi>;
1193 QStringList headers;
1194 headers << qt_("Package") << qt_("Load automatically")
1195 << qt_("Load always") << qt_("Do not load");
1196 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1197 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1198 map<string, string> const & packages = BufferParams::auto_packages();
1199 mathsModule->packagesTW->setRowCount(packages.size());
1201 for (map<string, string>::const_iterator it = packages.begin();
1202 it != packages.end(); ++it) {
1203 docstring const package = from_ascii(it->first);
1204 QString autoTooltip = qt_(it->second);
1205 QString alwaysTooltip;
1206 if (package == "amsmath")
1208 qt_("The AMS LaTeX packages are always used");
1210 alwaysTooltip = toqstr(bformat(
1211 _("The LaTeX package %1$s is always used"),
1213 QString neverTooltip;
1214 if (package == "amsmath")
1216 qt_("The AMS LaTeX packages are never used");
1218 neverTooltip = toqstr(bformat(
1219 _("The LaTeX package %1$s is never used"),
1221 QRadioButton * autoRB = new QRadioButton(mathsModule);
1222 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1223 QRadioButton * neverRB = new QRadioButton(mathsModule);
1224 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1225 packageGroup->addButton(autoRB);
1226 packageGroup->addButton(alwaysRB);
1227 packageGroup->addButton(neverRB);
1228 autoRB->setToolTip(autoTooltip);
1229 alwaysRB->setToolTip(alwaysTooltip);
1230 neverRB->setToolTip(neverTooltip);
1231 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1232 mathsModule->packagesTW->setItem(i, 0, pack);
1233 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1234 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1235 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1237 connect(autoRB, SIGNAL(clicked()),
1238 this, SLOT(change_adaptor()));
1239 connect(alwaysRB, SIGNAL(clicked()),
1240 this, SLOT(change_adaptor()));
1241 connect(neverRB, SIGNAL(clicked()),
1242 this, SLOT(change_adaptor()));
1245 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1246 this, SLOT(allPackagesAuto()));
1247 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1248 this, SLOT(allPackagesAlways()));
1249 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1250 this, SLOT(allPackagesNot()));
1251 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1252 this, SLOT(change_adaptor()));
1253 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1254 this, SLOT(change_adaptor()));
1255 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1256 this, SLOT(change_adaptor()));
1260 latexModule = new UiWidget<Ui::LaTeXUi>;
1261 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1262 this, SLOT(change_adaptor()));
1263 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1264 this, SLOT(change_adaptor()));
1265 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1266 this, SLOT(change_adaptor()));
1267 connect(latexModule->classCO, SIGNAL(activated(int)),
1268 this, SLOT(classChanged_adaptor()));
1269 connect(latexModule->classCO, SIGNAL(activated(int)),
1270 this, SLOT(change_adaptor()));
1271 connect(latexModule->layoutPB, SIGNAL(clicked()),
1272 this, SLOT(browseLayout()));
1273 connect(latexModule->layoutPB, SIGNAL(clicked()),
1274 this, SLOT(change_adaptor()));
1275 connect(latexModule->childDocGB, SIGNAL(clicked()),
1276 this, SLOT(change_adaptor()));
1277 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1278 this, SLOT(change_adaptor()));
1279 connect(latexModule->childDocPB, SIGNAL(clicked()),
1280 this, SLOT(browseMaster()));
1281 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1282 this, SLOT(change_adaptor()));
1283 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1284 this, SLOT(change_adaptor()));
1286 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1287 latexModule->optionsLE));
1288 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1289 latexModule->childDocLE));
1291 // postscript drivers
1292 for (int n = 0; tex_graphics[n][0]; ++n) {
1293 QString enc = qt_(tex_graphics_gui[n]);
1294 latexModule->psdriverCO->addItem(enc);
1297 LayoutFileList const & bcl = LayoutFileList::get();
1298 vector<LayoutFileIndex> classList = bcl.classList();
1299 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1301 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1302 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1303 for (int i = 0; cit != cen; ++cit, ++i) {
1304 LayoutFile const & tc = bcl[*cit];
1305 bool const available = tc.isTeXClassAvailable();
1306 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1307 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1308 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1310 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1311 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1312 "Please check if you have the matching %1$s class "
1313 "and all required packages (%2$s) installed."),
1314 output_type, from_utf8(tc.prerequisites(", "))));
1316 latexModule->classCO->addItemSort(toqstr(tc.name()),
1318 toqstr(translateIfPossible(from_utf8(tc.category()))),
1320 true, true, true, available);
1325 branchesModule = new GuiBranches;
1326 connect(branchesModule, SIGNAL(changed()),
1327 this, SLOT(change_adaptor()));
1328 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1329 this, SLOT(branchesRename(docstring const &, docstring const &)));
1330 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1331 updateUnknownBranches();
1335 preambleModule = new PreambleModule;
1336 connect(preambleModule, SIGNAL(changed()),
1337 this, SLOT(change_adaptor()));
1339 localLayout = new LocalLayout;
1340 connect(localLayout, SIGNAL(changed()),
1341 this, SLOT(change_adaptor()));
1345 bulletsModule = new BulletsModule;
1346 connect(bulletsModule, SIGNAL(changed()),
1347 this, SLOT(change_adaptor()));
1351 modulesModule = new UiWidget<Ui::ModulesUi>;
1352 modulesModule->availableLV->header()->setVisible(false);
1353 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1354 modulesModule->availableLV->header()->setStretchLastSection(false);
1356 new ModuleSelectionManager(modulesModule->availableLV,
1357 modulesModule->selectedLV,
1358 modulesModule->addPB, modulesModule->deletePB,
1359 modulesModule->upPB, modulesModule->downPB,
1360 availableModel(), selectedModel(), this);
1361 connect(selectionManager, SIGNAL(updateHook()),
1362 this, SLOT(updateModuleInfo()));
1363 connect(selectionManager, SIGNAL(selectionChanged()),
1364 this, SLOT(modulesChanged()));
1368 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1369 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1370 this, SLOT(change_adaptor()));
1371 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1372 this, SLOT(change_adaptor()));
1373 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1374 this, SLOT(change_adaptor()));
1375 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1376 this, SLOT(change_adaptor()));
1377 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1378 this, SLOT(change_adaptor()));
1379 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1380 this, SLOT(change_adaptor()));
1381 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1382 this, SLOT(change_adaptor()));
1383 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1384 this, SLOT(change_adaptor()));
1385 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1386 this, SLOT(change_adaptor()));
1387 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1388 this, SLOT(change_adaptor()));
1389 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1390 this, SLOT(change_adaptor()));
1391 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1392 this, SLOT(change_adaptor()));
1393 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1394 this, SLOT(change_adaptor()));
1395 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1396 this, SLOT(change_adaptor()));
1397 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1398 this, SLOT(change_adaptor()));
1399 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1400 this, SLOT(change_adaptor()));
1402 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1403 pdfSupportModule->titleLE));
1404 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1405 pdfSupportModule->authorLE));
1406 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1407 pdfSupportModule->subjectLE));
1408 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1409 pdfSupportModule->keywordsLE));
1410 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1411 pdfSupportModule->optionsLE));
1413 for (int i = 0; backref_opts[i][0]; ++i)
1414 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1418 floatModule = new FloatPlacement;
1419 connect(floatModule, SIGNAL(changed()),
1420 this, SLOT(change_adaptor()));
1424 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1425 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1426 this, SLOT(change_adaptor()));
1427 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1428 this, SLOT(change_adaptor()));
1429 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1430 this, SLOT(setListingsMessage()));
1431 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1432 this, SLOT(setListingsMessage()));
1433 listingsModule->listingsTB->setPlainText(
1434 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1438 docPS->addPanel(latexModule, N_("Document Class"));
1439 docPS->addPanel(masterChildModule, N_("Child Documents"));
1440 docPS->addPanel(modulesModule, N_("Modules"));
1441 docPS->addPanel(localLayout, N_("Local Layout"));
1442 docPS->addPanel(fontModule, N_("Fonts"));
1443 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1444 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1445 docPS->addPanel(marginsModule, N_("Page Margins"));
1446 docPS->addPanel(langModule, N_("Language"));
1447 docPS->addPanel(colorModule, N_("Colors"));
1448 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1449 docPS->addPanel(biblioModule, N_("Bibliography"));
1450 docPS->addPanel(indicesModule, N_("Indexes"));
1451 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1452 docPS->addPanel(mathsModule, N_("Math Options"));
1453 docPS->addPanel(floatModule, N_("Float Placement"));
1454 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1455 docPS->addPanel(bulletsModule, N_("Bullets"));
1456 docPS->addPanel(branchesModule, N_("Branches"));
1457 docPS->addPanel(outputModule, N_("Formats[[output]]"));
1458 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1459 docPS->setCurrentPanel("Document Class");
1460 // FIXME: hack to work around resizing bug in Qt >= 4.2
1461 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1462 #if QT_VERSION >= 0x040200
1463 docPS->updateGeometry();
1468 void GuiDocument::onBufferViewChanged()
1470 if (isVisibleView())
1471 initialiseParams("");
1475 void GuiDocument::saveDefaultClicked()
1481 void GuiDocument::useDefaultsClicked()
1487 void GuiDocument::change_adaptor()
1489 nonModuleChanged_ = true;
1494 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1499 string child = fromqstr(item->text(0));
1503 if (std::find(includeonlys_.begin(),
1504 includeonlys_.end(), child) != includeonlys_.end())
1505 includeonlys_.remove(child);
1507 includeonlys_.push_back(child);
1509 updateIncludeonlys();
1514 QString GuiDocument::validateListingsParameters()
1516 if (listingsModule->bypassCB->isChecked())
1518 string params = fromqstr(listingsModule->listingsED->toPlainText());
1519 return toqstr(InsetListingsParams(params).validate());
1523 void GuiDocument::setListingsMessage()
1526 static bool isOK = true;
1527 QString msg = validateListingsParameters();
1528 if (msg.isEmpty()) {
1532 // listingsTB->setTextColor("black");
1533 listingsModule->listingsTB->setPlainText(
1534 qt_("Input listings parameters below. "
1535 "Enter ? for a list of parameters."));
1538 // listingsTB->setTextColor("red");
1539 listingsModule->listingsTB->setPlainText(msg);
1544 void GuiDocument::setLSpacing(int item)
1546 textLayoutModule->lspacingLE->setEnabled(item == 3);
1550 void GuiDocument::setIndent(int item)
1552 bool const enable = (item == 1);
1553 textLayoutModule->indentLE->setEnabled(enable);
1554 textLayoutModule->indentLengthCO->setEnabled(enable);
1555 textLayoutModule->skipLE->setEnabled(false);
1556 textLayoutModule->skipLengthCO->setEnabled(false);
1561 void GuiDocument::enableIndent(bool indent)
1563 textLayoutModule->skipLE->setEnabled(!indent);
1564 textLayoutModule->skipLengthCO->setEnabled(!indent);
1566 setIndent(textLayoutModule->indentCO->currentIndex());
1570 void GuiDocument::setSkip(int item)
1572 bool const enable = (item == 3);
1573 textLayoutModule->skipLE->setEnabled(enable);
1574 textLayoutModule->skipLengthCO->setEnabled(enable);
1579 void GuiDocument::enableSkip(bool skip)
1581 textLayoutModule->indentLE->setEnabled(!skip);
1582 textLayoutModule->indentLengthCO->setEnabled(!skip);
1584 setSkip(textLayoutModule->skipCO->currentIndex());
1588 void GuiDocument::setMargins()
1590 bool const extern_geometry =
1591 documentClass().provides("geometry");
1592 marginsModule->marginCB->setEnabled(!extern_geometry);
1593 if (extern_geometry) {
1594 marginsModule->marginCB->setChecked(false);
1595 setCustomMargins(true);
1597 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1598 setCustomMargins(!bp_.use_geometry);
1603 void GuiDocument::papersizeChanged(int paper_size)
1605 setCustomPapersize(paper_size == 1);
1609 void GuiDocument::setCustomPapersize(bool custom)
1611 pageLayoutModule->paperwidthL->setEnabled(custom);
1612 pageLayoutModule->paperwidthLE->setEnabled(custom);
1613 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1614 pageLayoutModule->paperheightL->setEnabled(custom);
1615 pageLayoutModule->paperheightLE->setEnabled(custom);
1616 pageLayoutModule->paperheightLE->setFocus();
1617 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1621 void GuiDocument::setColSep()
1623 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1627 void GuiDocument::setCustomMargins(bool custom)
1629 marginsModule->topL->setEnabled(!custom);
1630 marginsModule->topLE->setEnabled(!custom);
1631 marginsModule->topUnit->setEnabled(!custom);
1633 marginsModule->bottomL->setEnabled(!custom);
1634 marginsModule->bottomLE->setEnabled(!custom);
1635 marginsModule->bottomUnit->setEnabled(!custom);
1637 marginsModule->innerL->setEnabled(!custom);
1638 marginsModule->innerLE->setEnabled(!custom);
1639 marginsModule->innerUnit->setEnabled(!custom);
1641 marginsModule->outerL->setEnabled(!custom);
1642 marginsModule->outerLE->setEnabled(!custom);
1643 marginsModule->outerUnit->setEnabled(!custom);
1645 marginsModule->headheightL->setEnabled(!custom);
1646 marginsModule->headheightLE->setEnabled(!custom);
1647 marginsModule->headheightUnit->setEnabled(!custom);
1649 marginsModule->headsepL->setEnabled(!custom);
1650 marginsModule->headsepLE->setEnabled(!custom);
1651 marginsModule->headsepUnit->setEnabled(!custom);
1653 marginsModule->footskipL->setEnabled(!custom);
1654 marginsModule->footskipLE->setEnabled(!custom);
1655 marginsModule->footskipUnit->setEnabled(!custom);
1657 bool const enableColSep = !custom &&
1658 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1659 marginsModule->columnsepL->setEnabled(enableColSep);
1660 marginsModule->columnsepLE->setEnabled(enableColSep);
1661 marginsModule->columnsepUnit->setEnabled(enableColSep);
1665 void GuiDocument::changeBackgroundColor()
1667 QColor const & newColor = QColorDialog::getColor(
1668 rgb2qcolor(set_backgroundcolor), asQWidget());
1669 if (!newColor.isValid())
1671 // set the button color and text
1672 colorModule->backgroundPB->setStyleSheet(
1673 colorButtonStyleSheet(newColor));
1674 colorModule->backgroundPB->setText(qt_("&Change..."));
1676 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1677 is_backgroundcolor = true;
1682 void GuiDocument::deleteBackgroundColor()
1684 // set the button color back to default by setting an empty StyleSheet
1685 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1686 // change button text
1687 colorModule->backgroundPB->setText(qt_("&Default..."));
1688 // save default color (white)
1689 set_backgroundcolor = rgbFromHexName("#ffffff");
1690 is_backgroundcolor = false;
1695 void GuiDocument::changeFontColor()
1697 QColor const & newColor = QColorDialog::getColor(
1698 rgb2qcolor(set_fontcolor), asQWidget());
1699 if (!newColor.isValid())
1701 // set the button color and text
1702 colorModule->fontColorPB->setStyleSheet(
1703 colorButtonStyleSheet(newColor));
1704 colorModule->fontColorPB->setText(qt_("&Change..."));
1706 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1707 is_fontcolor = true;
1712 void GuiDocument::deleteFontColor()
1714 // set the button color back to default by setting an empty StyleSheet
1715 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1716 // change button text
1717 colorModule->fontColorPB->setText(qt_("&Default..."));
1718 // save default color (black)
1719 set_fontcolor = rgbFromHexName("#000000");
1720 is_fontcolor = false;
1725 void GuiDocument::changeNoteFontColor()
1727 QColor const & newColor = QColorDialog::getColor(
1728 rgb2qcolor(set_notefontcolor), asQWidget());
1729 if (!newColor.isValid())
1731 // set the button color
1732 colorModule->noteFontColorPB->setStyleSheet(
1733 colorButtonStyleSheet(newColor));
1735 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1740 void GuiDocument::deleteNoteFontColor()
1742 // set the button color back to pref
1743 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1744 colorModule->noteFontColorPB->setStyleSheet(
1745 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1750 void GuiDocument::changeBoxBackgroundColor()
1752 QColor const & newColor = QColorDialog::getColor(
1753 rgb2qcolor(set_boxbgcolor), asQWidget());
1754 if (!newColor.isValid())
1756 // set the button color
1757 colorModule->boxBackgroundPB->setStyleSheet(
1758 colorButtonStyleSheet(newColor));
1760 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1765 void GuiDocument::deleteBoxBackgroundColor()
1767 // set the button color back to pref
1768 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1769 colorModule->boxBackgroundPB->setStyleSheet(
1770 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1775 void GuiDocument::updateQuoteStyles(bool const set)
1777 Language const * lang = lyx::languages.getLanguage(
1778 fromqstr(langModule->languageCO->itemData(
1779 langModule->languageCO->currentIndex()).toString()));
1781 InsetQuotesParams::QuoteStyle def = bp_.getQuoteStyle(lang->quoteStyle());
1783 langModule->quoteStyleCO->clear();
1785 bool has_default = false;
1786 for (int i = 0; i < quoteparams.stylescount(); ++i) {
1787 InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::QuoteStyle(i);
1788 if (qs == InsetQuotesParams::DynamicQuotes)
1790 bool const langdef = (qs == def);
1792 // add the default style on top
1793 langModule->quoteStyleCO->insertItem(0,
1794 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1798 langModule->quoteStyleCO->addItem(
1799 toqstr(quoteparams.getGuiLabel(qs, langdef)), qs);
1801 if (set && has_default)
1802 // (re)set to the default style
1803 langModule->quoteStyleCO->setCurrentIndex(0);
1807 void GuiDocument::languageChanged(int i)
1809 // some languages only work with polyglossia
1810 Language const * lang = lyx::languages.getLanguage(
1811 fromqstr(langModule->languageCO->itemData(i).toString()));
1812 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1813 // If we force to switch fontspec on, store
1814 // current state (#8717)
1815 if (fontModule->osFontsCB->isEnabled())
1816 forced_fontspec_activation =
1817 !fontModule->osFontsCB->isChecked();
1818 fontModule->osFontsCB->setChecked(true);
1819 fontModule->osFontsCB->setEnabled(false);
1822 fontModule->osFontsCB->setEnabled(true);
1823 // If we have forced to switch fontspec on,
1824 // restore previous state (#8717)
1825 if (forced_fontspec_activation)
1826 fontModule->osFontsCB->setChecked(false);
1827 forced_fontspec_activation = false;
1830 // set appropriate quotation mark style
1831 updateQuoteStyles(true);
1835 void GuiDocument::osFontsChanged(bool nontexfonts)
1837 bool const tex_fonts = !nontexfonts;
1838 // store current fonts
1839 QString const font_roman = fontModule->fontsRomanCO->itemData(
1840 fontModule->fontsRomanCO->currentIndex()).toString();
1841 QString const font_sans = fontModule->fontsSansCO->itemData(
1842 fontModule->fontsSansCO->currentIndex()).toString();
1843 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1844 fontModule->fontsTypewriterCO->currentIndex()).toString();
1845 QString const font_math = fontModule->fontsMathCO->itemData(
1846 fontModule->fontsMathCO->currentIndex()).toString();
1847 int const font_sf_scale = fontModule->scaleSansSB->value();
1848 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1851 // store default format
1852 QString const dformat = outputModule->defaultFormatCO->itemData(
1853 outputModule->defaultFormatCO->currentIndex()).toString();
1854 updateDefaultFormat();
1855 // try to restore default format
1856 int index = outputModule->defaultFormatCO->findData(dformat);
1857 // set to default if format is not found
1860 outputModule->defaultFormatCO->setCurrentIndex(index);
1862 // try to restore fonts which were selected two toggles ago
1863 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1865 fontModule->fontsRomanCO->setCurrentIndex(index);
1866 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1868 fontModule->fontsSansCO->setCurrentIndex(index);
1869 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1871 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1872 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1874 fontModule->fontsMathCO->setCurrentIndex(index);
1875 // save fonts for next next toggle
1876 fontModule->font_roman = font_roman;
1877 fontModule->font_sans = font_sans;
1878 fontModule->font_typewriter = font_typewriter;
1879 fontModule->font_math = font_math;
1880 fontModule->font_sf_scale = font_sf_scale;
1881 fontModule->font_tt_scale = font_tt_scale;
1883 langModule->encodingCO->setEnabled(tex_fonts &&
1884 !langModule->defaultencodingRB->isChecked());
1885 langModule->defaultencodingRB->setEnabled(tex_fonts);
1886 langModule->otherencodingRB->setEnabled(tex_fonts);
1888 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1889 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1890 fontModule->cjkFontLE->setEnabled(tex_fonts);
1891 fontModule->cjkFontLA->setEnabled(tex_fonts);
1893 updateFontOptions();
1895 fontModule->fontencLA->setEnabled(tex_fonts);
1896 fontModule->fontencCO->setEnabled(tex_fonts);
1898 fontModule->fontencLE->setEnabled(false);
1900 fontencChanged(fontModule->fontencCO->currentIndex());
1904 void GuiDocument::mathFontChanged(int)
1906 updateFontOptions();
1910 void GuiDocument::fontOsfToggled(bool state)
1912 if (fontModule->osFontsCB->isChecked())
1914 QString font = fontModule->fontsRomanCO->itemData(
1915 fontModule->fontsRomanCO->currentIndex()).toString();
1916 if (hasMonolithicExpertSet(font))
1917 fontModule->fontScCB->setChecked(state);
1921 void GuiDocument::fontScToggled(bool state)
1923 if (fontModule->osFontsCB->isChecked())
1925 QString font = fontModule->fontsRomanCO->itemData(
1926 fontModule->fontsRomanCO->currentIndex()).toString();
1927 if (hasMonolithicExpertSet(font))
1928 fontModule->fontOsfCB->setChecked(state);
1932 void GuiDocument::updateFontOptions()
1934 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1937 font = fontModule->fontsSansCO->itemData(
1938 fontModule->fontsSansCO->currentIndex()).toString();
1939 bool scaleable = providesScale(font);
1940 fontModule->scaleSansSB->setEnabled(scaleable);
1941 fontModule->scaleSansLA->setEnabled(scaleable);
1943 font = fontModule->fontsTypewriterCO->itemData(
1944 fontModule->fontsTypewriterCO->currentIndex()).toString();
1945 scaleable = providesScale(font);
1946 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1947 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1949 font = fontModule->fontsRomanCO->itemData(
1950 fontModule->fontsRomanCO->currentIndex()).toString();
1951 fontModule->fontScCB->setEnabled(providesSC(font));
1952 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1953 updateMathFonts(font);
1957 void GuiDocument::updateFontsize(string const & items, string const & sel)
1959 fontModule->fontsizeCO->clear();
1960 fontModule->fontsizeCO->addItem(qt_("Default"));
1962 for (int n = 0; !token(items,'|',n).empty(); ++n)
1963 fontModule->fontsizeCO->
1964 addItem(toqstr(token(items,'|',n)));
1966 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1967 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1968 fontModule->fontsizeCO->setCurrentIndex(n);
1975 bool GuiDocument::ot1() const
1977 QString const fontenc =
1978 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
1979 return (fontenc == "default"
1980 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
1981 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
1985 bool GuiDocument::completeFontset() const
1987 return (fontModule->fontsSansCO->itemData(
1988 fontModule->fontsSansCO->currentIndex()).toString() == "default"
1989 && fontModule->fontsSansCO->itemData(
1990 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
1994 bool GuiDocument::noMathFont() const
1996 return (fontModule->fontsMathCO->itemData(
1997 fontModule->fontsMathCO->currentIndex()).toString() == "default");
2001 void GuiDocument::updateTexFonts()
2003 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
2005 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
2006 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
2007 for (; it != end; ++it) {
2008 LaTeXFont lf = it->second;
2009 if (lf.name().empty()) {
2010 LYXERR0("Error: Unnamed font: " << it->first);
2013 docstring const family = lf.family();
2014 docstring guiname = translateIfPossible(lf.guiname());
2015 if (!lf.available(ot1(), noMathFont()))
2016 guiname += _(" (not installed)");
2018 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
2019 else if (family == "sf")
2020 sffonts_.insert(toqstr(guiname), toqstr(it->first));
2021 else if (family == "tt")
2022 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
2023 else if (family == "math")
2024 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
2029 void GuiDocument::updateFontlist()
2031 fontModule->fontsRomanCO->clear();
2032 fontModule->fontsSansCO->clear();
2033 fontModule->fontsTypewriterCO->clear();
2034 fontModule->fontsMathCO->clear();
2036 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
2037 if (fontModule->osFontsCB->isChecked()) {
2038 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2039 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2040 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2041 QString unimath = qt_("Non-TeX Fonts Default");
2042 if (!LaTeXFeatures::isAvailable("unicode-math"))
2043 unimath += qt_(" (not available)");
2044 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
2045 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2047 QFontDatabase fontdb;
2048 QStringList families(fontdb.families());
2049 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2050 fontModule->fontsRomanCO->addItem(*it, *it);
2051 fontModule->fontsSansCO->addItem(*it, *it);
2052 fontModule->fontsTypewriterCO->addItem(*it, *it);
2057 if (rmfonts_.empty())
2060 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2061 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2062 while (rmi != rmfonts_.constEnd()) {
2063 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2067 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2068 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2069 while (sfi != sffonts_.constEnd()) {
2070 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2074 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2075 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2076 while (tti != ttfonts_.constEnd()) {
2077 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2081 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2082 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2083 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2084 while (mmi != mathfonts_.constEnd()) {
2085 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2091 void GuiDocument::fontencChanged(int item)
2093 fontModule->fontencLE->setEnabled(
2094 fontModule->fontencCO->itemData(item).toString() == "custom");
2095 // The availability of TeX fonts depends on the font encoding
2097 updateFontOptions();
2101 void GuiDocument::updateMathFonts(QString const & rm)
2103 if (fontModule->osFontsCB->isChecked())
2105 QString const math =
2106 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2107 int const i = fontModule->fontsMathCO->findData("default");
2108 if (providesNoMath(rm) && i == -1)
2109 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2110 else if (!providesNoMath(rm) && i != -1) {
2111 int const c = fontModule->fontsMathCO->currentIndex();
2112 fontModule->fontsMathCO->removeItem(i);
2114 fontModule->fontsMathCO->setCurrentIndex(0);
2119 void GuiDocument::romanChanged(int item)
2121 if (fontModule->osFontsCB->isChecked())
2123 QString const font =
2124 fontModule->fontsRomanCO->itemData(item).toString();
2125 fontModule->fontScCB->setEnabled(providesSC(font));
2126 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2127 updateMathFonts(font);
2131 void GuiDocument::sansChanged(int item)
2133 if (fontModule->osFontsCB->isChecked())
2135 QString const font =
2136 fontModule->fontsSansCO->itemData(item).toString();
2137 bool scaleable = providesScale(font);
2138 fontModule->scaleSansSB->setEnabled(scaleable);
2139 fontModule->scaleSansLA->setEnabled(scaleable);
2143 void GuiDocument::ttChanged(int item)
2145 if (fontModule->osFontsCB->isChecked())
2147 QString const font =
2148 fontModule->fontsTypewriterCO->itemData(item).toString();
2149 bool scaleable = providesScale(font);
2150 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2151 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2155 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2158 pageLayoutModule->pagestyleCO->clear();
2159 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2161 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2162 string style = token(items, '|', n);
2163 QString style_gui = qt_(style);
2164 pagestyles.push_back(pair<string, QString>(style, style_gui));
2165 pageLayoutModule->pagestyleCO->addItem(style_gui);
2168 if (sel == "default") {
2169 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2175 for (size_t i = 0; i < pagestyles.size(); ++i)
2176 if (pagestyles[i].first == sel)
2177 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2180 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2184 void GuiDocument::browseLayout()
2186 QString const label1 = qt_("Layouts|#o#O");
2187 QString const dir1 = toqstr(lyxrc.document_path);
2188 QStringList const filter(qt_("LyX Layout (*.layout)"));
2189 QString file = browseRelToParent(QString(), bufferFilePath(),
2190 qt_("Local layout file"), filter, false,
2193 if (!file.endsWith(".layout"))
2196 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2197 fromqstr(bufferFilePath()));
2199 int const ret = Alert::prompt(_("Local layout file"),
2200 _("The layout file you have selected is a local layout\n"
2201 "file, not one in the system or user directory.\n"
2202 "Your document will not work with this layout if you\n"
2203 "move the layout file to a different directory."),
2204 1, 1, _("&Set Layout"), _("&Cancel"));
2208 // load the layout file
2209 LayoutFileList & bcl = LayoutFileList::get();
2210 string classname = layoutFile.onlyFileName();
2211 // this will update an existing layout if that layout has been loaded before.
2212 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2213 classname.substr(0, classname.size() - 7),
2214 layoutFile.onlyPath().absFileName()));
2217 Alert::error(_("Error"),
2218 _("Unable to read local layout file."));
2222 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2224 // do not trigger classChanged if there is no change.
2225 if (latexModule->classCO->currentText() == toqstr(name))
2229 bool const avail = latexModule->classCO->set(toqstr(name));
2231 LayoutFile const & tc = bcl[name];
2232 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2233 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2234 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2235 tooltip += '\n' + qt_("This is a local layout file.");
2236 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2237 toqstr(translateIfPossible(from_utf8(tc.category()))),
2239 true, true, true, true);
2240 latexModule->classCO->set(toqstr(name));
2247 void GuiDocument::browseMaster()
2249 QString const title = qt_("Select master document");
2250 QString const dir1 = toqstr(lyxrc.document_path);
2251 QString const old = latexModule->childDocLE->text();
2252 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2253 QStringList const filter(qt_("LyX Files (*.lyx)"));
2254 QString file = browseRelToSub(old, docpath, title, filter, false,
2255 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2257 if (!file.isEmpty())
2258 latexModule->childDocLE->setText(file);
2262 void GuiDocument::classChanged_adaptor()
2264 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2269 void GuiDocument::classChanged()
2271 int idx = latexModule->classCO->currentIndex();
2274 string const classname = fromqstr(latexModule->classCO->getData(idx));
2276 if (applyPB->isEnabled()) {
2277 int const ret = Alert::prompt(_("Unapplied changes"),
2278 _("Some changes in the dialog were not yet applied.\n"
2279 "If you do not apply now, they will be lost after this action."),
2280 1, 1, _("&Apply"), _("&Dismiss"));
2285 // We load the TextClass as soon as it is selected. This is
2286 // necessary so that other options in the dialog can be updated
2287 // according to the new class. Note, however, that, if you use
2288 // the scroll wheel when sitting on the combo box, we'll load a
2289 // lot of TextClass objects very quickly....
2290 if (!bp_.setBaseClass(classname)) {
2291 Alert::error(_("Error"), _("Unable to set document class."));
2294 if (lyxrc.auto_reset_options)
2295 bp_.useClassDefaults();
2297 // With the introduction of modules came a distinction between the base
2298 // class and the document class. The former corresponds to the main layout
2299 // file; the latter is that plus the modules (or the document-specific layout,
2300 // or whatever else there could be). Our parameters come from the document
2301 // class. So when we set the base class, we also need to recreate the document
2302 // class. Otherwise, we still have the old one.
2303 bp_.makeDocumentClass();
2308 void GuiDocument::languagePackageChanged(int i)
2310 langModule->languagePackageLE->setEnabled(
2311 langModule->languagePackageCO->itemData(i).toString() == "custom");
2315 void GuiDocument::biblioChanged()
2317 biblioChanged_ = true;
2322 void GuiDocument::rescanBibFiles()
2325 rescanTexStyles("bbx cbx");
2327 rescanTexStyles("bst");
2331 void GuiDocument::resetDefaultBibfile(string const & which)
2333 QString const engine =
2334 biblioModule->citeEngineCO->itemData(
2335 biblioModule->citeEngineCO->currentIndex()).toString();
2337 CiteEngineType const cet =
2338 CiteEngineType(biblioModule->citeStyleCO->itemData(
2339 biblioModule->citeStyleCO->currentIndex()).toInt());
2341 updateDefaultBiblio(theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet), which);
2345 void GuiDocument::resetDefaultBbxBibfile()
2347 resetDefaultBibfile("bbx");
2351 void GuiDocument::resetDefaultCbxBibfile()
2353 resetDefaultBibfile("cbx");
2357 void GuiDocument::citeEngineChanged(int n)
2359 QString const engine =
2360 biblioModule->citeEngineCO->itemData(n).toString();
2362 vector<string> const engs =
2363 theCiteEnginesList[fromqstr(engine)]->getEngineType();
2365 updateCiteStyles(engs);
2366 updateEngineDependends();
2367 resetDefaultBibfile();
2372 void GuiDocument::updateEngineDependends()
2374 bool const biblatex = isBiblatex();
2376 // These are only useful with BibTeX
2377 biblioModule->defaultBiblioCO->setEnabled(!biblatex);
2378 biblioModule->bibtexStyleLA->setEnabled(!biblatex);
2379 biblioModule->resetDefaultBiblioPB->setEnabled(!biblatex);
2380 biblioModule->bibtopicCB->setEnabled(!biblatex);
2382 // These are only useful with Biblatex
2383 biblioModule->biblatexBbxCO->setEnabled(biblatex);
2384 biblioModule->biblatexBbxLA->setEnabled(biblatex);
2385 biblioModule->biblatexCbxCO->setEnabled(biblatex);
2386 biblioModule->biblatexCbxLA->setEnabled(biblatex);
2387 biblioModule->resetBbxPB->setEnabled(biblatex);
2388 biblioModule->resetCbxPB->setEnabled(biblatex);
2389 biblioModule->matchBbxPB->setEnabled(biblatex);
2391 // These are useful with biblatex, jurabib and natbib
2392 QString const engine =
2393 biblioModule->citeEngineCO->itemData(
2394 biblioModule->citeEngineCO->currentIndex()).toString();
2395 LyXCiteEngine const * ce = theCiteEnginesList[fromqstr(engine)];
2397 bool const citepack = ce->requires("biblatex.sty") || ce->requires("jurabib.sty")
2398 || ce->requires("natbib.sty");
2399 biblioModule->citePackageOptionsLE->setEnabled(citepack);
2400 biblioModule->citePackageOptionsL->setEnabled(citepack);
2404 void GuiDocument::citeStyleChanged()
2406 QString const engine =
2407 biblioModule->citeEngineCO->itemData(
2408 biblioModule->citeEngineCO->currentIndex()).toString();
2409 QString const currentDef = isBiblatex() ?
2410 biblioModule->biblatexBbxCO->currentText()
2411 : biblioModule->defaultBiblioCO->currentText();
2412 if (theCiteEnginesList[fromqstr(engine)]->isDefaultBiblio(fromqstr(currentDef)))
2413 resetDefaultBibfile();
2419 void GuiDocument::bibtexChanged(int n)
2421 biblioModule->bibtexOptionsLE->setEnabled(
2422 biblioModule->bibtexCO->itemData(n).toString() != "default");
2427 void GuiDocument::updateCiteStyles(vector<string> const & engs, CiteEngineType const & sel)
2429 biblioModule->citeStyleCO->clear();
2431 vector<string>::const_iterator it = engs.begin();
2432 vector<string>::const_iterator end = engs.end();
2433 for (; it != end; ++it) {
2434 if (*it == "default")
2435 biblioModule->citeStyleCO->addItem(qt_("Basic numerical"),
2436 ENGINE_TYPE_DEFAULT);
2437 else if (*it == "authoryear")
2438 biblioModule->citeStyleCO->addItem(qt_("Author-year"),
2439 ENGINE_TYPE_AUTHORYEAR);
2440 else if (*it == "numerical")
2441 biblioModule->citeStyleCO->addItem(qt_("Author-number"),
2442 ENGINE_TYPE_NUMERICAL);
2444 int i = biblioModule->citeStyleCO->findData(sel);
2445 if (biblioModule->citeStyleCO->findData(sel) == -1)
2447 biblioModule->citeStyleCO->setCurrentIndex(i);
2449 biblioModule->citationStyleL->setEnabled(engs.size() > 1);
2450 biblioModule->citeStyleCO->setEnabled(engs.size() > 1);
2454 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2456 engine_types_.clear();
2460 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2462 string style = token(items, '|', n);
2463 engine_types_.push_back(style);
2466 updateCiteStyles(engine_types_, sel);
2472 // both of these should take a vector<docstring>
2474 // This is an insanely complicated attempt to make this sort of thing
2475 // work with RTL languages.
2476 docstring formatStrVec(vector<string> const & v, docstring const & s)
2478 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2482 return translateIfPossible(from_utf8(v[0]));
2483 if (v.size() == 2) {
2484 docstring retval = _("%1$s and %2$s");
2485 retval = subst(retval, _("and"), s);
2486 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2487 translateIfPossible(from_utf8(v[1])));
2489 // The idea here is to format all but the last two items...
2490 int const vSize = v.size();
2491 docstring t2 = _("%1$s, %2$s");
2492 docstring retval = translateIfPossible(from_utf8(v[0]));
2493 for (int i = 1; i < vSize - 2; ++i)
2494 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2495 //...and then to plug them, and the last two, into this schema
2496 docstring t = _("%1$s, %2$s, and %3$s");
2497 t = subst(t, _("and"), s);
2498 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2499 translateIfPossible(from_utf8(v[vSize - 1])));
2502 vector<string> idsToNames(vector<string> const & idList)
2504 vector<string> retval;
2505 vector<string>::const_iterator it = idList.begin();
2506 vector<string>::const_iterator end = idList.end();
2507 for (; it != end; ++it) {
2508 LyXModule const * const mod = theModuleList[*it];
2510 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2511 translateIfPossible(from_utf8(*it)))));
2513 retval.push_back(mod->getName());
2517 } // end anonymous namespace
2520 void GuiDocument::modulesToParams(BufferParams & bp)
2522 // update list of loaded modules
2523 bp.clearLayoutModules();
2524 int const srows = modules_sel_model_.rowCount();
2525 for (int i = 0; i < srows; ++i)
2526 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2528 // update the list of removed modules
2529 bp.clearRemovedModules();
2530 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2531 list<string>::const_iterator rit = reqmods.begin();
2532 list<string>::const_iterator ren = reqmods.end();
2534 // check each of the default modules
2535 for (; rit != ren; ++rit) {
2536 list<string>::const_iterator mit = bp.getModules().begin();
2537 list<string>::const_iterator men = bp.getModules().end();
2539 for (; mit != men; ++mit) {
2546 // the module isn't present so must have been removed by the user
2547 bp.addRemovedModule(*rit);
2552 void GuiDocument::modulesChanged()
2554 modulesToParams(bp_);
2556 if (applyPB->isEnabled() && nonModuleChanged_) {
2557 int const ret = Alert::prompt(_("Unapplied changes"),
2558 _("Some changes in the dialog were not yet applied.\n"
2559 "If you do not apply now, they will be lost after this action."),
2560 1, 1, _("&Apply"), _("&Dismiss"));
2565 bp_.makeDocumentClass();
2571 void GuiDocument::updateModuleInfo()
2573 selectionManager->update();
2575 //Module description
2576 bool const focus_on_selected = selectionManager->selectedFocused();
2577 QAbstractItemView * lv;
2578 if (focus_on_selected)
2579 lv = modulesModule->selectedLV;
2581 lv = modulesModule->availableLV;
2582 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2583 modulesModule->infoML->document()->clear();
2586 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2587 GuiIdListModel const & id_model =
2588 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2589 string const modName = id_model.getIDString(idx.row());
2590 docstring desc = getModuleDescription(modName);
2592 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2593 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2596 desc += _("Module provided by document class.");
2599 docstring cat = getModuleCategory(modName);
2603 desc += bformat(_("Category: %1$s."), cat);
2606 vector<string> pkglist = getPackageList(modName);
2607 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2608 if (!pkgdesc.empty()) {
2611 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2614 pkglist = getRequiredList(modName);
2615 if (!pkglist.empty()) {
2616 vector<string> const reqdescs = idsToNames(pkglist);
2617 pkgdesc = formatStrVec(reqdescs, _("or"));
2620 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2623 pkglist = getExcludedList(modName);
2624 if (!pkglist.empty()) {
2625 vector<string> const reqdescs = idsToNames(pkglist);
2626 pkgdesc = formatStrVec(reqdescs, _( "and"));
2629 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2632 if (!isModuleAvailable(modName)) {
2635 desc += _("WARNING: Some required packages are unavailable!");
2638 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2642 void GuiDocument::updateNumbering()
2644 DocumentClass const & tclass = documentClass();
2646 numberingModule->tocTW->setUpdatesEnabled(false);
2647 numberingModule->tocTW->clear();
2649 int const depth = numberingModule->depthSL->value();
2650 int const toc = numberingModule->tocSL->value();
2651 QString const no = qt_("No");
2652 QString const yes = qt_("Yes");
2653 QTreeWidgetItem * item = 0;
2655 DocumentClass::const_iterator lit = tclass.begin();
2656 DocumentClass::const_iterator len = tclass.end();
2657 for (; lit != len; ++lit) {
2658 int const toclevel = lit->toclevel;
2659 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2660 item = new QTreeWidgetItem(numberingModule->tocTW);
2661 item->setText(0, toqstr(translateIfPossible(lit->name())));
2662 item->setText(1, (toclevel <= depth) ? yes : no);
2663 item->setText(2, (toclevel <= toc) ? yes : no);
2667 numberingModule->tocTW->setUpdatesEnabled(true);
2668 numberingModule->tocTW->update();
2672 void GuiDocument::updateDefaultFormat()
2676 // make a copy in order to consider unapplied changes
2677 BufferParams param_copy = buffer().params();
2678 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2679 int const idx = latexModule->classCO->currentIndex();
2681 string const classname = fromqstr(latexModule->classCO->getData(idx));
2682 param_copy.setBaseClass(classname);
2683 param_copy.makeDocumentClass(true);
2685 outputModule->defaultFormatCO->blockSignals(true);
2686 outputModule->defaultFormatCO->clear();
2687 outputModule->defaultFormatCO->addItem(qt_("Default"),
2688 QVariant(QString("default")));
2689 FormatList const & formats =
2690 param_copy.exportableFormats(true);
2691 for (Format const * f : formats)
2692 outputModule->defaultFormatCO->addItem
2693 (toqstr(translateIfPossible(f->prettyname())),
2694 QVariant(toqstr(f->name())));
2695 outputModule->defaultFormatCO->blockSignals(false);
2699 bool GuiDocument::isChildIncluded(string const & child)
2701 if (includeonlys_.empty())
2703 return (std::find(includeonlys_.begin(),
2704 includeonlys_.end(), child) != includeonlys_.end());
2708 void GuiDocument::applyView()
2711 preambleModule->apply(bp_);
2712 localLayout->apply(bp_);
2715 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2716 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2719 string const engine =
2720 fromqstr(biblioModule->citeEngineCO->itemData(
2721 biblioModule->citeEngineCO->currentIndex()).toString());
2722 bp_.setCiteEngine(engine);
2724 CiteEngineType const style = CiteEngineType(biblioModule->citeStyleCO->itemData(
2725 biblioModule->citeStyleCO->currentIndex()).toInt());
2726 if (theCiteEnginesList[engine]->hasEngineType(style))
2727 bp_.setCiteEngineType(style);
2729 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2731 bp_.splitbib(biblioModule->bibtopicCB->isChecked());
2733 bp_.multibib = fromqstr(biblioModule->bibunitsCO->itemData(
2734 biblioModule->bibunitsCO->currentIndex()).toString());
2736 bp_.setDefaultBiblioStyle(fromqstr(biblioModule->defaultBiblioCO->currentText()));
2738 bp_.biblatex_bibstyle = fromqstr(biblioModule->biblatexBbxCO->currentText());
2739 bp_.biblatex_citestyle = fromqstr(biblioModule->biblatexCbxCO->currentText());
2740 bp_.biblio_opts = fromqstr(biblioModule->citePackageOptionsLE->text());
2742 string const bibtex_command =
2743 fromqstr(biblioModule->bibtexCO->itemData(
2744 biblioModule->bibtexCO->currentIndex()).toString());
2745 string const bibtex_options =
2746 fromqstr(biblioModule->bibtexOptionsLE->text());
2747 if (bibtex_command == "default" || bibtex_options.empty())
2748 bp_.bibtex_command = bibtex_command;
2750 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2752 if (biblioChanged_) {
2753 buffer().invalidateBibinfoCache();
2754 buffer().removeBiblioTempFiles();
2758 indicesModule->apply(bp_);
2760 // language & quotes
2761 if (langModule->defaultencodingRB->isChecked()) {
2762 bp_.inputenc = "auto";
2764 int i = langModule->encodingCO->currentIndex();
2766 bp_.inputenc = "default";
2768 QString const enc_gui =
2769 langModule->encodingCO->currentText();
2770 Encodings::const_iterator it = encodings.begin();
2771 Encodings::const_iterator const end = encodings.end();
2773 for (; it != end; ++it) {
2774 if (qt_(it->guiName()) == enc_gui &&
2776 bp_.inputenc = it->name();
2782 // should not happen
2783 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2784 bp_.inputenc = "default";
2789 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2790 langModule->quoteStyleCO->currentIndex()).toInt();
2791 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2793 QString const langname = langModule->languageCO->itemData(
2794 langModule->languageCO->currentIndex()).toString();
2795 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2796 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2797 // If current cursor language was the document language, then update it too.
2798 if (cur.current_font.language() == bp_.language) {
2799 cur.current_font.setLanguage(newlang);
2800 cur.real_current_font.setLanguage(newlang);
2802 bp_.language = newlang;
2804 QString const pack = langModule->languagePackageCO->itemData(
2805 langModule->languagePackageCO->currentIndex()).toString();
2806 if (pack == "custom")
2808 fromqstr(langModule->languagePackageLE->text());
2810 bp_.lang_package = fromqstr(pack);
2813 bp_.backgroundcolor = set_backgroundcolor;
2814 bp_.isbackgroundcolor = is_backgroundcolor;
2815 bp_.fontcolor = set_fontcolor;
2816 bp_.isfontcolor = is_fontcolor;
2817 bp_.notefontcolor = set_notefontcolor;
2818 bp_.boxbgcolor = set_boxbgcolor;
2821 if (bp_.documentClass().hasTocLevels()) {
2822 bp_.tocdepth = numberingModule->tocSL->value();
2823 bp_.secnumdepth = numberingModule->depthSL->value();
2827 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2828 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2829 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2830 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2833 bp_.graphics_driver =
2834 tex_graphics[latexModule->psdriverCO->currentIndex()];
2837 int idx = latexModule->classCO->currentIndex();
2839 string const classname = fromqstr(latexModule->classCO->getData(idx));
2840 bp_.setBaseClass(classname);
2844 modulesToParams(bp_);
2847 map<string, string> const & packages = BufferParams::auto_packages();
2848 for (map<string, string>::const_iterator it = packages.begin();
2849 it != packages.end(); ++it) {
2850 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2853 int row = mathsModule->packagesTW->row(item);
2854 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2855 if (rb->isChecked()) {
2856 bp_.use_package(it->first, BufferParams::package_auto);
2859 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2860 if (rb->isChecked()) {
2861 bp_.use_package(it->first, BufferParams::package_on);
2864 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2865 if (rb->isChecked())
2866 bp_.use_package(it->first, BufferParams::package_off);
2870 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2871 bp_.pagestyle = "default";
2873 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2874 for (size_t i = 0; i != pagestyles.size(); ++i)
2875 if (pagestyles[i].second == style_gui)
2876 bp_.pagestyle = pagestyles[i].first;
2880 switch (textLayoutModule->lspacingCO->currentIndex()) {
2882 bp_.spacing().set(Spacing::Single);
2885 bp_.spacing().set(Spacing::Onehalf);
2888 bp_.spacing().set(Spacing::Double);
2891 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2893 bp_.spacing().set(Spacing::Single);
2895 bp_.spacing().set(Spacing::Other, s);
2900 if (textLayoutModule->twoColumnCB->isChecked())
2905 bp_.justification = textLayoutModule->justCB->isChecked();
2907 if (textLayoutModule->indentRB->isChecked()) {
2908 // if paragraphs are separated by an indentation
2909 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2910 switch (textLayoutModule->indentCO->currentIndex()) {
2912 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2915 HSpace indent = HSpace(
2916 widgetsToLength(textLayoutModule->indentLE,
2917 textLayoutModule->indentLengthCO)
2919 bp_.setIndentation(indent);
2923 // this should never happen
2924 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2928 // if paragraphs are separated by a skip
2929 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2930 switch (textLayoutModule->skipCO->currentIndex()) {
2932 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2935 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2938 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2943 widgetsToLength(textLayoutModule->skipLE,
2944 textLayoutModule->skipLengthCO)
2950 // this should never happen
2951 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2957 fromqstr(latexModule->optionsLE->text());
2959 bp_.use_default_options =
2960 latexModule->defaultOptionsCB->isChecked();
2962 if (latexModule->childDocGB->isChecked())
2964 fromqstr(latexModule->childDocLE->text());
2966 bp_.master = string();
2969 bp_.clearIncludedChildren();
2970 if (masterChildModule->includeonlyRB->isChecked()) {
2971 list<string>::const_iterator it = includeonlys_.begin();
2972 for (; it != includeonlys_.end() ; ++it) {
2973 bp_.addIncludedChildren(*it);
2976 bp_.maintain_unincluded_children =
2977 masterChildModule->maintainAuxCB->isChecked();
2980 bp_.float_placement = floatModule->get();
2983 // text should have passed validation
2984 bp_.listings_params =
2985 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2988 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2989 outputModule->defaultFormatCO->currentIndex()).toString());
2991 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2992 bp_.useNonTeXFonts = nontexfonts;
2994 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2996 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2998 int mathfmt = outputModule->mathoutCB->currentIndex();
3001 BufferParams::MathOutput const mo =
3002 static_cast<BufferParams::MathOutput>(mathfmt);
3003 bp_.html_math_output = mo;
3004 bp_.html_be_strict = outputModule->strictCB->isChecked();
3005 bp_.html_css_as_file = outputModule->cssCB->isChecked();
3006 bp_.html_math_img_scale = outputModule->mathimgSB->value();
3007 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
3009 bp_.save_transient_properties =
3010 outputModule->saveTransientPropertiesCB->isChecked();
3013 bp_.fonts_roman[nontexfonts] =
3014 fromqstr(fontModule->fontsRomanCO->
3015 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
3016 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
3018 bp_.fonts_sans[nontexfonts] =
3019 fromqstr(fontModule->fontsSansCO->
3020 itemData(fontModule->fontsSansCO->currentIndex()).toString());
3021 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
3023 bp_.fonts_typewriter[nontexfonts] =
3024 fromqstr(fontModule->fontsTypewriterCO->
3025 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
3026 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
3028 bp_.fonts_math[nontexfonts] =
3029 fromqstr(fontModule->fontsMathCO->
3030 itemData(fontModule->fontsMathCO->currentIndex()).toString());
3031 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
3033 QString const fontenc =
3034 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
3035 if (fontenc == "custom")
3036 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
3038 bp_.fontenc = fromqstr(fontenc);
3041 fromqstr(fontModule->cjkFontLE->text());
3043 bp_.use_microtype = fontModule->microtypeCB->isChecked();
3045 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
3046 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
3048 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
3049 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
3051 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
3053 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
3056 bp_.fonts_default_family = "default";
3058 bp_.fonts_default_family = GuiDocument::fontfamilies[
3059 fontModule->fontsDefaultCO->currentIndex()];
3061 if (fontModule->fontsizeCO->currentIndex() == 0)
3062 bp_.fontsize = "default";
3065 fromqstr(fontModule->fontsizeCO->currentText());
3068 bp_.papersize = PAPER_SIZE(
3069 pageLayoutModule->papersizeCO->currentIndex());
3071 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
3072 pageLayoutModule->paperwidthUnitCO);
3074 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
3075 pageLayoutModule->paperheightUnitCO);
3077 if (pageLayoutModule->facingPagesCB->isChecked())
3078 bp_.sides = TwoSides;
3080 bp_.sides = OneSide;
3082 if (pageLayoutModule->landscapeRB->isChecked())
3083 bp_.orientation = ORIENTATION_LANDSCAPE;
3085 bp_.orientation = ORIENTATION_PORTRAIT;
3088 bp_.use_geometry = !marginsModule->marginCB->isChecked();
3090 Ui::MarginsUi const * m = marginsModule;
3092 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
3093 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
3094 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3095 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3096 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3097 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3098 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3099 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3102 branchesModule->apply(bp_);
3105 PDFOptions & pdf = bp_.pdfoptions();
3106 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3107 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3108 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3109 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3110 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3112 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3113 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3114 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3115 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3117 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3118 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3119 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3120 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3122 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3123 if (pdfSupportModule->fullscreenCB->isChecked())
3124 pdf.pagemode = pdf.pagemode_fullscreen;
3126 pdf.pagemode.clear();
3127 pdf.quoted_options = pdf.quoted_options_check(
3128 fromqstr(pdfSupportModule->optionsLE->text()));
3131 nonModuleChanged_ = false;
3135 void GuiDocument::paramsToDialog()
3137 // set the default unit
3138 Length::UNIT const default_unit = Length::defaultUnit();
3141 preambleModule->update(bp_, id());
3142 localLayout->update(bp_, id());
3145 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3146 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3149 string const cite_engine = bp_.citeEngine().list().front();
3151 biblioModule->citeEngineCO->setCurrentIndex(
3152 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3154 updateEngineType(documentClass().opt_enginetype(),
3155 bp_.citeEngineType());
3157 biblioModule->citeStyleCO->setCurrentIndex(
3158 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3160 biblioModule->bibtopicCB->setChecked(bp_.splitbib());
3162 biblioModule->bibunitsCO->clear();
3163 biblioModule->bibunitsCO->addItem(qt_("No"), QString());
3164 if (documentClass().hasLaTeXLayout("part"))
3165 biblioModule->bibunitsCO->addItem(qt_("per part"), toqstr("part"));
3166 if (documentClass().hasLaTeXLayout("chapter"))
3167 biblioModule->bibunitsCO->addItem(qt_("per chapter"), toqstr("chapter"));
3168 if (documentClass().hasLaTeXLayout("section"))
3169 biblioModule->bibunitsCO->addItem(qt_("per section"), toqstr("section"));
3170 if (documentClass().hasLaTeXLayout("subsection"))
3171 biblioModule->bibunitsCO->addItem(qt_("per subsection"), toqstr("subsection"));
3173 int const mbpos = biblioModule->bibunitsCO->findData(toqstr(bp_.multibib));
3175 biblioModule->bibunitsCO->setCurrentIndex(mbpos);
3177 biblioModule->bibunitsCO->setCurrentIndex(0);
3179 updateEngineDependends();
3182 updateDefaultBiblio(bp_.biblatex_bibstyle, "bbx");
3183 updateDefaultBiblio(bp_.biblatex_citestyle, "cbx");
3185 updateDefaultBiblio(bp_.defaultBiblioStyle());
3187 biblioModule->citePackageOptionsLE->setText(toqstr(bp_.biblio_opts));
3191 split(bp_.bibtex_command, command, ' ');
3193 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3195 biblioModule->bibtexCO->setCurrentIndex(bpos);
3196 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3198 // We reset to default if we do not know the specified compiler
3199 // This is for security reasons
3200 biblioModule->bibtexCO->setCurrentIndex(
3201 biblioModule->bibtexCO->findData(toqstr("default")));
3202 biblioModule->bibtexOptionsLE->clear();
3204 biblioModule->bibtexOptionsLE->setEnabled(
3205 biblioModule->bibtexCO->currentIndex() != 0);
3207 biblioChanged_ = false;
3210 // We may be called when there is no Buffer, e.g., when
3211 // the last view has just been closed.
3212 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3213 indicesModule->update(bp_, isReadOnly);
3215 // language & quotes
3216 int const pos = langModule->languageCO->findData(toqstr(
3217 bp_.language->lang()));
3218 langModule->languageCO->setCurrentIndex(pos);
3220 updateQuoteStyles();
3222 langModule->quoteStyleCO->setCurrentIndex(
3223 langModule->quoteStyleCO->findData(bp_.quotes_style));
3224 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3226 bool default_enc = true;
3227 if (bp_.inputenc != "auto") {
3228 default_enc = false;
3229 if (bp_.inputenc == "default") {
3230 langModule->encodingCO->setCurrentIndex(0);
3233 Encodings::const_iterator it = encodings.begin();
3234 Encodings::const_iterator const end = encodings.end();
3235 for (; it != end; ++it) {
3236 if (it->name() == bp_.inputenc &&
3238 enc_gui = it->guiName();
3242 int const i = langModule->encodingCO->findText(
3245 langModule->encodingCO->setCurrentIndex(i);
3247 // unknown encoding. Set to default.
3251 langModule->defaultencodingRB->setChecked(default_enc);
3252 langModule->otherencodingRB->setChecked(!default_enc);
3254 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3256 langModule->languagePackageCO->setCurrentIndex(
3257 langModule->languagePackageCO->findData("custom"));
3258 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3260 langModule->languagePackageCO->setCurrentIndex(p);
3261 langModule->languagePackageLE->clear();
3265 if (bp_.isfontcolor) {
3266 colorModule->fontColorPB->setStyleSheet(
3267 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3269 set_fontcolor = bp_.fontcolor;
3270 is_fontcolor = bp_.isfontcolor;
3272 colorModule->noteFontColorPB->setStyleSheet(
3273 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3274 set_notefontcolor = bp_.notefontcolor;
3276 if (bp_.isbackgroundcolor) {
3277 colorModule->backgroundPB->setStyleSheet(
3278 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3280 set_backgroundcolor = bp_.backgroundcolor;
3281 is_backgroundcolor = bp_.isbackgroundcolor;
3283 colorModule->boxBackgroundPB->setStyleSheet(
3284 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3285 set_boxbgcolor = bp_.boxbgcolor;
3288 int const min_toclevel = documentClass().min_toclevel();
3289 int const max_toclevel = documentClass().max_toclevel();
3290 if (documentClass().hasTocLevels()) {
3291 numberingModule->setEnabled(true);
3292 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3293 numberingModule->depthSL->setMaximum(max_toclevel);
3294 numberingModule->depthSL->setValue(bp_.secnumdepth);
3295 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3296 numberingModule->tocSL->setMaximum(max_toclevel);
3297 numberingModule->tocSL->setValue(bp_.tocdepth);
3300 numberingModule->setEnabled(false);
3301 numberingModule->tocTW->clear();
3305 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3306 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3307 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3308 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3309 bulletsModule->init();
3312 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3314 latexModule->psdriverCO->setCurrentIndex(nitem);
3317 map<string, string> const & packages = BufferParams::auto_packages();
3318 for (map<string, string>::const_iterator it = packages.begin();
3319 it != packages.end(); ++it) {
3320 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3323 int row = mathsModule->packagesTW->row(item);
3324 switch (bp_.use_package(it->first)) {
3325 case BufferParams::package_off: {
3326 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3327 rb->setChecked(true);
3330 case BufferParams::package_on: {
3331 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3332 rb->setChecked(true);
3335 case BufferParams::package_auto: {
3336 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3337 rb->setChecked(true);
3343 switch (bp_.spacing().getSpace()) {
3344 case Spacing::Other: nitem = 3; break;
3345 case Spacing::Double: nitem = 2; break;
3346 case Spacing::Onehalf: nitem = 1; break;
3347 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3351 string const & layoutID = bp_.baseClassID();
3352 setLayoutComboByIDString(layoutID);
3354 updatePagestyle(documentClass().opt_pagestyle(),
3357 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3358 if (bp_.spacing().getSpace() == Spacing::Other) {
3359 doubleToWidget(textLayoutModule->lspacingLE,
3360 bp_.spacing().getValueAsString());
3364 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3365 textLayoutModule->indentRB->setChecked(true);
3366 string indentation = bp_.getIndentation().asLyXCommand();
3368 if (indentation != "default") {
3369 lengthToWidgets(textLayoutModule->indentLE,
3370 textLayoutModule->indentLengthCO,
3371 indentation, default_unit);
3374 textLayoutModule->indentCO->setCurrentIndex(indent);
3377 textLayoutModule->skipRB->setChecked(true);
3379 switch (bp_.getDefSkip().kind()) {
3380 case VSpace::SMALLSKIP:
3383 case VSpace::MEDSKIP:
3386 case VSpace::BIGSKIP:
3389 case VSpace::LENGTH:
3392 string const length = bp_.getDefSkip().asLyXCommand();
3393 lengthToWidgets(textLayoutModule->skipLE,
3394 textLayoutModule->skipLengthCO,
3395 length, default_unit);
3402 textLayoutModule->skipCO->setCurrentIndex(skip);
3406 textLayoutModule->twoColumnCB->setChecked(
3408 textLayoutModule->justCB->setChecked(bp_.justification);
3410 if (!bp_.options.empty()) {
3411 latexModule->optionsLE->setText(
3412 toqstr(bp_.options));
3414 latexModule->optionsLE->setText(QString());
3418 latexModule->defaultOptionsCB->setChecked(
3419 bp_.use_default_options);
3420 updateSelectedModules();
3421 selectionManager->updateProvidedModules(
3422 bp_.baseClass()->providedModules());
3423 selectionManager->updateExcludedModules(
3424 bp_.baseClass()->excludedModules());
3426 if (!documentClass().options().empty()) {
3427 latexModule->defaultOptionsLE->setText(
3428 toqstr(documentClass().options()));
3430 latexModule->defaultOptionsLE->setText(
3431 toqstr(_("[No options predefined]")));
3434 latexModule->defaultOptionsLE->setEnabled(
3435 bp_.use_default_options
3436 && !documentClass().options().empty());
3438 latexModule->defaultOptionsCB->setEnabled(
3439 !documentClass().options().empty());
3441 if (!bp_.master.empty()) {
3442 latexModule->childDocGB->setChecked(true);
3443 latexModule->childDocLE->setText(
3444 toqstr(bp_.master));
3446 latexModule->childDocLE->setText(QString());
3447 latexModule->childDocGB->setChecked(false);
3451 if (!bufferview() || !buffer().hasChildren()) {
3452 masterChildModule->childrenTW->clear();
3453 includeonlys_.clear();
3454 docPS->showPanel("Child Documents", false);
3455 if (docPS->isCurrentPanel("Child Documents"))
3456 docPS->setCurrentPanel("Document Class");
3458 docPS->showPanel("Child Documents", true);
3459 masterChildModule->setEnabled(true);
3460 includeonlys_ = bp_.getIncludedChildren();
3461 updateIncludeonlys();
3463 masterChildModule->maintainAuxCB->setChecked(
3464 bp_.maintain_unincluded_children);
3467 floatModule->set(bp_.float_placement);
3470 // break listings_params to multiple lines
3472 InsetListingsParams(bp_.listings_params).separatedParams();
3473 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3476 // some languages only work with polyglossia/XeTeX
3477 Language const * lang = lyx::languages.getLanguage(
3478 fromqstr(langModule->languageCO->itemData(
3479 langModule->languageCO->currentIndex()).toString()));
3480 bool const need_fontspec =
3481 lang->babel().empty() && !lang->polyglossia().empty();
3482 bool const os_fonts_available =
3483 bp_.baseClass()->outputType() == lyx::LATEX
3484 && LaTeXFeatures::isAvailable("fontspec");
3485 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3486 fontModule->osFontsCB->setChecked(
3487 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3488 updateFontsize(documentClass().opt_fontsize(),
3491 QString font = toqstr(bp_.fontsRoman());
3492 int rpos = fontModule->fontsRomanCO->findData(font);
3494 rpos = fontModule->fontsRomanCO->count();
3495 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3497 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3498 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3500 font = toqstr(bp_.fontsSans());
3501 int spos = fontModule->fontsSansCO->findData(font);
3503 spos = fontModule->fontsSansCO->count();
3504 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3506 fontModule->fontsSansCO->setCurrentIndex(spos);
3507 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3509 font = toqstr(bp_.fontsTypewriter());
3510 int tpos = fontModule->fontsTypewriterCO->findData(font);
3512 tpos = fontModule->fontsTypewriterCO->count();
3513 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3515 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3516 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3518 font = toqstr(bp_.fontsMath());
3519 int mpos = fontModule->fontsMathCO->findData(font);
3521 mpos = fontModule->fontsMathCO->count();
3522 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3524 fontModule->fontsMathCO->setCurrentIndex(mpos);
3525 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3527 if (bp_.useNonTeXFonts && os_fonts_available) {
3528 fontModule->fontencLA->setEnabled(false);
3529 fontModule->fontencCO->setEnabled(false);
3530 fontModule->fontencLE->setEnabled(false);
3532 fontModule->fontencLA->setEnabled(true);
3533 fontModule->fontencCO->setEnabled(true);
3534 fontModule->fontencLE->setEnabled(true);
3540 if (!bp_.fonts_cjk.empty())
3541 fontModule->cjkFontLE->setText(
3542 toqstr(bp_.fonts_cjk));
3544 fontModule->cjkFontLE->setText(QString());
3546 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3548 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3549 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3550 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3551 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3552 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3553 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3555 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3557 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3559 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3560 fontModule->fontencCO->setCurrentIndex(
3561 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3562 fontModule->fontencLE->setEnabled(false);
3564 fontModule->fontencCO->setCurrentIndex(1);
3565 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3569 // This must be set _after_ fonts since updateDefaultFormat()
3570 // checks osFontsCB settings.
3571 // update combobox with formats
3572 updateDefaultFormat();
3573 int index = outputModule->defaultFormatCO->findData(toqstr(
3574 bp_.default_output_format));
3575 // set to default if format is not found
3578 outputModule->defaultFormatCO->setCurrentIndex(index);
3580 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3581 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3583 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3584 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3585 outputModule->strictCB->setChecked(bp_.html_be_strict);
3586 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3588 outputModule->saveTransientPropertiesCB
3589 ->setChecked(bp_.save_transient_properties);
3592 bool const extern_geometry =
3593 documentClass().provides("geometry");
3594 int const psize = bp_.papersize;
3595 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3596 setCustomPapersize(!extern_geometry && psize == 1);
3597 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3599 bool const landscape =
3600 bp_.orientation == ORIENTATION_LANDSCAPE;
3601 pageLayoutModule->landscapeRB->setChecked(landscape);
3602 pageLayoutModule->portraitRB->setChecked(!landscape);
3603 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3604 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3606 pageLayoutModule->facingPagesCB->setChecked(
3607 bp_.sides == TwoSides);
3609 lengthToWidgets(pageLayoutModule->paperwidthLE,
3610 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3611 lengthToWidgets(pageLayoutModule->paperheightLE,
3612 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3615 Ui::MarginsUi * m = marginsModule;
3619 lengthToWidgets(m->topLE, m->topUnit,
3620 bp_.topmargin, default_unit);
3622 lengthToWidgets(m->bottomLE, m->bottomUnit,
3623 bp_.bottommargin, default_unit);
3625 lengthToWidgets(m->innerLE, m->innerUnit,
3626 bp_.leftmargin, default_unit);
3628 lengthToWidgets(m->outerLE, m->outerUnit,
3629 bp_.rightmargin, default_unit);
3631 lengthToWidgets(m->headheightLE, m->headheightUnit,
3632 bp_.headheight, default_unit);
3634 lengthToWidgets(m->headsepLE, m->headsepUnit,
3635 bp_.headsep, default_unit);
3637 lengthToWidgets(m->footskipLE, m->footskipUnit,
3638 bp_.footskip, default_unit);
3640 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3641 bp_.columnsep, default_unit);
3644 updateUnknownBranches();
3645 branchesModule->update(bp_);
3648 PDFOptions const & pdf = bp_.pdfoptions();
3649 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3650 if (bp_.documentClass().provides("hyperref"))
3651 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3653 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3654 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3655 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3656 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3657 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3659 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3660 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3661 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3663 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3665 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3666 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3667 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3668 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3670 nn = findToken(backref_opts, pdf.backref);
3672 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3674 pdfSupportModule->fullscreenCB->setChecked
3675 (pdf.pagemode == pdf.pagemode_fullscreen);
3677 pdfSupportModule->optionsLE->setText(
3678 toqstr(pdf.quoted_options));
3680 // Make sure that the bc is in the INITIAL state
3681 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3684 // clear changed branches cache
3685 changedBranches_.clear();
3688 nonModuleChanged_ = false;
3692 void GuiDocument::saveDocDefault()
3694 // we have to apply the params first
3700 void GuiDocument::updateAvailableModules()
3702 modules_av_model_.clear();
3703 list<modInfoStruct> modInfoList = getModuleInfo();
3704 // Sort names according to the locale
3705 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3706 return 0 < b.name.localeAwareCompare(a.name);
3709 for (modInfoStruct const & m : modInfoList) {
3710 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3716 void GuiDocument::updateSelectedModules()
3718 modules_sel_model_.clear();
3719 list<modInfoStruct> const selModList = getSelectedModules();
3721 for (modInfoStruct const & m : selModList) {
3722 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3728 void GuiDocument::updateIncludeonlys()
3730 masterChildModule->childrenTW->clear();
3731 QString const no = qt_("No");
3732 QString const yes = qt_("Yes");
3734 if (includeonlys_.empty()) {
3735 masterChildModule->includeallRB->setChecked(true);
3736 masterChildModule->childrenTW->setEnabled(false);
3737 masterChildModule->maintainAuxCB->setEnabled(false);
3739 masterChildModule->includeonlyRB->setChecked(true);
3740 masterChildModule->childrenTW->setEnabled(true);
3741 masterChildModule->maintainAuxCB->setEnabled(true);
3743 ListOfBuffers children = buffer().getChildren();
3744 ListOfBuffers::const_iterator it = children.begin();
3745 ListOfBuffers::const_iterator end = children.end();
3746 bool has_unincluded = false;
3747 bool all_unincluded = true;
3748 for (; it != end; ++it) {
3749 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3752 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3753 from_utf8(buffer().filePath())));
3754 item->setText(0, toqstr(name));
3755 item->setText(1, isChildIncluded(name) ? yes : no);
3756 if (!isChildIncluded(name))
3757 has_unincluded = true;
3759 all_unincluded = false;
3761 // Both if all childs are included and if none is included
3762 // is equal to "include all" (i.e., ommit \includeonly).
3763 // Thus, reset the GUI.
3764 if (!has_unincluded || all_unincluded) {
3765 masterChildModule->includeallRB->setChecked(true);
3766 masterChildModule->childrenTW->setEnabled(false);
3767 includeonlys_.clear();
3769 // If all are included, we need to update again.
3770 if (!has_unincluded)
3771 updateIncludeonlys();
3775 bool GuiDocument::isBiblatex() const
3777 QString const engine =
3778 biblioModule->citeEngineCO->itemData(
3779 biblioModule->citeEngineCO->currentIndex()).toString();
3781 return theCiteEnginesList[fromqstr(engine)]->getCiteFramework() == "biblatex";
3785 void GuiDocument::updateDefaultBiblio(string const & style,
3786 string const & which)
3788 QString const bibstyle = toqstr(style);
3789 biblioModule->defaultBiblioCO->clear();
3794 if (which != "cbx") {
3795 // First the bbx styles
3796 biblioModule->biblatexBbxCO->clear();
3797 QStringList str = texFileList("bbxFiles.lst");
3798 // test whether we have a valid list, otherwise run rescan
3799 if (str.isEmpty()) {
3800 rescanTexStyles("bbx");
3801 str = texFileList("bbxFiles.lst");
3803 for (int i = 0; i != str.size(); ++i)
3804 str[i] = onlyFileName(str[i]);
3805 // sort on filename only (no path)
3808 for (int i = 0; i != str.count(); ++i) {
3809 QString item = changeExtension(str[i], "");
3810 if (item == bibstyle)
3812 biblioModule->biblatexBbxCO->addItem(item);
3815 if (item_nr == -1 && !bibstyle.isEmpty()) {
3816 biblioModule->biblatexBbxCO->addItem(bibstyle);
3817 item_nr = biblioModule->biblatexBbxCO->count() - 1;
3821 biblioModule->biblatexBbxCO->setCurrentIndex(item_nr);
3823 biblioModule->biblatexBbxCO->clearEditText();
3826 if (which != "bbx") {
3827 // now the cbx styles
3828 biblioModule->biblatexCbxCO->clear();
3829 QStringList str = texFileList("cbxFiles.lst");
3830 // test whether we have a valid list, otherwise run rescan
3831 if (str.isEmpty()) {
3832 rescanTexStyles("cbx");
3833 str = texFileList("cbxFiles.lst");
3835 for (int i = 0; i != str.size(); ++i)
3836 str[i] = onlyFileName(str[i]);
3837 // sort on filename only (no path)
3840 for (int i = 0; i != str.count(); ++i) {
3841 QString item = changeExtension(str[i], "");
3842 if (item == bibstyle)
3844 biblioModule->biblatexCbxCO->addItem(item);
3847 if (item_nr == -1 && !bibstyle.isEmpty()) {
3848 biblioModule->biblatexCbxCO->addItem(bibstyle);
3849 item_nr = biblioModule->biblatexCbxCO->count() - 1;
3853 biblioModule->biblatexCbxCO->setCurrentIndex(item_nr);
3855 biblioModule->biblatexCbxCO->clearEditText();
3858 biblioModule->biblatexBbxCO->clear();
3859 biblioModule->biblatexCbxCO->clear();
3860 QStringList str = texFileList("bstFiles.lst");
3861 // test whether we have a valid list, otherwise run rescan
3862 if (str.isEmpty()) {
3863 rescanTexStyles("bst");
3864 str = texFileList("bstFiles.lst");
3866 for (int i = 0; i != str.size(); ++i)
3867 str[i] = onlyFileName(str[i]);
3868 // sort on filename only (no path)
3871 for (int i = 0; i != str.count(); ++i) {
3872 QString item = changeExtension(str[i], "");
3873 if (item == bibstyle)
3875 biblioModule->defaultBiblioCO->addItem(item);
3878 if (item_nr == -1 && !bibstyle.isEmpty()) {
3879 biblioModule->defaultBiblioCO->addItem(bibstyle);
3880 item_nr = biblioModule->defaultBiblioCO->count() - 1;
3884 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
3886 biblioModule->defaultBiblioCO->clearEditText();
3889 updateResetDefaultBiblio();
3893 void GuiDocument::updateResetDefaultBiblio()
3895 QString const engine =
3896 biblioModule->citeEngineCO->itemData(
3897 biblioModule->citeEngineCO->currentIndex()).toString();
3898 CiteEngineType const cet =
3899 CiteEngineType(biblioModule->citeStyleCO->itemData(
3900 biblioModule->citeStyleCO->currentIndex()).toInt());
3902 string const defbib = theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet);
3904 QString const bbx = biblioModule->biblatexBbxCO->currentText();
3905 QString const cbx = biblioModule->biblatexCbxCO->currentText();
3906 biblioModule->resetCbxPB->setEnabled(defbib != fromqstr(cbx));
3907 biblioModule->resetBbxPB->setEnabled(defbib != fromqstr(bbx));
3908 biblioModule->matchBbxPB->setEnabled(bbx != cbx && !cbx.isEmpty()
3909 && biblioModule->biblatexBbxCO->findText(cbx) != -1);
3911 biblioModule->resetDefaultBiblioPB->setEnabled(
3912 defbib != fromqstr(biblioModule->defaultBiblioCO->currentText()));
3916 void GuiDocument::matchBiblatexStyles()
3918 updateDefaultBiblio(fromqstr(biblioModule->biblatexCbxCO->currentText()), "bbx");
3923 void GuiDocument::updateContents()
3925 // Nothing to do here as the document settings is not cursor dependant.
3930 void GuiDocument::useClassDefaults()
3932 if (applyPB->isEnabled()) {
3933 int const ret = Alert::prompt(_("Unapplied changes"),
3934 _("Some changes in the dialog were not yet applied.\n"
3935 "If you do not apply now, they will be lost after this action."),
3936 1, 1, _("&Apply"), _("&Dismiss"));
3941 int idx = latexModule->classCO->currentIndex();
3942 string const classname = fromqstr(latexModule->classCO->getData(idx));
3943 if (!bp_.setBaseClass(classname)) {
3944 Alert::error(_("Error"), _("Unable to set document class."));
3947 bp_.useClassDefaults();
3952 void GuiDocument::setLayoutComboByIDString(string const & idString)
3954 if (!latexModule->classCO->set(toqstr(idString)))
3955 Alert::warning(_("Can't set layout!"),
3956 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3960 bool GuiDocument::isValid()
3963 validateListingsParameters().isEmpty() &&
3964 localLayout->isValid() &&
3966 // if we're asking for skips between paragraphs
3967 !textLayoutModule->skipRB->isChecked() ||
3968 // then either we haven't chosen custom
3969 textLayoutModule->skipCO->currentIndex() != 3 ||
3970 // or else a length has been given
3971 !textLayoutModule->skipLE->text().isEmpty()
3974 // if we're asking for indentation
3975 !textLayoutModule->indentRB->isChecked() ||
3976 // then either we haven't chosen custom
3977 textLayoutModule->indentCO->currentIndex() != 1 ||
3978 // or else a length has been given
3979 !textLayoutModule->indentLE->text().isEmpty()
3984 char const * const GuiDocument::fontfamilies[5] = {
3985 "default", "rmdefault", "sfdefault", "ttdefault", ""
3989 char const * GuiDocument::fontfamilies_gui[5] = {
3990 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3994 bool GuiDocument::initialiseParams(string const &)
3996 BufferView const * view = bufferview();
3998 bp_ = BufferParams();
4002 bp_ = view->buffer().params();
4004 updateAvailableModules();
4005 //FIXME It'd be nice to make sure here that the selected
4006 //modules are consistent: That required modules are actually
4007 //selected, and that we don't have conflicts. If so, we could
4008 //at least pop up a warning.
4014 void GuiDocument::clearParams()
4016 bp_ = BufferParams();
4020 BufferId GuiDocument::id() const
4022 BufferView const * const view = bufferview();
4023 return view? &view->buffer() : 0;
4027 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
4029 return moduleNames_;
4033 list<GuiDocument::modInfoStruct> const
4034 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
4036 list<modInfoStruct> mInfo;
4037 for (string const & name : mods) {
4039 LyXModule const * const mod = theModuleList[name];
4044 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
4052 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
4054 return makeModuleInfo(params().getModules());
4058 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
4060 return makeModuleInfo(params().baseClass()->providedModules());
4064 DocumentClass const & GuiDocument::documentClass() const
4066 return bp_.documentClass();
4070 static void dispatch_bufferparams(Dialog const & dialog,
4071 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
4074 ss << "\\begin_header\n";
4075 bp.writeFile(ss, buf);
4076 ss << "\\end_header\n";
4077 dialog.dispatch(FuncRequest(lfun, ss.str()));
4081 void GuiDocument::dispatchParams()
4083 // We need a non-const buffer object.
4084 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
4085 // There may be several undo records; group them (bug #8998)
4086 buf.undo().beginUndoGroup();
4088 // This must come first so that a language change is correctly noticed
4091 // Apply the BufferParams. Note that this will set the base class
4092 // and then update the buffer's layout.
4093 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
4095 if (!params().master.empty()) {
4096 FileName const master_file = support::makeAbsPath(params().master,
4097 support::onlyPath(buffer().absFileName()));
4098 if (isLyXFileName(master_file.absFileName())) {
4099 Buffer * master = checkAndLoadLyXFile(master_file);
4101 if (master->isChild(const_cast<Buffer *>(&buffer())))
4102 const_cast<Buffer &>(buffer()).setParent(master);
4104 Alert::warning(_("Assigned master does not include this file"),
4105 bformat(_("You must include this file in the document\n"
4106 "'%1$s' in order to use the master document\n"
4107 "feature."), from_utf8(params().master)));
4109 Alert::warning(_("Could not load master"),
4110 bformat(_("The master document '%1$s'\n"
4111 "could not be loaded."),
4112 from_utf8(params().master)));
4116 // Generate the colours requested by each new branch.
4117 BranchList & branchlist = params().branchlist();
4118 if (!branchlist.empty()) {
4119 BranchList::const_iterator it = branchlist.begin();
4120 BranchList::const_iterator const end = branchlist.end();
4121 for (; it != end; ++it) {
4122 docstring const & current_branch = it->branch();
4123 Branch const * branch = branchlist.find(current_branch);
4124 string const x11hexname = X11hexname(branch->color());
4125 // display the new color
4126 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
4127 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4130 // Open insets of selected branches, close deselected ones
4131 dispatch(FuncRequest(LFUN_INSET_FORALL,
4132 "Branch inset-toggle assign"));
4134 // rename branches in the document
4135 executeBranchRenaming();
4136 // and clear changed branches cache
4137 changedBranches_.clear();
4139 // Generate the colours requested by indices.
4140 IndicesList & indiceslist = params().indiceslist();
4141 if (!indiceslist.empty()) {
4142 IndicesList::const_iterator it = indiceslist.begin();
4143 IndicesList::const_iterator const end = indiceslist.end();
4144 for (; it != end; ++it) {
4145 docstring const & current_index = it->shortcut();
4146 Index const * index = indiceslist.findShortcut(current_index);
4147 string const x11hexname = X11hexname(index->color());
4148 // display the new color
4149 docstring const str = current_index + ' ' + from_ascii(x11hexname);
4150 dispatch(FuncRequest(LFUN_SET_COLOR, str));
4154 // If we used an LFUN, we would not need these two lines:
4155 BufferView * bv = const_cast<BufferView *>(bufferview());
4156 bv->processUpdateFlags(Update::Force | Update::FitCursor);
4158 // Don't forget to close the group. Note that it is important
4159 // to check that there is no early return in the method.
4160 buf.undo().endUndoGroup();
4164 void GuiDocument::setLanguage() const
4166 Language const * const newL = bp_.language;
4167 if (buffer().params().language == newL)
4170 string const & lang_name = newL->lang();
4171 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
4175 void GuiDocument::saveAsDefault() const
4177 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
4181 bool GuiDocument::providesOSF(QString const & font) const
4183 if (fontModule->osFontsCB->isChecked())
4184 // FIXME: we should check if the fonts really
4185 // have OSF support. But how?
4187 return theLaTeXFonts().getLaTeXFont(
4188 qstring_to_ucs4(font)).providesOSF(ot1(),
4194 bool GuiDocument::providesSC(QString const & font) const
4196 if (fontModule->osFontsCB->isChecked())
4198 return theLaTeXFonts().getLaTeXFont(
4199 qstring_to_ucs4(font)).providesSC(ot1(),
4205 bool GuiDocument::providesScale(QString const & font) const
4207 if (fontModule->osFontsCB->isChecked())
4209 return theLaTeXFonts().getLaTeXFont(
4210 qstring_to_ucs4(font)).providesScale(ot1(),
4216 bool GuiDocument::providesNoMath(QString const & font) const
4218 if (fontModule->osFontsCB->isChecked())
4220 return theLaTeXFonts().getLaTeXFont(
4221 qstring_to_ucs4(font)).providesNoMath(ot1(),
4226 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4228 if (fontModule->osFontsCB->isChecked())
4230 return theLaTeXFonts().getLaTeXFont(
4231 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4238 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4240 // FIXME Unicode: docstrings would be better for these parameters but this
4241 // change requires a lot of others
4244 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4245 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4246 // Find the first sentence of the description
4247 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4248 int pos = bf.toNextBoundary();
4251 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4252 // Tooltip is the desc followed by the module name
4253 m.description = QString("%1<i>%2</i>")
4254 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4260 void GuiDocument::loadModuleInfo()
4262 moduleNames_.clear();
4263 for (LyXModule const & mod : theModuleList)
4264 if (mod.category().substr(0, 8) != "Citation")
4265 moduleNames_.push_back(modInfo(mod));
4269 void GuiDocument::updateUnknownBranches()
4273 list<docstring> used_branches;
4274 buffer().getUsedBranches(used_branches);
4275 list<docstring>::const_iterator it = used_branches.begin();
4276 QStringList unknown_branches;
4277 for (; it != used_branches.end() ; ++it) {
4278 if (!buffer().params().branchlist().find(*it))
4279 unknown_branches.append(toqstr(*it));
4281 branchesModule->setUnknownBranches(unknown_branches);
4285 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4287 map<docstring, docstring>::iterator it = changedBranches_.begin();
4288 for (; it != changedBranches_.end() ; ++it) {
4289 if (it->second == oldname) {
4290 // branch has already been renamed
4291 it->second = newname;
4296 changedBranches_[oldname] = newname;
4300 void GuiDocument::executeBranchRenaming() const
4302 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4303 for (; it != changedBranches_.end() ; ++it) {
4304 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4305 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4310 void GuiDocument::allPackagesAuto()
4316 void GuiDocument::allPackagesAlways()
4322 void GuiDocument::allPackagesNot()
4328 void GuiDocument::allPackages(int col)
4330 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4331 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4332 rb->setChecked(true);
4337 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4340 } // namespace frontend
4343 #include "moc_GuiDocument.cpp"