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 for (int i = 0; i < quoteparams.stylescount(); ++i) {
1074 InsetQuotesParams::QuoteStyle qs = InsetQuotesParams::QuoteStyle(i);
1075 if (qs == InsetQuotesParams::DynamicQuotes)
1077 langModule->quoteStyleCO->addItem(toqstr(quoteparams.getGuiLabel(qs)), qs);
1080 langModule->languagePackageCO->addItem(
1081 qt_("Default"), toqstr("default"));
1082 langModule->languagePackageCO->addItem(
1083 qt_("Automatic"), toqstr("auto"));
1084 langModule->languagePackageCO->addItem(
1085 qt_("Always Babel"), toqstr("babel"));
1086 langModule->languagePackageCO->addItem(
1087 qt_("Custom"), toqstr("custom"));
1088 langModule->languagePackageCO->addItem(
1089 qt_("None[[language package]]"), toqstr("none"));
1093 colorModule = new UiWidget<Ui::ColorUi>;
1094 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1095 this, SLOT(changeFontColor()));
1096 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1097 this, SLOT(deleteFontColor()));
1098 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1099 this, SLOT(changeNoteFontColor()));
1100 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1101 this, SLOT(deleteNoteFontColor()));
1102 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1103 this, SLOT(changeBackgroundColor()));
1104 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1105 this, SLOT(deleteBackgroundColor()));
1106 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1107 this, SLOT(changeBoxBackgroundColor()));
1108 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1109 this, SLOT(deleteBoxBackgroundColor()));
1113 numberingModule = new UiWidget<Ui::NumberingUi>;
1114 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1115 this, SLOT(change_adaptor()));
1116 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1117 this, SLOT(change_adaptor()));
1118 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1119 this, SLOT(updateNumbering()));
1120 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1121 this, SLOT(updateNumbering()));
1122 numberingModule->tocTW->setColumnCount(3);
1123 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1124 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1125 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1126 setSectionResizeMode(numberingModule->tocTW->header(), QHeaderView::ResizeToContents);
1129 biblioModule = new UiWidget<Ui::BiblioUi>;
1130 connect(biblioModule->citeEngineCO, SIGNAL(activated(int)),
1131 this, SLOT(citeEngineChanged(int)));
1132 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1133 this, SLOT(citeStyleChanged()));
1134 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1135 this, SLOT(biblioChanged()));
1136 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1137 this, SLOT(bibtexChanged(int)));
1138 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1139 this, SLOT(biblioChanged()));
1140 connect(biblioModule->defaultBiblioCO, SIGNAL(activated(int)),
1141 this, SLOT(biblioChanged()));
1142 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1143 this, SLOT(biblioChanged()));
1144 connect(biblioModule->defaultBiblioCO, SIGNAL(editTextChanged(QString)),
1145 this, SLOT(updateResetDefaultBiblio()));
1146 connect(biblioModule->rescanBibliosPB, SIGNAL(clicked()),
1147 this, SLOT(rescanBibFiles()));
1148 connect(biblioModule->resetDefaultBiblioPB, SIGNAL(clicked()),
1149 this, SLOT(resetDefaultBibfile()));
1151 biblioModule->citeEngineCO->clear();
1152 for (LyXCiteEngine const & cet : theCiteEnginesList) {
1153 biblioModule->citeEngineCO->addItem(qt_(cet.getName()), toqstr(cet.getID()));
1154 int const i = biblioModule->citeEngineCO->findData(toqstr(cet.getID()));
1155 biblioModule->citeEngineCO->setItemData(i, qt_(cet.getDescription()),
1159 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1160 biblioModule->bibtexOptionsLE));
1161 biblioModule->defaultBiblioCO->lineEdit()->setValidator(new NoNewLineValidator(
1162 biblioModule->defaultBiblioCO->lineEdit()));
1164 // NOTE: we do not provide "custom" here for security reasons!
1165 biblioModule->bibtexCO->clear();
1166 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1167 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1168 it != lyxrc.bibtex_alternatives.end(); ++it) {
1169 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1170 biblioModule->bibtexCO->addItem(command, command);
1175 indicesModule = new GuiIndices;
1176 connect(indicesModule, SIGNAL(changed()),
1177 this, SLOT(change_adaptor()));
1181 mathsModule = new UiWidget<Ui::MathsUi>;
1182 QStringList headers;
1183 headers << qt_("Package") << qt_("Load automatically")
1184 << qt_("Load always") << qt_("Do not load");
1185 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1186 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1187 map<string, string> const & packages = BufferParams::auto_packages();
1188 mathsModule->packagesTW->setRowCount(packages.size());
1190 for (map<string, string>::const_iterator it = packages.begin();
1191 it != packages.end(); ++it) {
1192 docstring const package = from_ascii(it->first);
1193 QString autoTooltip = qt_(it->second);
1194 QString alwaysTooltip;
1195 if (package == "amsmath")
1197 qt_("The AMS LaTeX packages are always used");
1199 alwaysTooltip = toqstr(bformat(
1200 _("The LaTeX package %1$s is always used"),
1202 QString neverTooltip;
1203 if (package == "amsmath")
1205 qt_("The AMS LaTeX packages are never used");
1207 neverTooltip = toqstr(bformat(
1208 _("The LaTeX package %1$s is never used"),
1210 QRadioButton * autoRB = new QRadioButton(mathsModule);
1211 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1212 QRadioButton * neverRB = new QRadioButton(mathsModule);
1213 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1214 packageGroup->addButton(autoRB);
1215 packageGroup->addButton(alwaysRB);
1216 packageGroup->addButton(neverRB);
1217 autoRB->setToolTip(autoTooltip);
1218 alwaysRB->setToolTip(alwaysTooltip);
1219 neverRB->setToolTip(neverTooltip);
1220 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1221 mathsModule->packagesTW->setItem(i, 0, pack);
1222 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1223 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1224 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1226 connect(autoRB, SIGNAL(clicked()),
1227 this, SLOT(change_adaptor()));
1228 connect(alwaysRB, SIGNAL(clicked()),
1229 this, SLOT(change_adaptor()));
1230 connect(neverRB, SIGNAL(clicked()),
1231 this, SLOT(change_adaptor()));
1234 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1235 this, SLOT(allPackagesAuto()));
1236 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1237 this, SLOT(allPackagesAlways()));
1238 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1239 this, SLOT(allPackagesNot()));
1240 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1241 this, SLOT(change_adaptor()));
1242 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1243 this, SLOT(change_adaptor()));
1244 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1245 this, SLOT(change_adaptor()));
1249 latexModule = new UiWidget<Ui::LaTeXUi>;
1250 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1251 this, SLOT(change_adaptor()));
1252 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1253 this, SLOT(change_adaptor()));
1254 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1255 this, SLOT(change_adaptor()));
1256 connect(latexModule->classCO, SIGNAL(activated(int)),
1257 this, SLOT(classChanged_adaptor()));
1258 connect(latexModule->classCO, SIGNAL(activated(int)),
1259 this, SLOT(change_adaptor()));
1260 connect(latexModule->layoutPB, SIGNAL(clicked()),
1261 this, SLOT(browseLayout()));
1262 connect(latexModule->layoutPB, SIGNAL(clicked()),
1263 this, SLOT(change_adaptor()));
1264 connect(latexModule->childDocGB, SIGNAL(clicked()),
1265 this, SLOT(change_adaptor()));
1266 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1267 this, SLOT(change_adaptor()));
1268 connect(latexModule->childDocPB, SIGNAL(clicked()),
1269 this, SLOT(browseMaster()));
1270 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1271 this, SLOT(change_adaptor()));
1272 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1273 this, SLOT(change_adaptor()));
1275 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1276 latexModule->optionsLE));
1277 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1278 latexModule->childDocLE));
1280 // postscript drivers
1281 for (int n = 0; tex_graphics[n][0]; ++n) {
1282 QString enc = qt_(tex_graphics_gui[n]);
1283 latexModule->psdriverCO->addItem(enc);
1286 LayoutFileList const & bcl = LayoutFileList::get();
1287 vector<LayoutFileIndex> classList = bcl.classList();
1288 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1290 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1291 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1292 for (int i = 0; cit != cen; ++cit, ++i) {
1293 LayoutFile const & tc = bcl[*cit];
1294 bool const available = tc.isTeXClassAvailable();
1295 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1296 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1297 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1299 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1300 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1301 "Please check if you have the matching %1$s class "
1302 "and all required packages (%2$s) installed."),
1303 output_type, from_utf8(tc.prerequisites(", "))));
1305 latexModule->classCO->addItemSort(toqstr(tc.name()),
1307 toqstr(translateIfPossible(from_utf8(tc.category()))),
1309 true, true, true, available);
1314 branchesModule = new GuiBranches;
1315 connect(branchesModule, SIGNAL(changed()),
1316 this, SLOT(change_adaptor()));
1317 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1318 this, SLOT(branchesRename(docstring const &, docstring const &)));
1319 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1320 updateUnknownBranches();
1324 preambleModule = new PreambleModule;
1325 connect(preambleModule, SIGNAL(changed()),
1326 this, SLOT(change_adaptor()));
1328 localLayout = new LocalLayout;
1329 connect(localLayout, SIGNAL(changed()),
1330 this, SLOT(change_adaptor()));
1334 bulletsModule = new BulletsModule;
1335 connect(bulletsModule, SIGNAL(changed()),
1336 this, SLOT(change_adaptor()));
1340 modulesModule = new UiWidget<Ui::ModulesUi>;
1341 modulesModule->availableLV->header()->setVisible(false);
1342 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1343 modulesModule->availableLV->header()->setStretchLastSection(false);
1345 new ModuleSelectionManager(modulesModule->availableLV,
1346 modulesModule->selectedLV,
1347 modulesModule->addPB, modulesModule->deletePB,
1348 modulesModule->upPB, modulesModule->downPB,
1349 availableModel(), selectedModel(), this);
1350 connect(selectionManager, SIGNAL(updateHook()),
1351 this, SLOT(updateModuleInfo()));
1352 connect(selectionManager, SIGNAL(selectionChanged()),
1353 this, SLOT(modulesChanged()));
1357 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1358 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1359 this, SLOT(change_adaptor()));
1360 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1361 this, SLOT(change_adaptor()));
1362 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1363 this, SLOT(change_adaptor()));
1364 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1365 this, SLOT(change_adaptor()));
1366 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1367 this, SLOT(change_adaptor()));
1368 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1369 this, SLOT(change_adaptor()));
1370 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1371 this, SLOT(change_adaptor()));
1372 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1373 this, SLOT(change_adaptor()));
1374 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1375 this, SLOT(change_adaptor()));
1376 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1377 this, SLOT(change_adaptor()));
1378 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1379 this, SLOT(change_adaptor()));
1380 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1381 this, SLOT(change_adaptor()));
1382 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1383 this, SLOT(change_adaptor()));
1384 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1385 this, SLOT(change_adaptor()));
1386 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1387 this, SLOT(change_adaptor()));
1388 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1389 this, SLOT(change_adaptor()));
1391 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1392 pdfSupportModule->titleLE));
1393 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1394 pdfSupportModule->authorLE));
1395 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1396 pdfSupportModule->subjectLE));
1397 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1398 pdfSupportModule->keywordsLE));
1399 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1400 pdfSupportModule->optionsLE));
1402 for (int i = 0; backref_opts[i][0]; ++i)
1403 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1407 floatModule = new FloatPlacement;
1408 connect(floatModule, SIGNAL(changed()),
1409 this, SLOT(change_adaptor()));
1413 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1414 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1415 this, SLOT(change_adaptor()));
1416 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1417 this, SLOT(change_adaptor()));
1418 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1419 this, SLOT(setListingsMessage()));
1420 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1421 this, SLOT(setListingsMessage()));
1422 listingsModule->listingsTB->setPlainText(
1423 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1427 docPS->addPanel(latexModule, N_("Document Class"));
1428 docPS->addPanel(masterChildModule, N_("Child Documents"));
1429 docPS->addPanel(modulesModule, N_("Modules"));
1430 docPS->addPanel(localLayout, N_("Local Layout"));
1431 docPS->addPanel(fontModule, N_("Fonts"));
1432 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1433 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1434 docPS->addPanel(marginsModule, N_("Page Margins"));
1435 docPS->addPanel(langModule, N_("Language"));
1436 docPS->addPanel(colorModule, N_("Colors"));
1437 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1438 docPS->addPanel(biblioModule, N_("Bibliography"));
1439 docPS->addPanel(indicesModule, N_("Indexes"));
1440 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1441 docPS->addPanel(mathsModule, N_("Math Options"));
1442 docPS->addPanel(floatModule, N_("Float Placement"));
1443 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1444 docPS->addPanel(bulletsModule, N_("Bullets"));
1445 docPS->addPanel(branchesModule, N_("Branches"));
1446 docPS->addPanel(outputModule, N_("Formats[[output]]"));
1447 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1448 docPS->setCurrentPanel("Document Class");
1449 // FIXME: hack to work around resizing bug in Qt >= 4.2
1450 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1451 #if QT_VERSION >= 0x040200
1452 docPS->updateGeometry();
1457 void GuiDocument::onBufferViewChanged()
1459 if (isVisibleView())
1460 initialiseParams("");
1464 void GuiDocument::saveDefaultClicked()
1470 void GuiDocument::useDefaultsClicked()
1476 void GuiDocument::change_adaptor()
1478 nonModuleChanged_ = true;
1483 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1488 string child = fromqstr(item->text(0));
1492 if (std::find(includeonlys_.begin(),
1493 includeonlys_.end(), child) != includeonlys_.end())
1494 includeonlys_.remove(child);
1496 includeonlys_.push_back(child);
1498 updateIncludeonlys();
1503 QString GuiDocument::validateListingsParameters()
1505 if (listingsModule->bypassCB->isChecked())
1507 string params = fromqstr(listingsModule->listingsED->toPlainText());
1508 return toqstr(InsetListingsParams(params).validate());
1512 void GuiDocument::setListingsMessage()
1515 static bool isOK = true;
1516 QString msg = validateListingsParameters();
1517 if (msg.isEmpty()) {
1521 // listingsTB->setTextColor("black");
1522 listingsModule->listingsTB->setPlainText(
1523 qt_("Input listings parameters below. "
1524 "Enter ? for a list of parameters."));
1527 // listingsTB->setTextColor("red");
1528 listingsModule->listingsTB->setPlainText(msg);
1533 void GuiDocument::setLSpacing(int item)
1535 textLayoutModule->lspacingLE->setEnabled(item == 3);
1539 void GuiDocument::setIndent(int item)
1541 bool const enable = (item == 1);
1542 textLayoutModule->indentLE->setEnabled(enable);
1543 textLayoutModule->indentLengthCO->setEnabled(enable);
1544 textLayoutModule->skipLE->setEnabled(false);
1545 textLayoutModule->skipLengthCO->setEnabled(false);
1550 void GuiDocument::enableIndent(bool indent)
1552 textLayoutModule->skipLE->setEnabled(!indent);
1553 textLayoutModule->skipLengthCO->setEnabled(!indent);
1555 setIndent(textLayoutModule->indentCO->currentIndex());
1559 void GuiDocument::setSkip(int item)
1561 bool const enable = (item == 3);
1562 textLayoutModule->skipLE->setEnabled(enable);
1563 textLayoutModule->skipLengthCO->setEnabled(enable);
1568 void GuiDocument::enableSkip(bool skip)
1570 textLayoutModule->indentLE->setEnabled(!skip);
1571 textLayoutModule->indentLengthCO->setEnabled(!skip);
1573 setSkip(textLayoutModule->skipCO->currentIndex());
1577 void GuiDocument::setMargins()
1579 bool const extern_geometry =
1580 documentClass().provides("geometry");
1581 marginsModule->marginCB->setEnabled(!extern_geometry);
1582 if (extern_geometry) {
1583 marginsModule->marginCB->setChecked(false);
1584 setCustomMargins(true);
1586 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1587 setCustomMargins(!bp_.use_geometry);
1592 void GuiDocument::papersizeChanged(int paper_size)
1594 setCustomPapersize(paper_size == 1);
1598 void GuiDocument::setCustomPapersize(bool custom)
1600 pageLayoutModule->paperwidthL->setEnabled(custom);
1601 pageLayoutModule->paperwidthLE->setEnabled(custom);
1602 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1603 pageLayoutModule->paperheightL->setEnabled(custom);
1604 pageLayoutModule->paperheightLE->setEnabled(custom);
1605 pageLayoutModule->paperheightLE->setFocus();
1606 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1610 void GuiDocument::setColSep()
1612 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1616 void GuiDocument::setCustomMargins(bool custom)
1618 marginsModule->topL->setEnabled(!custom);
1619 marginsModule->topLE->setEnabled(!custom);
1620 marginsModule->topUnit->setEnabled(!custom);
1622 marginsModule->bottomL->setEnabled(!custom);
1623 marginsModule->bottomLE->setEnabled(!custom);
1624 marginsModule->bottomUnit->setEnabled(!custom);
1626 marginsModule->innerL->setEnabled(!custom);
1627 marginsModule->innerLE->setEnabled(!custom);
1628 marginsModule->innerUnit->setEnabled(!custom);
1630 marginsModule->outerL->setEnabled(!custom);
1631 marginsModule->outerLE->setEnabled(!custom);
1632 marginsModule->outerUnit->setEnabled(!custom);
1634 marginsModule->headheightL->setEnabled(!custom);
1635 marginsModule->headheightLE->setEnabled(!custom);
1636 marginsModule->headheightUnit->setEnabled(!custom);
1638 marginsModule->headsepL->setEnabled(!custom);
1639 marginsModule->headsepLE->setEnabled(!custom);
1640 marginsModule->headsepUnit->setEnabled(!custom);
1642 marginsModule->footskipL->setEnabled(!custom);
1643 marginsModule->footskipLE->setEnabled(!custom);
1644 marginsModule->footskipUnit->setEnabled(!custom);
1646 bool const enableColSep = !custom &&
1647 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1648 marginsModule->columnsepL->setEnabled(enableColSep);
1649 marginsModule->columnsepLE->setEnabled(enableColSep);
1650 marginsModule->columnsepUnit->setEnabled(enableColSep);
1654 void GuiDocument::changeBackgroundColor()
1656 QColor const & newColor = QColorDialog::getColor(
1657 rgb2qcolor(set_backgroundcolor), asQWidget());
1658 if (!newColor.isValid())
1660 // set the button color and text
1661 colorModule->backgroundPB->setStyleSheet(
1662 colorButtonStyleSheet(newColor));
1663 colorModule->backgroundPB->setText(qt_("&Change..."));
1665 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1666 is_backgroundcolor = true;
1671 void GuiDocument::deleteBackgroundColor()
1673 // set the button color back to default by setting an empty StyleSheet
1674 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1675 // change button text
1676 colorModule->backgroundPB->setText(qt_("&Default..."));
1677 // save default color (white)
1678 set_backgroundcolor = rgbFromHexName("#ffffff");
1679 is_backgroundcolor = false;
1684 void GuiDocument::changeFontColor()
1686 QColor const & newColor = QColorDialog::getColor(
1687 rgb2qcolor(set_fontcolor), asQWidget());
1688 if (!newColor.isValid())
1690 // set the button color and text
1691 colorModule->fontColorPB->setStyleSheet(
1692 colorButtonStyleSheet(newColor));
1693 colorModule->fontColorPB->setText(qt_("&Change..."));
1695 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1696 is_fontcolor = true;
1701 void GuiDocument::deleteFontColor()
1703 // set the button color back to default by setting an empty StyleSheet
1704 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1705 // change button text
1706 colorModule->fontColorPB->setText(qt_("&Default..."));
1707 // save default color (black)
1708 set_fontcolor = rgbFromHexName("#000000");
1709 is_fontcolor = false;
1714 void GuiDocument::changeNoteFontColor()
1716 QColor const & newColor = QColorDialog::getColor(
1717 rgb2qcolor(set_notefontcolor), asQWidget());
1718 if (!newColor.isValid())
1720 // set the button color
1721 colorModule->noteFontColorPB->setStyleSheet(
1722 colorButtonStyleSheet(newColor));
1724 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1729 void GuiDocument::deleteNoteFontColor()
1731 // set the button color back to pref
1732 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1733 colorModule->noteFontColorPB->setStyleSheet(
1734 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1739 void GuiDocument::changeBoxBackgroundColor()
1741 QColor const & newColor = QColorDialog::getColor(
1742 rgb2qcolor(set_boxbgcolor), asQWidget());
1743 if (!newColor.isValid())
1745 // set the button color
1746 colorModule->boxBackgroundPB->setStyleSheet(
1747 colorButtonStyleSheet(newColor));
1749 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1754 void GuiDocument::deleteBoxBackgroundColor()
1756 // set the button color back to pref
1757 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1758 colorModule->boxBackgroundPB->setStyleSheet(
1759 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1764 void GuiDocument::languageChanged(int i)
1766 // some languages only work with polyglossia
1767 Language const * lang = lyx::languages.getLanguage(
1768 fromqstr(langModule->languageCO->itemData(i).toString()));
1769 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1770 // If we force to switch fontspec on, store
1771 // current state (#8717)
1772 if (fontModule->osFontsCB->isEnabled())
1773 forced_fontspec_activation =
1774 !fontModule->osFontsCB->isChecked();
1775 fontModule->osFontsCB->setChecked(true);
1776 fontModule->osFontsCB->setEnabled(false);
1779 fontModule->osFontsCB->setEnabled(true);
1780 // If we have forced to switch fontspec on,
1781 // restore previous state (#8717)
1782 if (forced_fontspec_activation)
1783 fontModule->osFontsCB->setChecked(false);
1784 forced_fontspec_activation = false;
1787 // set appropriate quotation mark style
1788 if (!lang->quoteStyle().empty()) {
1789 langModule->quoteStyleCO->setCurrentIndex(
1790 bp_.getQuoteStyle(lang->quoteStyle()));
1795 void GuiDocument::osFontsChanged(bool nontexfonts)
1797 bool const tex_fonts = !nontexfonts;
1798 // store current fonts
1799 QString const font_roman = fontModule->fontsRomanCO->itemData(
1800 fontModule->fontsRomanCO->currentIndex()).toString();
1801 QString const font_sans = fontModule->fontsSansCO->itemData(
1802 fontModule->fontsSansCO->currentIndex()).toString();
1803 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1804 fontModule->fontsTypewriterCO->currentIndex()).toString();
1805 QString const font_math = fontModule->fontsMathCO->itemData(
1806 fontModule->fontsMathCO->currentIndex()).toString();
1807 int const font_sf_scale = fontModule->scaleSansSB->value();
1808 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1811 // store default format
1812 QString const dformat = outputModule->defaultFormatCO->itemData(
1813 outputModule->defaultFormatCO->currentIndex()).toString();
1814 updateDefaultFormat();
1815 // try to restore default format
1816 int index = outputModule->defaultFormatCO->findData(dformat);
1817 // set to default if format is not found
1820 outputModule->defaultFormatCO->setCurrentIndex(index);
1822 // try to restore fonts which were selected two toggles ago
1823 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1825 fontModule->fontsRomanCO->setCurrentIndex(index);
1826 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1828 fontModule->fontsSansCO->setCurrentIndex(index);
1829 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1831 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1832 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1834 fontModule->fontsMathCO->setCurrentIndex(index);
1835 // save fonts for next next toggle
1836 fontModule->font_roman = font_roman;
1837 fontModule->font_sans = font_sans;
1838 fontModule->font_typewriter = font_typewriter;
1839 fontModule->font_math = font_math;
1840 fontModule->font_sf_scale = font_sf_scale;
1841 fontModule->font_tt_scale = font_tt_scale;
1843 langModule->encodingCO->setEnabled(tex_fonts &&
1844 !langModule->defaultencodingRB->isChecked());
1845 langModule->defaultencodingRB->setEnabled(tex_fonts);
1846 langModule->otherencodingRB->setEnabled(tex_fonts);
1848 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1849 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1850 fontModule->cjkFontLE->setEnabled(tex_fonts);
1851 fontModule->cjkFontLA->setEnabled(tex_fonts);
1853 updateFontOptions();
1855 fontModule->fontencLA->setEnabled(tex_fonts);
1856 fontModule->fontencCO->setEnabled(tex_fonts);
1858 fontModule->fontencLE->setEnabled(false);
1860 fontencChanged(fontModule->fontencCO->currentIndex());
1864 void GuiDocument::mathFontChanged(int)
1866 updateFontOptions();
1870 void GuiDocument::fontOsfToggled(bool state)
1872 if (fontModule->osFontsCB->isChecked())
1874 QString font = fontModule->fontsRomanCO->itemData(
1875 fontModule->fontsRomanCO->currentIndex()).toString();
1876 if (hasMonolithicExpertSet(font))
1877 fontModule->fontScCB->setChecked(state);
1881 void GuiDocument::fontScToggled(bool state)
1883 if (fontModule->osFontsCB->isChecked())
1885 QString font = fontModule->fontsRomanCO->itemData(
1886 fontModule->fontsRomanCO->currentIndex()).toString();
1887 if (hasMonolithicExpertSet(font))
1888 fontModule->fontOsfCB->setChecked(state);
1892 void GuiDocument::updateFontOptions()
1894 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1897 font = fontModule->fontsSansCO->itemData(
1898 fontModule->fontsSansCO->currentIndex()).toString();
1899 bool scaleable = providesScale(font);
1900 fontModule->scaleSansSB->setEnabled(scaleable);
1901 fontModule->scaleSansLA->setEnabled(scaleable);
1903 font = fontModule->fontsTypewriterCO->itemData(
1904 fontModule->fontsTypewriterCO->currentIndex()).toString();
1905 scaleable = providesScale(font);
1906 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1907 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1909 font = fontModule->fontsRomanCO->itemData(
1910 fontModule->fontsRomanCO->currentIndex()).toString();
1911 fontModule->fontScCB->setEnabled(providesSC(font));
1912 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1913 updateMathFonts(font);
1917 void GuiDocument::updateFontsize(string const & items, string const & sel)
1919 fontModule->fontsizeCO->clear();
1920 fontModule->fontsizeCO->addItem(qt_("Default"));
1922 for (int n = 0; !token(items,'|',n).empty(); ++n)
1923 fontModule->fontsizeCO->
1924 addItem(toqstr(token(items,'|',n)));
1926 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1927 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1928 fontModule->fontsizeCO->setCurrentIndex(n);
1935 bool GuiDocument::ot1() const
1937 QString const fontenc =
1938 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
1939 return (fontenc == "default"
1940 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
1941 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
1945 bool GuiDocument::completeFontset() const
1947 return (fontModule->fontsSansCO->itemData(
1948 fontModule->fontsSansCO->currentIndex()).toString() == "default"
1949 && fontModule->fontsSansCO->itemData(
1950 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
1954 bool GuiDocument::noMathFont() const
1956 return (fontModule->fontsMathCO->itemData(
1957 fontModule->fontsMathCO->currentIndex()).toString() == "default");
1961 void GuiDocument::updateTexFonts()
1963 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
1965 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
1966 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
1967 for (; it != end; ++it) {
1968 LaTeXFont lf = it->second;
1969 if (lf.name().empty()) {
1970 LYXERR0("Error: Unnamed font: " << it->first);
1973 docstring const family = lf.family();
1974 docstring guiname = translateIfPossible(lf.guiname());
1975 if (!lf.available(ot1(), noMathFont()))
1976 guiname += _(" (not installed)");
1978 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
1979 else if (family == "sf")
1980 sffonts_.insert(toqstr(guiname), toqstr(it->first));
1981 else if (family == "tt")
1982 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
1983 else if (family == "math")
1984 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
1989 void GuiDocument::updateFontlist()
1991 fontModule->fontsRomanCO->clear();
1992 fontModule->fontsSansCO->clear();
1993 fontModule->fontsTypewriterCO->clear();
1994 fontModule->fontsMathCO->clear();
1996 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
1997 if (fontModule->osFontsCB->isChecked()) {
1998 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1999 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2000 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2001 QString unimath = qt_("Non-TeX Fonts Default");
2002 if (!LaTeXFeatures::isAvailable("unicode-math"))
2003 unimath += qt_(" (not available)");
2004 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
2005 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2007 QFontDatabase fontdb;
2008 QStringList families(fontdb.families());
2009 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2010 fontModule->fontsRomanCO->addItem(*it, *it);
2011 fontModule->fontsSansCO->addItem(*it, *it);
2012 fontModule->fontsTypewriterCO->addItem(*it, *it);
2017 if (rmfonts_.empty())
2020 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2021 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2022 while (rmi != rmfonts_.constEnd()) {
2023 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2027 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2028 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2029 while (sfi != sffonts_.constEnd()) {
2030 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2034 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2035 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2036 while (tti != ttfonts_.constEnd()) {
2037 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2041 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2042 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2043 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2044 while (mmi != mathfonts_.constEnd()) {
2045 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2051 void GuiDocument::fontencChanged(int item)
2053 fontModule->fontencLE->setEnabled(
2054 fontModule->fontencCO->itemData(item).toString() == "custom");
2055 // The availability of TeX fonts depends on the font encoding
2057 updateFontOptions();
2061 void GuiDocument::updateMathFonts(QString const & rm)
2063 if (fontModule->osFontsCB->isChecked())
2065 QString const math =
2066 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2067 int const i = fontModule->fontsMathCO->findData("default");
2068 if (providesNoMath(rm) && i == -1)
2069 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2070 else if (!providesNoMath(rm) && i != -1) {
2071 int const c = fontModule->fontsMathCO->currentIndex();
2072 fontModule->fontsMathCO->removeItem(i);
2074 fontModule->fontsMathCO->setCurrentIndex(0);
2079 void GuiDocument::romanChanged(int item)
2081 if (fontModule->osFontsCB->isChecked())
2083 QString const font =
2084 fontModule->fontsRomanCO->itemData(item).toString();
2085 fontModule->fontScCB->setEnabled(providesSC(font));
2086 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2087 updateMathFonts(font);
2091 void GuiDocument::sansChanged(int item)
2093 if (fontModule->osFontsCB->isChecked())
2095 QString const font =
2096 fontModule->fontsSansCO->itemData(item).toString();
2097 bool scaleable = providesScale(font);
2098 fontModule->scaleSansSB->setEnabled(scaleable);
2099 fontModule->scaleSansLA->setEnabled(scaleable);
2103 void GuiDocument::ttChanged(int item)
2105 if (fontModule->osFontsCB->isChecked())
2107 QString const font =
2108 fontModule->fontsTypewriterCO->itemData(item).toString();
2109 bool scaleable = providesScale(font);
2110 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2111 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2115 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2118 pageLayoutModule->pagestyleCO->clear();
2119 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2121 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2122 string style = token(items, '|', n);
2123 QString style_gui = qt_(style);
2124 pagestyles.push_back(pair<string, QString>(style, style_gui));
2125 pageLayoutModule->pagestyleCO->addItem(style_gui);
2128 if (sel == "default") {
2129 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2135 for (size_t i = 0; i < pagestyles.size(); ++i)
2136 if (pagestyles[i].first == sel)
2137 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2140 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2144 void GuiDocument::browseLayout()
2146 QString const label1 = qt_("Layouts|#o#O");
2147 QString const dir1 = toqstr(lyxrc.document_path);
2148 QStringList const filter(qt_("LyX Layout (*.layout)"));
2149 QString file = browseRelToParent(QString(), bufferFilePath(),
2150 qt_("Local layout file"), filter, false,
2153 if (!file.endsWith(".layout"))
2156 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2157 fromqstr(bufferFilePath()));
2159 int const ret = Alert::prompt(_("Local layout file"),
2160 _("The layout file you have selected is a local layout\n"
2161 "file, not one in the system or user directory.\n"
2162 "Your document will not work with this layout if you\n"
2163 "move the layout file to a different directory."),
2164 1, 1, _("&Set Layout"), _("&Cancel"));
2168 // load the layout file
2169 LayoutFileList & bcl = LayoutFileList::get();
2170 string classname = layoutFile.onlyFileName();
2171 // this will update an existing layout if that layout has been loaded before.
2172 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2173 classname.substr(0, classname.size() - 7),
2174 layoutFile.onlyPath().absFileName()));
2177 Alert::error(_("Error"),
2178 _("Unable to read local layout file."));
2182 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2184 // do not trigger classChanged if there is no change.
2185 if (latexModule->classCO->currentText() == toqstr(name))
2189 bool const avail = latexModule->classCO->set(toqstr(name));
2191 LayoutFile const & tc = bcl[name];
2192 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2193 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2194 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2195 tooltip += '\n' + qt_("This is a local layout file.");
2196 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2197 toqstr(translateIfPossible(from_utf8(tc.category()))),
2199 true, true, true, true);
2200 latexModule->classCO->set(toqstr(name));
2207 void GuiDocument::browseMaster()
2209 QString const title = qt_("Select master document");
2210 QString const dir1 = toqstr(lyxrc.document_path);
2211 QString const old = latexModule->childDocLE->text();
2212 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2213 QStringList const filter(qt_("LyX Files (*.lyx)"));
2214 QString file = browseRelToSub(old, docpath, title, filter, false,
2215 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2217 if (!file.isEmpty())
2218 latexModule->childDocLE->setText(file);
2222 void GuiDocument::classChanged_adaptor()
2224 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2229 void GuiDocument::classChanged()
2231 int idx = latexModule->classCO->currentIndex();
2234 string const classname = fromqstr(latexModule->classCO->getData(idx));
2236 if (applyPB->isEnabled()) {
2237 int const ret = Alert::prompt(_("Unapplied changes"),
2238 _("Some changes in the dialog were not yet applied.\n"
2239 "If you do not apply now, they will be lost after this action."),
2240 1, 1, _("&Apply"), _("&Dismiss"));
2245 // We load the TextClass as soon as it is selected. This is
2246 // necessary so that other options in the dialog can be updated
2247 // according to the new class. Note, however, that, if you use
2248 // the scroll wheel when sitting on the combo box, we'll load a
2249 // lot of TextClass objects very quickly....
2250 if (!bp_.setBaseClass(classname)) {
2251 Alert::error(_("Error"), _("Unable to set document class."));
2254 if (lyxrc.auto_reset_options)
2255 bp_.useClassDefaults();
2257 // With the introduction of modules came a distinction between the base
2258 // class and the document class. The former corresponds to the main layout
2259 // file; the latter is that plus the modules (or the document-specific layout,
2260 // or whatever else there could be). Our parameters come from the document
2261 // class. So when we set the base class, we also need to recreate the document
2262 // class. Otherwise, we still have the old one.
2263 bp_.makeDocumentClass();
2268 void GuiDocument::languagePackageChanged(int i)
2270 langModule->languagePackageLE->setEnabled(
2271 langModule->languagePackageCO->itemData(i).toString() == "custom");
2275 void GuiDocument::biblioChanged()
2277 biblioChanged_ = true;
2282 void GuiDocument::rescanBibFiles()
2284 rescanTexStyles("bst");
2288 void GuiDocument::resetDefaultBibfile()
2290 QString const engine =
2291 biblioModule->citeEngineCO->itemData(
2292 biblioModule->citeEngineCO->currentIndex()).toString();
2294 CiteEngineType const cet =
2295 CiteEngineType(biblioModule->citeStyleCO->itemData(
2296 biblioModule->citeStyleCO->currentIndex()).toInt());
2298 updateDefaultBiblio(theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet));
2302 void GuiDocument::citeEngineChanged(int n)
2304 QString const engine =
2305 biblioModule->citeEngineCO->itemData(n).toString();
2307 vector<string> const engs =
2308 theCiteEnginesList[fromqstr(engine)]->getEngineType();
2310 updateCiteStyles(engs);
2311 resetDefaultBibfile();
2317 void GuiDocument::citeStyleChanged()
2319 QString const engine =
2320 biblioModule->citeEngineCO->itemData(
2321 biblioModule->citeEngineCO->currentIndex()).toString();
2322 if (theCiteEnginesList[fromqstr(engine)]->isDefaultBiblio(
2323 fromqstr(biblioModule->defaultBiblioCO->currentText())))
2324 resetDefaultBibfile();
2330 void GuiDocument::bibtexChanged(int n)
2332 biblioModule->bibtexOptionsLE->setEnabled(
2333 biblioModule->bibtexCO->itemData(n).toString() != "default");
2338 void GuiDocument::updateCiteStyles(vector<string> const & engs, CiteEngineType const & sel)
2340 biblioModule->citeStyleCO->clear();
2342 vector<string>::const_iterator it = engs.begin();
2343 vector<string>::const_iterator end = engs.end();
2344 for (; it != end; ++it) {
2345 if (*it == "default")
2346 biblioModule->citeStyleCO->addItem(qt_("Basic numerical"),
2347 ENGINE_TYPE_DEFAULT);
2348 else if (*it == "authoryear")
2349 biblioModule->citeStyleCO->addItem(qt_("Author-year"),
2350 ENGINE_TYPE_AUTHORYEAR);
2351 else if (*it == "numerical")
2352 biblioModule->citeStyleCO->addItem(qt_("Author-number"),
2353 ENGINE_TYPE_NUMERICAL);
2355 int i = biblioModule->citeStyleCO->findData(sel);
2356 if (biblioModule->citeStyleCO->findData(sel) == -1)
2358 biblioModule->citeStyleCO->setCurrentIndex(i);
2360 biblioModule->citationStyleL->setEnabled(engs.size() > 1);
2361 biblioModule->citeStyleCO->setEnabled(engs.size() > 1);
2365 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2367 engine_types_.clear();
2371 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2373 string style = token(items, '|', n);
2374 engine_types_.push_back(style);
2377 updateCiteStyles(engine_types_, sel);
2383 // both of these should take a vector<docstring>
2385 // This is an insanely complicated attempt to make this sort of thing
2386 // work with RTL languages.
2387 docstring formatStrVec(vector<string> const & v, docstring const & s)
2389 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2393 return translateIfPossible(from_utf8(v[0]));
2394 if (v.size() == 2) {
2395 docstring retval = _("%1$s and %2$s");
2396 retval = subst(retval, _("and"), s);
2397 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2398 translateIfPossible(from_utf8(v[1])));
2400 // The idea here is to format all but the last two items...
2401 int const vSize = v.size();
2402 docstring t2 = _("%1$s, %2$s");
2403 docstring retval = translateIfPossible(from_utf8(v[0]));
2404 for (int i = 1; i < vSize - 2; ++i)
2405 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2406 //...and then to plug them, and the last two, into this schema
2407 docstring t = _("%1$s, %2$s, and %3$s");
2408 t = subst(t, _("and"), s);
2409 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2410 translateIfPossible(from_utf8(v[vSize - 1])));
2413 vector<string> idsToNames(vector<string> const & idList)
2415 vector<string> retval;
2416 vector<string>::const_iterator it = idList.begin();
2417 vector<string>::const_iterator end = idList.end();
2418 for (; it != end; ++it) {
2419 LyXModule const * const mod = theModuleList[*it];
2421 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2422 translateIfPossible(from_utf8(*it)))));
2424 retval.push_back(mod->getName());
2428 } // end anonymous namespace
2431 void GuiDocument::modulesToParams(BufferParams & bp)
2433 // update list of loaded modules
2434 bp.clearLayoutModules();
2435 int const srows = modules_sel_model_.rowCount();
2436 for (int i = 0; i < srows; ++i)
2437 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2439 // update the list of removed modules
2440 bp.clearRemovedModules();
2441 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2442 list<string>::const_iterator rit = reqmods.begin();
2443 list<string>::const_iterator ren = reqmods.end();
2445 // check each of the default modules
2446 for (; rit != ren; ++rit) {
2447 list<string>::const_iterator mit = bp.getModules().begin();
2448 list<string>::const_iterator men = bp.getModules().end();
2450 for (; mit != men; ++mit) {
2457 // the module isn't present so must have been removed by the user
2458 bp.addRemovedModule(*rit);
2463 void GuiDocument::modulesChanged()
2465 modulesToParams(bp_);
2467 if (applyPB->isEnabled() && nonModuleChanged_) {
2468 int const ret = Alert::prompt(_("Unapplied changes"),
2469 _("Some changes in the dialog were not yet applied.\n"
2470 "If you do not apply now, they will be lost after this action."),
2471 1, 1, _("&Apply"), _("&Dismiss"));
2476 bp_.makeDocumentClass();
2482 void GuiDocument::updateModuleInfo()
2484 selectionManager->update();
2486 //Module description
2487 bool const focus_on_selected = selectionManager->selectedFocused();
2488 QAbstractItemView * lv;
2489 if (focus_on_selected)
2490 lv = modulesModule->selectedLV;
2492 lv = modulesModule->availableLV;
2493 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2494 modulesModule->infoML->document()->clear();
2497 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2498 GuiIdListModel const & id_model =
2499 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2500 string const modName = id_model.getIDString(idx.row());
2501 docstring desc = getModuleDescription(modName);
2503 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2504 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2507 desc += _("Module provided by document class.");
2510 docstring cat = getModuleCategory(modName);
2514 desc += bformat(_("Category: %1$s."), cat);
2517 vector<string> pkglist = getPackageList(modName);
2518 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2519 if (!pkgdesc.empty()) {
2522 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2525 pkglist = getRequiredList(modName);
2526 if (!pkglist.empty()) {
2527 vector<string> const reqdescs = idsToNames(pkglist);
2528 pkgdesc = formatStrVec(reqdescs, _("or"));
2531 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2534 pkglist = getExcludedList(modName);
2535 if (!pkglist.empty()) {
2536 vector<string> const reqdescs = idsToNames(pkglist);
2537 pkgdesc = formatStrVec(reqdescs, _( "and"));
2540 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2543 if (!isModuleAvailable(modName)) {
2546 desc += _("WARNING: Some required packages are unavailable!");
2549 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2553 void GuiDocument::updateNumbering()
2555 DocumentClass const & tclass = documentClass();
2557 numberingModule->tocTW->setUpdatesEnabled(false);
2558 numberingModule->tocTW->clear();
2560 int const depth = numberingModule->depthSL->value();
2561 int const toc = numberingModule->tocSL->value();
2562 QString const no = qt_("No");
2563 QString const yes = qt_("Yes");
2564 QTreeWidgetItem * item = 0;
2566 DocumentClass::const_iterator lit = tclass.begin();
2567 DocumentClass::const_iterator len = tclass.end();
2568 for (; lit != len; ++lit) {
2569 int const toclevel = lit->toclevel;
2570 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2571 item = new QTreeWidgetItem(numberingModule->tocTW);
2572 item->setText(0, toqstr(translateIfPossible(lit->name())));
2573 item->setText(1, (toclevel <= depth) ? yes : no);
2574 item->setText(2, (toclevel <= toc) ? yes : no);
2578 numberingModule->tocTW->setUpdatesEnabled(true);
2579 numberingModule->tocTW->update();
2583 void GuiDocument::updateDefaultFormat()
2587 // make a copy in order to consider unapplied changes
2588 BufferParams param_copy = buffer().params();
2589 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2590 int const idx = latexModule->classCO->currentIndex();
2592 string const classname = fromqstr(latexModule->classCO->getData(idx));
2593 param_copy.setBaseClass(classname);
2594 param_copy.makeDocumentClass(true);
2596 outputModule->defaultFormatCO->blockSignals(true);
2597 outputModule->defaultFormatCO->clear();
2598 outputModule->defaultFormatCO->addItem(qt_("Default"),
2599 QVariant(QString("default")));
2600 FormatList const & formats =
2601 param_copy.exportableFormats(true);
2602 for (Format const * f : formats)
2603 outputModule->defaultFormatCO->addItem
2604 (toqstr(translateIfPossible(f->prettyname())),
2605 QVariant(toqstr(f->name())));
2606 outputModule->defaultFormatCO->blockSignals(false);
2610 bool GuiDocument::isChildIncluded(string const & child)
2612 if (includeonlys_.empty())
2614 return (std::find(includeonlys_.begin(),
2615 includeonlys_.end(), child) != includeonlys_.end());
2619 void GuiDocument::applyView()
2622 preambleModule->apply(bp_);
2623 localLayout->apply(bp_);
2626 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2627 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2630 string const engine =
2631 fromqstr(biblioModule->citeEngineCO->itemData(
2632 biblioModule->citeEngineCO->currentIndex()).toString());
2633 bp_.setCiteEngine(engine);
2635 CiteEngineType const style = CiteEngineType(biblioModule->citeStyleCO->itemData(
2636 biblioModule->citeStyleCO->currentIndex()).toInt());
2637 if (theCiteEnginesList[engine]->hasEngineType(style))
2638 bp_.setCiteEngineType(style);
2640 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2643 biblioModule->bibtopicCB->isChecked();
2645 bp_.biblio_style = fromqstr(biblioModule->defaultBiblioCO->currentText());
2647 string const bibtex_command =
2648 fromqstr(biblioModule->bibtexCO->itemData(
2649 biblioModule->bibtexCO->currentIndex()).toString());
2650 string const bibtex_options =
2651 fromqstr(biblioModule->bibtexOptionsLE->text());
2652 if (bibtex_command == "default" || bibtex_options.empty())
2653 bp_.bibtex_command = bibtex_command;
2655 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2657 if (biblioChanged_) {
2658 buffer().invalidateBibinfoCache();
2659 buffer().removeBiblioTempFiles();
2663 indicesModule->apply(bp_);
2665 // language & quotes
2666 if (langModule->defaultencodingRB->isChecked()) {
2667 bp_.inputenc = "auto";
2669 int i = langModule->encodingCO->currentIndex();
2671 bp_.inputenc = "default";
2673 QString const enc_gui =
2674 langModule->encodingCO->currentText();
2675 Encodings::const_iterator it = encodings.begin();
2676 Encodings::const_iterator const end = encodings.end();
2678 for (; it != end; ++it) {
2679 if (qt_(it->guiName()) == enc_gui &&
2681 bp_.inputenc = it->name();
2687 // should not happen
2688 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2689 bp_.inputenc = "default";
2694 bp_.quotes_style = (InsetQuotesParams::QuoteStyle) langModule->quoteStyleCO->itemData(
2695 langModule->quoteStyleCO->currentIndex()).toInt();
2696 bp_.dynamic_quotes = langModule->dynamicQuotesCB->isChecked();
2698 QString const langname = langModule->languageCO->itemData(
2699 langModule->languageCO->currentIndex()).toString();
2700 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2701 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2702 // If current cursor language was the document language, then update it too.
2703 if (cur.current_font.language() == bp_.language) {
2704 cur.current_font.setLanguage(newlang);
2705 cur.real_current_font.setLanguage(newlang);
2707 bp_.language = newlang;
2709 QString const pack = langModule->languagePackageCO->itemData(
2710 langModule->languagePackageCO->currentIndex()).toString();
2711 if (pack == "custom")
2713 fromqstr(langModule->languagePackageLE->text());
2715 bp_.lang_package = fromqstr(pack);
2718 bp_.backgroundcolor = set_backgroundcolor;
2719 bp_.isbackgroundcolor = is_backgroundcolor;
2720 bp_.fontcolor = set_fontcolor;
2721 bp_.isfontcolor = is_fontcolor;
2722 bp_.notefontcolor = set_notefontcolor;
2723 bp_.boxbgcolor = set_boxbgcolor;
2726 if (bp_.documentClass().hasTocLevels()) {
2727 bp_.tocdepth = numberingModule->tocSL->value();
2728 bp_.secnumdepth = numberingModule->depthSL->value();
2732 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2733 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2734 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2735 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2738 bp_.graphics_driver =
2739 tex_graphics[latexModule->psdriverCO->currentIndex()];
2742 int idx = latexModule->classCO->currentIndex();
2744 string const classname = fromqstr(latexModule->classCO->getData(idx));
2745 bp_.setBaseClass(classname);
2749 modulesToParams(bp_);
2752 map<string, string> const & packages = BufferParams::auto_packages();
2753 for (map<string, string>::const_iterator it = packages.begin();
2754 it != packages.end(); ++it) {
2755 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2758 int row = mathsModule->packagesTW->row(item);
2759 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2760 if (rb->isChecked()) {
2761 bp_.use_package(it->first, BufferParams::package_auto);
2764 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2765 if (rb->isChecked()) {
2766 bp_.use_package(it->first, BufferParams::package_on);
2769 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2770 if (rb->isChecked())
2771 bp_.use_package(it->first, BufferParams::package_off);
2775 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2776 bp_.pagestyle = "default";
2778 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2779 for (size_t i = 0; i != pagestyles.size(); ++i)
2780 if (pagestyles[i].second == style_gui)
2781 bp_.pagestyle = pagestyles[i].first;
2785 switch (textLayoutModule->lspacingCO->currentIndex()) {
2787 bp_.spacing().set(Spacing::Single);
2790 bp_.spacing().set(Spacing::Onehalf);
2793 bp_.spacing().set(Spacing::Double);
2796 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2798 bp_.spacing().set(Spacing::Single);
2800 bp_.spacing().set(Spacing::Other, s);
2805 if (textLayoutModule->twoColumnCB->isChecked())
2810 bp_.justification = textLayoutModule->justCB->isChecked();
2812 if (textLayoutModule->indentRB->isChecked()) {
2813 // if paragraphs are separated by an indentation
2814 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2815 switch (textLayoutModule->indentCO->currentIndex()) {
2817 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2820 HSpace indent = HSpace(
2821 widgetsToLength(textLayoutModule->indentLE,
2822 textLayoutModule->indentLengthCO)
2824 bp_.setIndentation(indent);
2828 // this should never happen
2829 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2833 // if paragraphs are separated by a skip
2834 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2835 switch (textLayoutModule->skipCO->currentIndex()) {
2837 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2840 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2843 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2848 widgetsToLength(textLayoutModule->skipLE,
2849 textLayoutModule->skipLengthCO)
2855 // this should never happen
2856 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2862 fromqstr(latexModule->optionsLE->text());
2864 bp_.use_default_options =
2865 latexModule->defaultOptionsCB->isChecked();
2867 if (latexModule->childDocGB->isChecked())
2869 fromqstr(latexModule->childDocLE->text());
2871 bp_.master = string();
2874 bp_.clearIncludedChildren();
2875 if (masterChildModule->includeonlyRB->isChecked()) {
2876 list<string>::const_iterator it = includeonlys_.begin();
2877 for (; it != includeonlys_.end() ; ++it) {
2878 bp_.addIncludedChildren(*it);
2881 bp_.maintain_unincluded_children =
2882 masterChildModule->maintainAuxCB->isChecked();
2885 bp_.float_placement = floatModule->get();
2888 // text should have passed validation
2889 bp_.listings_params =
2890 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2893 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2894 outputModule->defaultFormatCO->currentIndex()).toString());
2896 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2897 bp_.useNonTeXFonts = nontexfonts;
2899 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2901 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2903 int mathfmt = outputModule->mathoutCB->currentIndex();
2906 BufferParams::MathOutput const mo =
2907 static_cast<BufferParams::MathOutput>(mathfmt);
2908 bp_.html_math_output = mo;
2909 bp_.html_be_strict = outputModule->strictCB->isChecked();
2910 bp_.html_css_as_file = outputModule->cssCB->isChecked();
2911 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2912 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
2914 bp_.save_transient_properties =
2915 outputModule->saveTransientPropertiesCB->isChecked();
2918 bp_.fonts_roman[nontexfonts] =
2919 fromqstr(fontModule->fontsRomanCO->
2920 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2921 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
2923 bp_.fonts_sans[nontexfonts] =
2924 fromqstr(fontModule->fontsSansCO->
2925 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2926 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
2928 bp_.fonts_typewriter[nontexfonts] =
2929 fromqstr(fontModule->fontsTypewriterCO->
2930 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2931 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
2933 bp_.fonts_math[nontexfonts] =
2934 fromqstr(fontModule->fontsMathCO->
2935 itemData(fontModule->fontsMathCO->currentIndex()).toString());
2936 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
2938 QString const fontenc =
2939 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
2940 if (fontenc == "custom")
2941 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2943 bp_.fontenc = fromqstr(fontenc);
2946 fromqstr(fontModule->cjkFontLE->text());
2948 bp_.use_microtype = fontModule->microtypeCB->isChecked();
2950 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
2951 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
2953 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
2954 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
2956 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2958 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2961 bp_.fonts_default_family = "default";
2963 bp_.fonts_default_family = GuiDocument::fontfamilies[
2964 fontModule->fontsDefaultCO->currentIndex()];
2966 if (fontModule->fontsizeCO->currentIndex() == 0)
2967 bp_.fontsize = "default";
2970 fromqstr(fontModule->fontsizeCO->currentText());
2973 bp_.papersize = PAPER_SIZE(
2974 pageLayoutModule->papersizeCO->currentIndex());
2976 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2977 pageLayoutModule->paperwidthUnitCO);
2979 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2980 pageLayoutModule->paperheightUnitCO);
2982 if (pageLayoutModule->facingPagesCB->isChecked())
2983 bp_.sides = TwoSides;
2985 bp_.sides = OneSide;
2987 if (pageLayoutModule->landscapeRB->isChecked())
2988 bp_.orientation = ORIENTATION_LANDSCAPE;
2990 bp_.orientation = ORIENTATION_PORTRAIT;
2993 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2995 Ui::MarginsUi const * m = marginsModule;
2997 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2998 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2999 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
3000 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
3001 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
3002 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
3003 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
3004 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
3007 branchesModule->apply(bp_);
3010 PDFOptions & pdf = bp_.pdfoptions();
3011 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
3012 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
3013 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
3014 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
3015 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
3017 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
3018 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
3019 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
3020 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
3022 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
3023 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
3024 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
3025 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
3027 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
3028 if (pdfSupportModule->fullscreenCB->isChecked())
3029 pdf.pagemode = pdf.pagemode_fullscreen;
3031 pdf.pagemode.clear();
3032 pdf.quoted_options = pdf.quoted_options_check(
3033 fromqstr(pdfSupportModule->optionsLE->text()));
3036 nonModuleChanged_ = false;
3040 void GuiDocument::paramsToDialog()
3042 // set the default unit
3043 Length::UNIT const default_unit = Length::defaultUnit();
3046 preambleModule->update(bp_, id());
3047 localLayout->update(bp_, id());
3050 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3051 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3054 string const cite_engine = bp_.citeEngine().list().front();
3056 biblioModule->citeEngineCO->setCurrentIndex(
3057 biblioModule->citeEngineCO->findData(toqstr(cite_engine)));
3059 updateEngineType(documentClass().opt_enginetype(),
3060 bp_.citeEngineType());
3062 biblioModule->citeStyleCO->setCurrentIndex(
3063 biblioModule->citeStyleCO->findData(bp_.citeEngineType()));
3065 biblioModule->bibtopicCB->setChecked(
3068 updateDefaultBiblio(bp_.defaultBiblioStyle());
3072 split(bp_.bibtex_command, command, ' ');
3074 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3076 biblioModule->bibtexCO->setCurrentIndex(bpos);
3077 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3079 // We reset to default if we do not know the specified compiler
3080 // This is for security reasons
3081 biblioModule->bibtexCO->setCurrentIndex(
3082 biblioModule->bibtexCO->findData(toqstr("default")));
3083 biblioModule->bibtexOptionsLE->clear();
3085 biblioModule->bibtexOptionsLE->setEnabled(
3086 biblioModule->bibtexCO->currentIndex() != 0);
3088 biblioChanged_ = false;
3091 // We may be called when there is no Buffer, e.g., when
3092 // the last view has just been closed.
3093 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3094 indicesModule->update(bp_, isReadOnly);
3096 // language & quotes
3097 int const pos = langModule->languageCO->findData(toqstr(
3098 bp_.language->lang()));
3099 langModule->languageCO->setCurrentIndex(pos);
3101 langModule->quoteStyleCO->setCurrentIndex(
3103 langModule->dynamicQuotesCB->setChecked(bp_.dynamic_quotes);
3105 bool default_enc = true;
3106 if (bp_.inputenc != "auto") {
3107 default_enc = false;
3108 if (bp_.inputenc == "default") {
3109 langModule->encodingCO->setCurrentIndex(0);
3112 Encodings::const_iterator it = encodings.begin();
3113 Encodings::const_iterator const end = encodings.end();
3114 for (; it != end; ++it) {
3115 if (it->name() == bp_.inputenc &&
3117 enc_gui = it->guiName();
3121 int const i = langModule->encodingCO->findText(
3124 langModule->encodingCO->setCurrentIndex(i);
3126 // unknown encoding. Set to default.
3130 langModule->defaultencodingRB->setChecked(default_enc);
3131 langModule->otherencodingRB->setChecked(!default_enc);
3133 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3135 langModule->languagePackageCO->setCurrentIndex(
3136 langModule->languagePackageCO->findData("custom"));
3137 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3139 langModule->languagePackageCO->setCurrentIndex(p);
3140 langModule->languagePackageLE->clear();
3144 if (bp_.isfontcolor) {
3145 colorModule->fontColorPB->setStyleSheet(
3146 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3148 set_fontcolor = bp_.fontcolor;
3149 is_fontcolor = bp_.isfontcolor;
3151 colorModule->noteFontColorPB->setStyleSheet(
3152 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3153 set_notefontcolor = bp_.notefontcolor;
3155 if (bp_.isbackgroundcolor) {
3156 colorModule->backgroundPB->setStyleSheet(
3157 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3159 set_backgroundcolor = bp_.backgroundcolor;
3160 is_backgroundcolor = bp_.isbackgroundcolor;
3162 colorModule->boxBackgroundPB->setStyleSheet(
3163 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3164 set_boxbgcolor = bp_.boxbgcolor;
3167 int const min_toclevel = documentClass().min_toclevel();
3168 int const max_toclevel = documentClass().max_toclevel();
3169 if (documentClass().hasTocLevels()) {
3170 numberingModule->setEnabled(true);
3171 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3172 numberingModule->depthSL->setMaximum(max_toclevel);
3173 numberingModule->depthSL->setValue(bp_.secnumdepth);
3174 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3175 numberingModule->tocSL->setMaximum(max_toclevel);
3176 numberingModule->tocSL->setValue(bp_.tocdepth);
3179 numberingModule->setEnabled(false);
3180 numberingModule->tocTW->clear();
3184 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3185 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3186 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3187 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3188 bulletsModule->init();
3191 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3193 latexModule->psdriverCO->setCurrentIndex(nitem);
3196 map<string, string> const & packages = BufferParams::auto_packages();
3197 for (map<string, string>::const_iterator it = packages.begin();
3198 it != packages.end(); ++it) {
3199 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3202 int row = mathsModule->packagesTW->row(item);
3203 switch (bp_.use_package(it->first)) {
3204 case BufferParams::package_off: {
3205 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3206 rb->setChecked(true);
3209 case BufferParams::package_on: {
3210 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3211 rb->setChecked(true);
3214 case BufferParams::package_auto: {
3215 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3216 rb->setChecked(true);
3222 switch (bp_.spacing().getSpace()) {
3223 case Spacing::Other: nitem = 3; break;
3224 case Spacing::Double: nitem = 2; break;
3225 case Spacing::Onehalf: nitem = 1; break;
3226 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3230 string const & layoutID = bp_.baseClassID();
3231 setLayoutComboByIDString(layoutID);
3233 updatePagestyle(documentClass().opt_pagestyle(),
3236 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3237 if (bp_.spacing().getSpace() == Spacing::Other) {
3238 doubleToWidget(textLayoutModule->lspacingLE,
3239 bp_.spacing().getValueAsString());
3243 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3244 textLayoutModule->indentRB->setChecked(true);
3245 string indentation = bp_.getIndentation().asLyXCommand();
3247 if (indentation != "default") {
3248 lengthToWidgets(textLayoutModule->indentLE,
3249 textLayoutModule->indentLengthCO,
3250 indentation, default_unit);
3253 textLayoutModule->indentCO->setCurrentIndex(indent);
3256 textLayoutModule->skipRB->setChecked(true);
3258 switch (bp_.getDefSkip().kind()) {
3259 case VSpace::SMALLSKIP:
3262 case VSpace::MEDSKIP:
3265 case VSpace::BIGSKIP:
3268 case VSpace::LENGTH:
3271 string const length = bp_.getDefSkip().asLyXCommand();
3272 lengthToWidgets(textLayoutModule->skipLE,
3273 textLayoutModule->skipLengthCO,
3274 length, default_unit);
3281 textLayoutModule->skipCO->setCurrentIndex(skip);
3285 textLayoutModule->twoColumnCB->setChecked(
3287 textLayoutModule->justCB->setChecked(bp_.justification);
3289 if (!bp_.options.empty()) {
3290 latexModule->optionsLE->setText(
3291 toqstr(bp_.options));
3293 latexModule->optionsLE->setText(QString());
3297 latexModule->defaultOptionsCB->setChecked(
3298 bp_.use_default_options);
3299 updateSelectedModules();
3300 selectionManager->updateProvidedModules(
3301 bp_.baseClass()->providedModules());
3302 selectionManager->updateExcludedModules(
3303 bp_.baseClass()->excludedModules());
3305 if (!documentClass().options().empty()) {
3306 latexModule->defaultOptionsLE->setText(
3307 toqstr(documentClass().options()));
3309 latexModule->defaultOptionsLE->setText(
3310 toqstr(_("[No options predefined]")));
3313 latexModule->defaultOptionsLE->setEnabled(
3314 bp_.use_default_options
3315 && !documentClass().options().empty());
3317 latexModule->defaultOptionsCB->setEnabled(
3318 !documentClass().options().empty());
3320 if (!bp_.master.empty()) {
3321 latexModule->childDocGB->setChecked(true);
3322 latexModule->childDocLE->setText(
3323 toqstr(bp_.master));
3325 latexModule->childDocLE->setText(QString());
3326 latexModule->childDocGB->setChecked(false);
3330 if (!bufferview() || !buffer().hasChildren()) {
3331 masterChildModule->childrenTW->clear();
3332 includeonlys_.clear();
3333 docPS->showPanel("Child Documents", false);
3334 if (docPS->isCurrentPanel("Child Documents"))
3335 docPS->setCurrentPanel("Document Class");
3337 docPS->showPanel("Child Documents", true);
3338 masterChildModule->setEnabled(true);
3339 includeonlys_ = bp_.getIncludedChildren();
3340 updateIncludeonlys();
3342 masterChildModule->maintainAuxCB->setChecked(
3343 bp_.maintain_unincluded_children);
3346 floatModule->set(bp_.float_placement);
3349 // break listings_params to multiple lines
3351 InsetListingsParams(bp_.listings_params).separatedParams();
3352 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3355 // some languages only work with polyglossia/XeTeX
3356 Language const * lang = lyx::languages.getLanguage(
3357 fromqstr(langModule->languageCO->itemData(
3358 langModule->languageCO->currentIndex()).toString()));
3359 bool const need_fontspec =
3360 lang->babel().empty() && !lang->polyglossia().empty();
3361 bool const os_fonts_available =
3362 bp_.baseClass()->outputType() == lyx::LATEX
3363 && LaTeXFeatures::isAvailable("fontspec");
3364 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3365 fontModule->osFontsCB->setChecked(
3366 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3367 updateFontsize(documentClass().opt_fontsize(),
3370 QString font = toqstr(bp_.fontsRoman());
3371 int rpos = fontModule->fontsRomanCO->findData(font);
3373 rpos = fontModule->fontsRomanCO->count();
3374 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3376 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3377 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3379 font = toqstr(bp_.fontsSans());
3380 int spos = fontModule->fontsSansCO->findData(font);
3382 spos = fontModule->fontsSansCO->count();
3383 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3385 fontModule->fontsSansCO->setCurrentIndex(spos);
3386 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3388 font = toqstr(bp_.fontsTypewriter());
3389 int tpos = fontModule->fontsTypewriterCO->findData(font);
3391 tpos = fontModule->fontsTypewriterCO->count();
3392 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3394 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3395 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3397 font = toqstr(bp_.fontsMath());
3398 int mpos = fontModule->fontsMathCO->findData(font);
3400 mpos = fontModule->fontsMathCO->count();
3401 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3403 fontModule->fontsMathCO->setCurrentIndex(mpos);
3404 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3406 if (bp_.useNonTeXFonts && os_fonts_available) {
3407 fontModule->fontencLA->setEnabled(false);
3408 fontModule->fontencCO->setEnabled(false);
3409 fontModule->fontencLE->setEnabled(false);
3411 fontModule->fontencLA->setEnabled(true);
3412 fontModule->fontencCO->setEnabled(true);
3413 fontModule->fontencLE->setEnabled(true);
3419 if (!bp_.fonts_cjk.empty())
3420 fontModule->cjkFontLE->setText(
3421 toqstr(bp_.fonts_cjk));
3423 fontModule->cjkFontLE->setText(QString());
3425 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3427 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3428 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3429 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3430 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3431 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3432 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3434 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3436 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3438 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3439 fontModule->fontencCO->setCurrentIndex(
3440 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3441 fontModule->fontencLE->setEnabled(false);
3443 fontModule->fontencCO->setCurrentIndex(1);
3444 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3448 // This must be set _after_ fonts since updateDefaultFormat()
3449 // checks osFontsCB settings.
3450 // update combobox with formats
3451 updateDefaultFormat();
3452 int index = outputModule->defaultFormatCO->findData(toqstr(
3453 bp_.default_output_format));
3454 // set to default if format is not found
3457 outputModule->defaultFormatCO->setCurrentIndex(index);
3459 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3460 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3462 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3463 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3464 outputModule->strictCB->setChecked(bp_.html_be_strict);
3465 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3467 outputModule->saveTransientPropertiesCB
3468 ->setChecked(bp_.save_transient_properties);
3471 bool const extern_geometry =
3472 documentClass().provides("geometry");
3473 int const psize = bp_.papersize;
3474 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3475 setCustomPapersize(!extern_geometry && psize == 1);
3476 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3478 bool const landscape =
3479 bp_.orientation == ORIENTATION_LANDSCAPE;
3480 pageLayoutModule->landscapeRB->setChecked(landscape);
3481 pageLayoutModule->portraitRB->setChecked(!landscape);
3482 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3483 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3485 pageLayoutModule->facingPagesCB->setChecked(
3486 bp_.sides == TwoSides);
3488 lengthToWidgets(pageLayoutModule->paperwidthLE,
3489 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3490 lengthToWidgets(pageLayoutModule->paperheightLE,
3491 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3494 Ui::MarginsUi * m = marginsModule;
3498 lengthToWidgets(m->topLE, m->topUnit,
3499 bp_.topmargin, default_unit);
3501 lengthToWidgets(m->bottomLE, m->bottomUnit,
3502 bp_.bottommargin, default_unit);
3504 lengthToWidgets(m->innerLE, m->innerUnit,
3505 bp_.leftmargin, default_unit);
3507 lengthToWidgets(m->outerLE, m->outerUnit,
3508 bp_.rightmargin, default_unit);
3510 lengthToWidgets(m->headheightLE, m->headheightUnit,
3511 bp_.headheight, default_unit);
3513 lengthToWidgets(m->headsepLE, m->headsepUnit,
3514 bp_.headsep, default_unit);
3516 lengthToWidgets(m->footskipLE, m->footskipUnit,
3517 bp_.footskip, default_unit);
3519 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3520 bp_.columnsep, default_unit);
3523 updateUnknownBranches();
3524 branchesModule->update(bp_);
3527 PDFOptions const & pdf = bp_.pdfoptions();
3528 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3529 if (bp_.documentClass().provides("hyperref"))
3530 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3532 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3533 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3534 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3535 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3536 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3538 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3539 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3540 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3542 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3544 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3545 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3546 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3547 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3549 nn = findToken(backref_opts, pdf.backref);
3551 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3553 pdfSupportModule->fullscreenCB->setChecked
3554 (pdf.pagemode == pdf.pagemode_fullscreen);
3556 pdfSupportModule->optionsLE->setText(
3557 toqstr(pdf.quoted_options));
3559 // Make sure that the bc is in the INITIAL state
3560 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3563 // clear changed branches cache
3564 changedBranches_.clear();
3567 nonModuleChanged_ = false;
3571 void GuiDocument::saveDocDefault()
3573 // we have to apply the params first
3579 void GuiDocument::updateAvailableModules()
3581 modules_av_model_.clear();
3582 list<modInfoStruct> modInfoList = getModuleInfo();
3583 // Sort names according to the locale
3584 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3585 return 0 < b.name.localeAwareCompare(a.name);
3588 for (modInfoStruct const & m : modInfoList) {
3589 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3595 void GuiDocument::updateSelectedModules()
3597 modules_sel_model_.clear();
3598 list<modInfoStruct> const selModList = getSelectedModules();
3600 for (modInfoStruct const & m : selModList) {
3601 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3607 void GuiDocument::updateIncludeonlys()
3609 masterChildModule->childrenTW->clear();
3610 QString const no = qt_("No");
3611 QString const yes = qt_("Yes");
3613 if (includeonlys_.empty()) {
3614 masterChildModule->includeallRB->setChecked(true);
3615 masterChildModule->childrenTW->setEnabled(false);
3616 masterChildModule->maintainAuxCB->setEnabled(false);
3618 masterChildModule->includeonlyRB->setChecked(true);
3619 masterChildModule->childrenTW->setEnabled(true);
3620 masterChildModule->maintainAuxCB->setEnabled(true);
3622 ListOfBuffers children = buffer().getChildren();
3623 ListOfBuffers::const_iterator it = children.begin();
3624 ListOfBuffers::const_iterator end = children.end();
3625 bool has_unincluded = false;
3626 bool all_unincluded = true;
3627 for (; it != end; ++it) {
3628 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3631 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3632 from_utf8(buffer().filePath())));
3633 item->setText(0, toqstr(name));
3634 item->setText(1, isChildIncluded(name) ? yes : no);
3635 if (!isChildIncluded(name))
3636 has_unincluded = true;
3638 all_unincluded = false;
3640 // Both if all childs are included and if none is included
3641 // is equal to "include all" (i.e., ommit \includeonly).
3642 // Thus, reset the GUI.
3643 if (!has_unincluded || all_unincluded) {
3644 masterChildModule->includeallRB->setChecked(true);
3645 masterChildModule->childrenTW->setEnabled(false);
3646 includeonlys_.clear();
3648 // If all are included, we need to update again.
3649 if (!has_unincluded)
3650 updateIncludeonlys();
3654 void GuiDocument::updateDefaultBiblio(string const & style)
3656 QString const bibstyle = toqstr(style);
3657 biblioModule->defaultBiblioCO->clear();
3661 QStringList str = texFileList("bstFiles.lst");
3662 // test whether we have a valid list, otherwise run rescan
3663 if (str.isEmpty()) {
3664 rescanTexStyles("bst");
3665 str = texFileList("bstFiles.lst");
3667 for (int i = 0; i != str.size(); ++i)
3668 str[i] = onlyFileName(str[i]);
3669 // sort on filename only (no path)
3672 for (int i = 0; i != str.count(); ++i) {
3673 QString item = changeExtension(str[i], "");
3674 if (item == bibstyle)
3676 biblioModule->defaultBiblioCO->addItem(item);
3679 if (item_nr == -1 && !bibstyle.isEmpty()) {
3680 biblioModule->defaultBiblioCO->addItem(bibstyle);
3681 item_nr = biblioModule->defaultBiblioCO->count() - 1;
3685 biblioModule->defaultBiblioCO->setCurrentIndex(item_nr);
3687 biblioModule->defaultBiblioCO->clearEditText();
3689 updateResetDefaultBiblio();
3693 void GuiDocument::updateResetDefaultBiblio()
3695 QString const engine =
3696 biblioModule->citeEngineCO->itemData(
3697 biblioModule->citeEngineCO->currentIndex()).toString();
3698 CiteEngineType const cet =
3699 CiteEngineType(biblioModule->citeStyleCO->itemData(
3700 biblioModule->citeStyleCO->currentIndex()).toInt());
3701 biblioModule->resetDefaultBiblioPB->setEnabled(
3702 theCiteEnginesList[fromqstr(engine)]->getDefaultBiblio(cet)
3703 != fromqstr(biblioModule->defaultBiblioCO->currentText()));
3707 void GuiDocument::updateContents()
3709 // Nothing to do here as the document settings is not cursor dependant.
3714 void GuiDocument::useClassDefaults()
3716 if (applyPB->isEnabled()) {
3717 int const ret = Alert::prompt(_("Unapplied changes"),
3718 _("Some changes in the dialog were not yet applied.\n"
3719 "If you do not apply now, they will be lost after this action."),
3720 1, 1, _("&Apply"), _("&Dismiss"));
3725 int idx = latexModule->classCO->currentIndex();
3726 string const classname = fromqstr(latexModule->classCO->getData(idx));
3727 if (!bp_.setBaseClass(classname)) {
3728 Alert::error(_("Error"), _("Unable to set document class."));
3731 bp_.useClassDefaults();
3736 void GuiDocument::setLayoutComboByIDString(string const & idString)
3738 if (!latexModule->classCO->set(toqstr(idString)))
3739 Alert::warning(_("Can't set layout!"),
3740 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3744 bool GuiDocument::isValid()
3747 validateListingsParameters().isEmpty() &&
3748 localLayout->isValid() &&
3750 // if we're asking for skips between paragraphs
3751 !textLayoutModule->skipRB->isChecked() ||
3752 // then either we haven't chosen custom
3753 textLayoutModule->skipCO->currentIndex() != 3 ||
3754 // or else a length has been given
3755 !textLayoutModule->skipLE->text().isEmpty()
3758 // if we're asking for indentation
3759 !textLayoutModule->indentRB->isChecked() ||
3760 // then either we haven't chosen custom
3761 textLayoutModule->indentCO->currentIndex() != 1 ||
3762 // or else a length has been given
3763 !textLayoutModule->indentLE->text().isEmpty()
3768 char const * const GuiDocument::fontfamilies[5] = {
3769 "default", "rmdefault", "sfdefault", "ttdefault", ""
3773 char const * GuiDocument::fontfamilies_gui[5] = {
3774 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3778 bool GuiDocument::initialiseParams(string const &)
3780 BufferView const * view = bufferview();
3782 bp_ = BufferParams();
3786 bp_ = view->buffer().params();
3788 updateAvailableModules();
3789 //FIXME It'd be nice to make sure here that the selected
3790 //modules are consistent: That required modules are actually
3791 //selected, and that we don't have conflicts. If so, we could
3792 //at least pop up a warning.
3798 void GuiDocument::clearParams()
3800 bp_ = BufferParams();
3804 BufferId GuiDocument::id() const
3806 BufferView const * const view = bufferview();
3807 return view? &view->buffer() : 0;
3811 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3813 return moduleNames_;
3817 list<GuiDocument::modInfoStruct> const
3818 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3820 list<modInfoStruct> mInfo;
3821 for (string const & name : mods) {
3823 LyXModule const * const mod = theModuleList[name];
3828 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
3836 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3838 return makeModuleInfo(params().getModules());
3842 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3844 return makeModuleInfo(params().baseClass()->providedModules());
3848 DocumentClass const & GuiDocument::documentClass() const
3850 return bp_.documentClass();
3854 static void dispatch_bufferparams(Dialog const & dialog,
3855 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
3858 ss << "\\begin_header\n";
3859 bp.writeFile(ss, buf);
3860 ss << "\\end_header\n";
3861 dialog.dispatch(FuncRequest(lfun, ss.str()));
3865 void GuiDocument::dispatchParams()
3867 // We need a non-const buffer object.
3868 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
3869 // There may be several undo records; group them (bug #8998)
3870 buf.undo().beginUndoGroup();
3872 // This must come first so that a language change is correctly noticed
3875 // Apply the BufferParams. Note that this will set the base class
3876 // and then update the buffer's layout.
3877 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
3879 if (!params().master.empty()) {
3880 FileName const master_file = support::makeAbsPath(params().master,
3881 support::onlyPath(buffer().absFileName()));
3882 if (isLyXFileName(master_file.absFileName())) {
3883 Buffer * master = checkAndLoadLyXFile(master_file);
3885 if (master->isChild(const_cast<Buffer *>(&buffer())))
3886 const_cast<Buffer &>(buffer()).setParent(master);
3888 Alert::warning(_("Assigned master does not include this file"),
3889 bformat(_("You must include this file in the document\n"
3890 "'%1$s' in order to use the master document\n"
3891 "feature."), from_utf8(params().master)));
3893 Alert::warning(_("Could not load master"),
3894 bformat(_("The master document '%1$s'\n"
3895 "could not be loaded."),
3896 from_utf8(params().master)));
3900 // Generate the colours requested by each new branch.
3901 BranchList & branchlist = params().branchlist();
3902 if (!branchlist.empty()) {
3903 BranchList::const_iterator it = branchlist.begin();
3904 BranchList::const_iterator const end = branchlist.end();
3905 for (; it != end; ++it) {
3906 docstring const & current_branch = it->branch();
3907 Branch const * branch = branchlist.find(current_branch);
3908 string const x11hexname = X11hexname(branch->color());
3909 // display the new color
3910 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3911 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3914 // Open insets of selected branches, close deselected ones
3915 dispatch(FuncRequest(LFUN_INSET_FORALL,
3916 "Branch inset-toggle assign"));
3918 // rename branches in the document
3919 executeBranchRenaming();
3920 // and clear changed branches cache
3921 changedBranches_.clear();
3923 // Generate the colours requested by indices.
3924 IndicesList & indiceslist = params().indiceslist();
3925 if (!indiceslist.empty()) {
3926 IndicesList::const_iterator it = indiceslist.begin();
3927 IndicesList::const_iterator const end = indiceslist.end();
3928 for (; it != end; ++it) {
3929 docstring const & current_index = it->shortcut();
3930 Index const * index = indiceslist.findShortcut(current_index);
3931 string const x11hexname = X11hexname(index->color());
3932 // display the new color
3933 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3934 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3938 // If we used an LFUN, we would not need these two lines:
3939 BufferView * bv = const_cast<BufferView *>(bufferview());
3940 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3942 // Don't forget to close the group. Note that it is important
3943 // to check that there is no early return in the method.
3944 buf.undo().endUndoGroup();
3948 void GuiDocument::setLanguage() const
3950 Language const * const newL = bp_.language;
3951 if (buffer().params().language == newL)
3954 string const & lang_name = newL->lang();
3955 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3959 void GuiDocument::saveAsDefault() const
3961 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
3965 bool GuiDocument::providesOSF(QString const & font) const
3967 if (fontModule->osFontsCB->isChecked())
3968 // FIXME: we should check if the fonts really
3969 // have OSF support. But how?
3971 return theLaTeXFonts().getLaTeXFont(
3972 qstring_to_ucs4(font)).providesOSF(ot1(),
3978 bool GuiDocument::providesSC(QString const & font) const
3980 if (fontModule->osFontsCB->isChecked())
3982 return theLaTeXFonts().getLaTeXFont(
3983 qstring_to_ucs4(font)).providesSC(ot1(),
3989 bool GuiDocument::providesScale(QString const & font) const
3991 if (fontModule->osFontsCB->isChecked())
3993 return theLaTeXFonts().getLaTeXFont(
3994 qstring_to_ucs4(font)).providesScale(ot1(),
4000 bool GuiDocument::providesNoMath(QString const & font) const
4002 if (fontModule->osFontsCB->isChecked())
4004 return theLaTeXFonts().getLaTeXFont(
4005 qstring_to_ucs4(font)).providesNoMath(ot1(),
4010 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
4012 if (fontModule->osFontsCB->isChecked())
4014 return theLaTeXFonts().getLaTeXFont(
4015 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
4022 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
4024 // FIXME Unicode: docstrings would be better for these parameters but this
4025 // change requires a lot of others
4028 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
4029 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
4030 // Find the first sentence of the description
4031 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
4032 int pos = bf.toNextBoundary();
4035 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
4036 // Tooltip is the desc followed by the module name
4037 m.description = QString("%1<i>%2</i>")
4038 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
4044 void GuiDocument::loadModuleInfo()
4046 moduleNames_.clear();
4047 for (LyXModule const & mod : theModuleList)
4048 if (mod.category().substr(0, 8) != "Citation")
4049 moduleNames_.push_back(modInfo(mod));
4053 void GuiDocument::updateUnknownBranches()
4057 list<docstring> used_branches;
4058 buffer().getUsedBranches(used_branches);
4059 list<docstring>::const_iterator it = used_branches.begin();
4060 QStringList unknown_branches;
4061 for (; it != used_branches.end() ; ++it) {
4062 if (!buffer().params().branchlist().find(*it))
4063 unknown_branches.append(toqstr(*it));
4065 branchesModule->setUnknownBranches(unknown_branches);
4069 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
4071 map<docstring, docstring>::iterator it = changedBranches_.begin();
4072 for (; it != changedBranches_.end() ; ++it) {
4073 if (it->second == oldname) {
4074 // branch has already been renamed
4075 it->second = newname;
4080 changedBranches_[oldname] = newname;
4084 void GuiDocument::executeBranchRenaming() const
4086 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
4087 for (; it != changedBranches_.end() ; ++it) {
4088 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4089 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4094 void GuiDocument::allPackagesAuto()
4100 void GuiDocument::allPackagesAlways()
4106 void GuiDocument::allPackagesNot()
4112 void GuiDocument::allPackages(int col)
4114 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4115 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4116 rb->setChecked(true);
4121 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4124 } // namespace frontend
4127 #include "moc_GuiDocument.cpp"