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"
33 #include "ColorCache.h"
36 #include "FloatPlacement.h"
38 #include "FuncRequest.h"
40 #include "IndicesList.h"
42 #include "LaTeXFeatures.h"
43 #include "LaTeXFonts.h"
45 #include "LayoutEnums.h"
46 #include "LayoutModuleList.h"
48 #include "ModuleList.h"
49 #include "OutputParams.h"
50 #include "PDFOptions.h"
51 #include "qt_helpers.h"
53 #include "TextClass.h"
57 #include "insets/InsetListingsParams.h"
59 #include "support/debug.h"
60 #include "support/FileName.h"
61 #include "support/filetools.h"
62 #include "support/gettext.h"
63 #include "support/lassert.h"
64 #include "support/lstrings.h"
66 #include "frontends/alert.h"
68 #include <QAbstractItemModel>
69 #include <QHeaderView>
71 #include <QColorDialog>
72 #include <QCloseEvent>
73 #include <QFontDatabase>
75 #include <QTextBoundaryFinder>
76 #include <QTextCursor>
86 // a style sheet for buttons
87 // this is for example used for the background color setting button
88 static inline QString colorButtonStyleSheet(QColor const & bgColor)
90 if (bgColor.isValid()) {
91 QString rc = QLatin1String("background-color:");
100 using namespace lyx::support;
105 char const * const tex_graphics[] =
107 "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
108 "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
109 "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
110 "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
115 char const * const tex_graphics_gui[] =
117 N_("Default"), "dvialw", "DviLaser", "dvipdf", "DVIPDFM", "DVIPDFMx",
118 "Dvips", "DVIPSONE", "DVItoPS", "DVIWIN", "DVIWindo", "dvi2ps", "EmTeX",
119 "LN", "OzTeX", "pctexhp", "pctexps", "pctexwin", "PCTeX32", "pdfTeX",
120 "psprint", "pubps", "tcidvi", "Textures", "TrueTeX", "VTeX", "xdvi",
121 "XeTeX", N_("None"), ""
125 char const * backref_opts[] =
127 "false", "section", "slide", "page", ""
131 char const * backref_opts_gui[] =
133 N_("Off"), N_("Section"), N_("Slide"), N_("Page"), ""
137 vector<string> engine_types_;
138 vector<pair<string, QString> > pagestyles;
140 QMap<QString, QString> rmfonts_;
141 QMap<QString, QString> sffonts_;
142 QMap<QString, QString> ttfonts_;
143 QMap<QString, QString> mathfonts_;
146 } // anonymous namespace
150 RGBColor set_backgroundcolor;
151 bool is_backgroundcolor;
152 RGBColor set_fontcolor;
154 RGBColor set_notefontcolor;
155 RGBColor set_boxbgcolor;
156 bool forced_fontspec_activation;
159 // used when sorting the textclass list.
160 class less_textclass_avail_desc
161 : public binary_function<string, string, int>
164 bool operator()(string const & lhs, string const & rhs) const
166 // Ordering criteria:
167 // 1. Availability of text class
168 // 2. Description (lexicographic)
169 LayoutFile const & tc1 = LayoutFileList::get()[lhs];
170 LayoutFile const & tc2 = LayoutFileList::get()[rhs];
171 int const order = compare_no_case(
172 translateIfPossible(from_utf8(tc1.description())),
173 translateIfPossible(from_utf8(tc2.description())));
174 return (tc1.isTeXClassAvailable() && !tc2.isTeXClassAvailable()) ||
175 (tc1.isTeXClassAvailable() == tc2.isTeXClassAvailable() && order < 0);
184 vector<string> getRequiredList(string const & modName)
186 LyXModule const * const mod = theModuleList[modName];
188 return vector<string>(); //empty such thing
189 return mod->getRequiredModules();
193 vector<string> getExcludedList(string const & modName)
195 LyXModule const * const mod = theModuleList[modName];
197 return vector<string>(); //empty such thing
198 return mod->getExcludedModules();
202 docstring getModuleCategory(string const & modName)
204 LyXModule const * const mod = theModuleList[modName];
207 return from_utf8(mod->category());
211 docstring getModuleDescription(string const & modName)
213 LyXModule const * const mod = theModuleList[modName];
215 return _("Module not found!");
217 return translateIfPossible(from_utf8(mod->getDescription()));
221 vector<string> getPackageList(string const & modName)
223 LyXModule const * const mod = theModuleList[modName];
225 return vector<string>(); //empty such thing
226 return mod->getPackageList();
230 bool isModuleAvailable(string const & modName)
232 LyXModule const * const mod = theModuleList[modName];
235 return mod->isAvailable();
238 } // anonymous namespace
241 /////////////////////////////////////////////////////////////////////
243 // ModuleSelectionManager
245 /////////////////////////////////////////////////////////////////////
247 /// SelectionManager for use with modules
248 class ModuleSelectionManager : public GuiSelectionManager
252 ModuleSelectionManager(
253 QTreeView * availableLV,
254 QListView * selectedLV,
258 QPushButton * downPB,
259 GuiIdListModel * availableModel,
260 GuiIdListModel * selectedModel,
261 GuiDocument const * container)
262 : GuiSelectionManager(availableLV, selectedLV, addPB, delPB,
263 upPB, downPB, availableModel, selectedModel), container_(container)
266 void updateProvidedModules(LayoutModuleList const & pm)
267 { provided_modules_ = pm.list(); }
269 void updateExcludedModules(LayoutModuleList const & em)
270 { excluded_modules_ = em.list(); }
273 virtual void updateAddPB();
275 virtual void updateUpPB();
277 virtual void updateDownPB();
279 virtual void updateDelPB();
280 /// returns availableModel as a GuiIdListModel
281 GuiIdListModel * getAvailableModel()
283 return dynamic_cast<GuiIdListModel *>(availableModel);
285 /// returns selectedModel as a GuiIdListModel
286 GuiIdListModel * getSelectedModel()
288 return dynamic_cast<GuiIdListModel *>(selectedModel);
290 /// keeps a list of the modules the text class provides
291 list<string> provided_modules_;
293 list<string> excluded_modules_;
295 GuiDocument const * container_;
298 void ModuleSelectionManager::updateAddPB()
300 int const arows = availableModel->rowCount();
301 QModelIndexList const avail_sels =
302 availableLV->selectionModel()->selectedIndexes();
304 // disable if there aren't any modules (?), if none of them is chosen
305 // in the dialog, or if the chosen one is already selected for use.
306 if (arows == 0 || avail_sels.isEmpty() || isSelected(avail_sels.first())) {
307 addPB->setEnabled(false);
311 QModelIndex const & idx = availableLV->selectionModel()->currentIndex();
312 string const modname = getAvailableModel()->getIDString(idx.row());
315 container_->params().layoutModuleCanBeAdded(modname);
316 addPB->setEnabled(enable);
320 void ModuleSelectionManager::updateDownPB()
322 int const srows = selectedModel->rowCount();
324 downPB->setEnabled(false);
327 QModelIndex const & curidx = selectedLV->selectionModel()->currentIndex();
328 int const curRow = curidx.row();
329 if (curRow < 0 || curRow >= srows - 1) { // invalid or last item
330 downPB->setEnabled(false);
334 // determine whether immediately succeding element requires this one
335 string const curmodname = getSelectedModel()->getIDString(curRow);
336 string const nextmodname = getSelectedModel()->getIDString(curRow + 1);
338 vector<string> reqs = getRequiredList(nextmodname);
340 // if it doesn't require anything....
342 downPB->setEnabled(true);
346 // Enable it if this module isn't required.
347 // FIXME This should perhaps be more flexible and check whether, even
348 // if the next one is required, there is also an earlier one that will do.
350 find(reqs.begin(), reqs.end(), curmodname) == reqs.end());
353 void ModuleSelectionManager::updateUpPB()
355 int const srows = selectedModel->rowCount();
357 upPB->setEnabled(false);
361 QModelIndex const & curIdx = selectedLV->selectionModel()->currentIndex();
362 int curRow = curIdx.row();
363 if (curRow <= 0 || curRow > srows - 1) { // first item or invalid
364 upPB->setEnabled(false);
367 string const curmodname = getSelectedModel()->getIDString(curRow);
369 // determine whether immediately preceding element is required by this one
370 vector<string> reqs = getRequiredList(curmodname);
372 // if this one doesn't require anything....
374 upPB->setEnabled(true);
379 // Enable it if the preceding module isn't required.
380 // NOTE This is less flexible than it might be. We could check whether, even
381 // if the previous one is required, there is an earlier one that would do.
382 string const premod = getSelectedModel()->getIDString(curRow - 1);
383 upPB->setEnabled(find(reqs.begin(), reqs.end(), premod) == reqs.end());
386 void ModuleSelectionManager::updateDelPB()
388 int const srows = selectedModel->rowCount();
390 deletePB->setEnabled(false);
394 QModelIndex const & curidx =
395 selectedLV->selectionModel()->currentIndex();
396 int const curRow = curidx.row();
397 if (curRow < 0 || curRow >= srows) { // invalid index?
398 deletePB->setEnabled(false);
402 string const curmodname = getSelectedModel()->getIDString(curRow);
404 // We're looking here for a reason NOT to enable the button. If we
405 // find one, we disable it and return. If we don't, we'll end up at
406 // the end of the function, and then we enable it.
407 for (int i = curRow + 1; i < srows; ++i) {
408 string const thisMod = getSelectedModel()->getIDString(i);
409 vector<string> reqs = getRequiredList(thisMod);
410 //does this one require us?
411 if (find(reqs.begin(), reqs.end(), curmodname) == reqs.end())
415 // OK, so this module requires us
416 // is there an EARLIER module that also satisfies the require?
417 // NOTE We demand that it be earlier to keep the list of modules
418 // consistent with the rule that a module must be proceeded by a
419 // required module. There would be more flexible ways to proceed,
420 // but that would be a lot more complicated, and the logic here is
421 // already complicated. (That's why I've left the debugging code.)
422 // lyxerr << "Testing " << thisMod << endl;
423 bool foundone = false;
424 for (int j = 0; j < curRow; ++j) {
425 string const mod = getSelectedModel()->getIDString(j);
426 // lyxerr << "In loop: Testing " << mod << endl;
427 // do we satisfy the require?
428 if (find(reqs.begin(), reqs.end(), mod) != reqs.end()) {
429 // lyxerr << mod << " does the trick." << endl;
434 // did we find a module to satisfy the require?
436 // lyxerr << "No matching module found." << endl;
437 deletePB->setEnabled(false);
441 // lyxerr << "All's well that ends well." << endl;
442 deletePB->setEnabled(true);
446 /////////////////////////////////////////////////////////////////////
450 /////////////////////////////////////////////////////////////////////
452 PreambleModule::PreambleModule() : current_id_(0)
454 // This is not a memory leak. The object will be destroyed
456 // @ is letter in the LyX user preamble
457 (void) new LaTeXHighlighter(preambleTE->document(), true);
458 preambleTE->setFont(guiApp->typewriterSystemFont());
459 preambleTE->setWordWrapMode(QTextOption::NoWrap);
460 setFocusProxy(preambleTE);
461 connect(preambleTE, SIGNAL(textChanged()), this, SIGNAL(changed()));
465 void PreambleModule::update(BufferParams const & params, BufferId id)
467 QString preamble = toqstr(params.preamble);
468 // Nothing to do if the params and preamble are unchanged.
469 if (id == current_id_
470 && preamble == preambleTE->document()->toPlainText())
473 QTextCursor cur = preambleTE->textCursor();
474 // Save the coords before switching to the new one.
475 preamble_coords_[current_id_] =
476 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
478 // Save the params address for further use.
480 preambleTE->document()->setPlainText(preamble);
481 Coords::const_iterator it = preamble_coords_.find(current_id_);
482 if (it == preamble_coords_.end())
483 // First time we open this one.
484 preamble_coords_[current_id_] = make_pair(0, 0);
486 // Restore saved coords.
487 QTextCursor cur = preambleTE->textCursor();
488 cur.setPosition(it->second.first);
489 preambleTE->setTextCursor(cur);
490 preambleTE->verticalScrollBar()->setValue(it->second.second);
495 void PreambleModule::apply(BufferParams & params)
497 params.preamble = fromqstr(preambleTE->document()->toPlainText());
501 void PreambleModule::closeEvent(QCloseEvent * e)
503 // Save the coords before closing.
504 QTextCursor cur = preambleTE->textCursor();
505 preamble_coords_[current_id_] =
506 make_pair(cur.position(), preambleTE->verticalScrollBar()->value());
511 /////////////////////////////////////////////////////////////////////
515 /////////////////////////////////////////////////////////////////////
518 LocalLayout::LocalLayout() : current_id_(0), validated_(false)
520 connect(locallayoutTE, SIGNAL(textChanged()), this, SLOT(textChanged()));
521 connect(validatePB, SIGNAL(clicked()), this, SLOT(validatePressed()));
522 connect(convertPB, SIGNAL(clicked()), this, SLOT(convertPressed()));
526 void LocalLayout::update(BufferParams const & params, BufferId id)
528 QString layout = toqstr(params.getLocalLayout(false));
529 // Nothing to do if the params and preamble are unchanged.
530 if (id == current_id_
531 && layout == locallayoutTE->document()->toPlainText())
534 // Save the params address for further use.
536 locallayoutTE->document()->setPlainText(layout);
541 void LocalLayout::apply(BufferParams & params)
543 string const layout = fromqstr(locallayoutTE->document()->toPlainText());
544 params.setLocalLayout(layout, false);
548 void LocalLayout::hideConvert()
550 convertPB->setEnabled(false);
551 convertLB->setText("");
557 void LocalLayout::textChanged()
559 static const QString message =
560 qt_("Press button to check validity...");
561 string const layout =
562 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
564 if (layout.empty()) {
566 validatePB->setEnabled(false);
567 validLB->setText("");
570 } else if (!validatePB->isEnabled()) {
571 // if that's already enabled, we shouldn't need to do anything.
573 validLB->setText(message);
574 validatePB->setEnabled(true);
581 void LocalLayout::convert() {
582 string const layout =
583 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
584 string const newlayout = TextClass::convert(layout);
585 if (!newlayout.empty())
586 locallayoutTE->setPlainText(toqstr(newlayout));
591 void LocalLayout::convertPressed() {
598 void LocalLayout::validate() {
600 static const QString vpar("<p style=\"font-weight: bold;\">%1</p>");
601 // Flashy red bold text
602 static const QString ivpar("<p style=\"color: #c00000; font-weight: bold; \">"
604 string const layout =
605 fromqstr(locallayoutTE->document()->toPlainText().trimmed());
606 if (!layout.empty()) {
607 TextClass::ReturnValues const ret = TextClass::validate(layout);
608 validated_ = (ret == TextClass::OK) || (ret == TextClass::OK_OLDFORMAT);
609 validatePB->setEnabled(false);
610 validLB->setText(validated_ ? vpar.arg(qt_("Layout is valid!"))
611 : ivpar.arg(qt_("Layout is invalid!")));
612 if (ret == TextClass::OK_OLDFORMAT) {
614 // Testing conversion to LYXFILE_LAYOUT_FORMAT at this point
616 if (TextClass::convert(layout).empty()) {
617 // Conversion failed. If LAYOUT_FORMAT > LYXFILE_LAYOUT_FORMAT,
618 // then maybe the layout is still valid, but its format is more
619 // recent than LYXFILE_LAYOUT_FORMAT. However, if LAYOUT_FORMAT
620 // == LYXFILE_LAYOUT_FORMAT then something is definitely wrong.
621 convertPB->setEnabled(false);
622 const QString text = (LAYOUT_FORMAT == LYXFILE_LAYOUT_FORMAT)
623 ? ivpar.arg(qt_("Conversion to current format impossible!"))
624 : vpar.arg(qt_("Conversion to current stable format "
626 convertLB->setText(text);
628 convertPB->setEnabled(true);
629 convertLB->setText(qt_("Convert to current format"));
640 void LocalLayout::validatePressed() {
646 /////////////////////////////////////////////////////////////////////
650 /////////////////////////////////////////////////////////////////////
653 GuiDocument::GuiDocument(GuiView & lv)
654 : GuiDialog(lv, "document", qt_("Document Settings")),
655 biblioChanged_(false), nonModuleChanged_(false)
659 connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
660 connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
661 connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
662 connect(restorePB, SIGNAL(clicked()), this, SLOT(slotRestore()));
664 connect(savePB, SIGNAL(clicked()), this, SLOT(saveDefaultClicked()));
665 connect(defaultPB, SIGNAL(clicked()), this, SLOT(useDefaultsClicked()));
667 // Manage the restore, ok, apply, restore and cancel/close buttons
668 bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
670 bc().setApply(applyPB);
671 bc().setCancel(closePB);
672 bc().setRestore(restorePB);
676 textLayoutModule = new UiWidget<Ui::TextLayoutUi>;
677 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
678 this, SLOT(change_adaptor()));
679 connect(textLayoutModule->lspacingCO, SIGNAL(activated(int)),
680 this, SLOT(setLSpacing(int)));
681 connect(textLayoutModule->lspacingLE, SIGNAL(textChanged(const QString &)),
682 this, SLOT(change_adaptor()));
684 connect(textLayoutModule->indentRB, SIGNAL(clicked()),
685 this, SLOT(change_adaptor()));
686 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
687 textLayoutModule->indentCO, SLOT(setEnabled(bool)));
688 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
689 this, SLOT(change_adaptor()));
690 connect(textLayoutModule->indentCO, SIGNAL(activated(int)),
691 this, SLOT(setIndent(int)));
692 connect(textLayoutModule->indentLE, SIGNAL(textChanged(const QString &)),
693 this, SLOT(change_adaptor()));
694 connect(textLayoutModule->indentLengthCO, SIGNAL(activated(int)),
695 this, SLOT(change_adaptor()));
697 connect(textLayoutModule->skipRB, SIGNAL(clicked()),
698 this, SLOT(change_adaptor()));
699 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
700 textLayoutModule->skipCO, SLOT(setEnabled(bool)));
701 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
702 this, SLOT(change_adaptor()));
703 connect(textLayoutModule->skipCO, SIGNAL(activated(int)),
704 this, SLOT(setSkip(int)));
705 connect(textLayoutModule->skipLE, SIGNAL(textChanged(const QString &)),
706 this, SLOT(change_adaptor()));
707 connect(textLayoutModule->skipLengthCO, SIGNAL(activated(int)),
708 this, SLOT(change_adaptor()));
710 connect(textLayoutModule->indentRB, SIGNAL(toggled(bool)),
711 this, SLOT(enableIndent(bool)));
712 connect(textLayoutModule->skipRB, SIGNAL(toggled(bool)),
713 this, SLOT(enableSkip(bool)));
715 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
716 this, SLOT(change_adaptor()));
717 connect(textLayoutModule->twoColumnCB, SIGNAL(clicked()),
718 this, SLOT(setColSep()));
719 connect(textLayoutModule->justCB, SIGNAL(clicked()),
720 this, SLOT(change_adaptor()));
722 textLayoutModule->lspacingLE->setValidator(new QDoubleValidator(
723 textLayoutModule->lspacingLE));
724 textLayoutModule->indentLE->setValidator(new LengthValidator(
725 textLayoutModule->indentLE));
726 textLayoutModule->skipLE->setValidator(new LengthValidator(
727 textLayoutModule->skipLE));
729 textLayoutModule->indentCO->addItem(qt_("Default"));
730 textLayoutModule->indentCO->addItem(qt_("Custom"));
731 textLayoutModule->skipCO->addItem(qt_("SmallSkip"));
732 textLayoutModule->skipCO->addItem(qt_("MedSkip"));
733 textLayoutModule->skipCO->addItem(qt_("BigSkip"));
734 textLayoutModule->skipCO->addItem(qt_("Custom"));
735 textLayoutModule->lspacingCO->insertItem(
736 Spacing::Single, qt_("Single"));
737 textLayoutModule->lspacingCO->insertItem(
738 Spacing::Onehalf, qt_("OneHalf"));
739 textLayoutModule->lspacingCO->insertItem(
740 Spacing::Double, qt_("Double"));
741 textLayoutModule->lspacingCO->insertItem(
742 Spacing::Other, qt_("Custom"));
743 // initialize the length validator
744 bc().addCheckedLineEdit(textLayoutModule->indentLE);
745 bc().addCheckedLineEdit(textLayoutModule->skipLE);
748 // master/child handling
749 masterChildModule = new UiWidget<Ui::MasterChildUi>;
751 connect(masterChildModule->childrenTW, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
752 this, SLOT(includeonlyClicked(QTreeWidgetItem *, int)));
753 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
754 masterChildModule->childrenTW, SLOT(setEnabled(bool)));
755 connect(masterChildModule->includeonlyRB, SIGNAL(toggled(bool)),
756 masterChildModule->maintainAuxCB, SLOT(setEnabled(bool)));
757 connect(masterChildModule->includeallRB, SIGNAL(clicked()),
758 this, SLOT(change_adaptor()));
759 connect(masterChildModule->includeonlyRB, SIGNAL(clicked()),
760 this, SLOT(change_adaptor()));
761 connect(masterChildModule->maintainAuxCB, SIGNAL(clicked()),
762 this, SLOT(change_adaptor()));
763 masterChildModule->childrenTW->setColumnCount(2);
764 masterChildModule->childrenTW->headerItem()->setText(0, qt_("Child Document"));
765 masterChildModule->childrenTW->headerItem()->setText(1, qt_("Include to Output"));
766 masterChildModule->childrenTW->resizeColumnToContents(1);
767 masterChildModule->childrenTW->resizeColumnToContents(2);
771 outputModule = new UiWidget<Ui::OutputUi>;
773 connect(outputModule->defaultFormatCO, SIGNAL(activated(int)),
774 this, SLOT(change_adaptor()));
775 connect(outputModule->mathimgSB, SIGNAL(valueChanged(double)),
776 this, SLOT(change_adaptor()));
777 connect(outputModule->strictCB, SIGNAL(stateChanged(int)),
778 this, SLOT(change_adaptor()));
779 connect(outputModule->cssCB, SIGNAL(stateChanged(int)),
780 this, SLOT(change_adaptor()));
781 connect(outputModule->mathoutCB, SIGNAL(currentIndexChanged(int)),
782 this, SLOT(change_adaptor()));
784 connect(outputModule->outputsyncCB, SIGNAL(clicked()),
785 this, SLOT(change_adaptor()));
786 connect(outputModule->synccustomCB, SIGNAL(editTextChanged(QString)),
787 this, SLOT(change_adaptor()));
788 outputModule->synccustomCB->addItem("");
789 outputModule->synccustomCB->addItem("\\synctex=1");
790 outputModule->synccustomCB->addItem("\\synctex=-1");
791 outputModule->synccustomCB->addItem("\\usepackage[active]{srcltx}");
793 outputModule->synccustomCB->setValidator(new NoNewLineValidator(
794 outputModule->synccustomCB));
796 connect(outputModule->saveTransientPropertiesCB, SIGNAL(clicked()),
797 this, SLOT(change_adaptor()));
800 fontModule = new FontModule;
801 connect(fontModule->osFontsCB, SIGNAL(clicked()),
802 this, SLOT(change_adaptor()));
803 connect(fontModule->osFontsCB, SIGNAL(toggled(bool)),
804 this, SLOT(osFontsChanged(bool)));
805 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
806 this, SLOT(change_adaptor()));
807 connect(fontModule->fontsRomanCO, SIGNAL(activated(int)),
808 this, SLOT(romanChanged(int)));
809 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
810 this, SLOT(change_adaptor()));
811 connect(fontModule->fontsSansCO, SIGNAL(activated(int)),
812 this, SLOT(sansChanged(int)));
813 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
814 this, SLOT(change_adaptor()));
815 connect(fontModule->fontsTypewriterCO, SIGNAL(activated(int)),
816 this, SLOT(ttChanged(int)));
817 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
818 this, SLOT(change_adaptor()));
819 connect(fontModule->fontsMathCO, SIGNAL(activated(int)),
820 this, SLOT(mathFontChanged(int)));
821 connect(fontModule->fontsDefaultCO, SIGNAL(activated(int)),
822 this, SLOT(change_adaptor()));
823 connect(fontModule->fontencCO, SIGNAL(activated(int)),
824 this, SLOT(change_adaptor()));
825 connect(fontModule->fontencCO, SIGNAL(activated(int)),
826 this, SLOT(fontencChanged(int)));
827 connect(fontModule->fontencLE, SIGNAL(textChanged(const QString &)),
828 this, SLOT(change_adaptor()));
829 connect(fontModule->fontsizeCO, SIGNAL(activated(int)),
830 this, SLOT(change_adaptor()));
831 connect(fontModule->cjkFontLE, SIGNAL(textChanged(const QString &)),
832 this, SLOT(change_adaptor()));
833 connect(fontModule->microtypeCB, SIGNAL(clicked()),
834 this, SLOT(change_adaptor()));
835 connect(fontModule->scaleSansSB, SIGNAL(valueChanged(int)),
836 this, SLOT(change_adaptor()));
837 connect(fontModule->scaleTypewriterSB, SIGNAL(valueChanged(int)),
838 this, SLOT(change_adaptor()));
839 connect(fontModule->fontScCB, SIGNAL(clicked()),
840 this, SLOT(change_adaptor()));
841 connect(fontModule->fontScCB, SIGNAL(toggled(bool)),
842 this, SLOT(fontScToggled(bool)));
843 connect(fontModule->fontOsfCB, SIGNAL(clicked()),
844 this, SLOT(change_adaptor()));
845 connect(fontModule->fontOsfCB, SIGNAL(toggled(bool)),
846 this, SLOT(fontOsfToggled(bool)));
848 fontModule->fontencLE->setValidator(new NoNewLineValidator(
849 fontModule->fontencLE));
850 fontModule->cjkFontLE->setValidator(new NoNewLineValidator(
851 fontModule->cjkFontLE));
855 fontModule->fontsizeCO->addItem(qt_("Default"));
856 fontModule->fontsizeCO->addItem(qt_("10"));
857 fontModule->fontsizeCO->addItem(qt_("11"));
858 fontModule->fontsizeCO->addItem(qt_("12"));
860 fontModule->fontencCO->addItem(qt_("Default"), QString("global"));
861 fontModule->fontencCO->addItem(qt_("Custom"), QString("custom"));
862 fontModule->fontencCO->addItem(qt_("None (no fontenc)"), QString("default"));
864 for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
865 fontModule->fontsDefaultCO->addItem(
866 qt_(GuiDocument::fontfamilies_gui[n]));
868 if (!LaTeXFeatures::isAvailable("fontspec"))
869 fontModule->osFontsCB->setToolTip(
870 qt_("Use OpenType and TrueType fonts directly (requires XeTeX or LuaTeX)\n"
871 "You need to install the package \"fontspec\" to use this feature"));
875 pageLayoutModule = new UiWidget<Ui::PageLayoutUi>;
876 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
877 this, SLOT(papersizeChanged(int)));
878 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
879 this, SLOT(papersizeChanged(int)));
880 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
881 this, SLOT(change_adaptor()));
882 connect(pageLayoutModule->papersizeCO, SIGNAL(activated(int)),
883 this, SLOT(change_adaptor()));
884 connect(pageLayoutModule->paperheightLE, SIGNAL(textChanged(const QString &)),
885 this, SLOT(change_adaptor()));
886 connect(pageLayoutModule->paperwidthLE, SIGNAL(textChanged(const QString &)),
887 this, SLOT(change_adaptor()));
888 connect(pageLayoutModule->paperwidthUnitCO, SIGNAL(activated(int)),
889 this, SLOT(change_adaptor()));
890 connect(pageLayoutModule->paperheightUnitCO, SIGNAL(activated(int)),
891 this, SLOT(change_adaptor()));
892 connect(pageLayoutModule->portraitRB, SIGNAL(clicked()),
893 this, SLOT(change_adaptor()));
894 connect(pageLayoutModule->landscapeRB, SIGNAL(clicked()),
895 this, SLOT(change_adaptor()));
896 connect(pageLayoutModule->facingPagesCB, SIGNAL(clicked()),
897 this, SLOT(change_adaptor()));
898 connect(pageLayoutModule->pagestyleCO, SIGNAL(activated(int)),
899 this, SLOT(change_adaptor()));
901 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
902 pageLayoutModule->pagestyleCO->addItem(qt_("empty"));
903 pageLayoutModule->pagestyleCO->addItem(qt_("plain"));
904 pageLayoutModule->pagestyleCO->addItem(qt_("headings"));
905 pageLayoutModule->pagestyleCO->addItem(qt_("fancy"));
906 bc().addCheckedLineEdit(pageLayoutModule->paperheightLE,
907 pageLayoutModule->paperheightL);
908 bc().addCheckedLineEdit(pageLayoutModule->paperwidthLE,
909 pageLayoutModule->paperwidthL);
911 QComboBox * cb = pageLayoutModule->papersizeCO;
912 cb->addItem(qt_("Default"));
913 cb->addItem(qt_("Custom"));
914 cb->addItem(qt_("US letter"));
915 cb->addItem(qt_("US legal"));
916 cb->addItem(qt_("US executive"));
917 cb->addItem(qt_("A0"));
918 cb->addItem(qt_("A1"));
919 cb->addItem(qt_("A2"));
920 cb->addItem(qt_("A3"));
921 cb->addItem(qt_("A4"));
922 cb->addItem(qt_("A5"));
923 cb->addItem(qt_("A6"));
924 cb->addItem(qt_("B0"));
925 cb->addItem(qt_("B1"));
926 cb->addItem(qt_("B2"));
927 cb->addItem(qt_("B3"));
928 cb->addItem(qt_("B4"));
929 cb->addItem(qt_("B5"));
930 cb->addItem(qt_("B6"));
931 cb->addItem(qt_("C0"));
932 cb->addItem(qt_("C1"));
933 cb->addItem(qt_("C2"));
934 cb->addItem(qt_("C3"));
935 cb->addItem(qt_("C4"));
936 cb->addItem(qt_("C5"));
937 cb->addItem(qt_("C6"));
938 cb->addItem(qt_("JIS B0"));
939 cb->addItem(qt_("JIS B1"));
940 cb->addItem(qt_("JIS B2"));
941 cb->addItem(qt_("JIS B3"));
942 cb->addItem(qt_("JIS B4"));
943 cb->addItem(qt_("JIS B5"));
944 cb->addItem(qt_("JIS B6"));
945 // remove the %-items from the unit choice
946 pageLayoutModule->paperwidthUnitCO->noPercents();
947 pageLayoutModule->paperheightUnitCO->noPercents();
948 pageLayoutModule->paperheightLE->setValidator(unsignedLengthValidator(
949 pageLayoutModule->paperheightLE));
950 pageLayoutModule->paperwidthLE->setValidator(unsignedLengthValidator(
951 pageLayoutModule->paperwidthLE));
955 marginsModule = new UiWidget<Ui::MarginsUi>;
956 connect(marginsModule->marginCB, SIGNAL(toggled(bool)),
957 this, SLOT(setCustomMargins(bool)));
958 connect(marginsModule->marginCB, SIGNAL(clicked()),
959 this, SLOT(change_adaptor()));
960 connect(marginsModule->topLE, SIGNAL(textChanged(QString)),
961 this, SLOT(change_adaptor()));
962 connect(marginsModule->topUnit, SIGNAL(activated(int)),
963 this, SLOT(change_adaptor()));
964 connect(marginsModule->bottomLE, SIGNAL(textChanged(QString)),
965 this, SLOT(change_adaptor()));
966 connect(marginsModule->bottomUnit, SIGNAL(activated(int)),
967 this, SLOT(change_adaptor()));
968 connect(marginsModule->innerLE, SIGNAL(textChanged(QString)),
969 this, SLOT(change_adaptor()));
970 connect(marginsModule->innerUnit, SIGNAL(activated(int)),
971 this, SLOT(change_adaptor()));
972 connect(marginsModule->outerLE, SIGNAL(textChanged(QString)),
973 this, SLOT(change_adaptor()));
974 connect(marginsModule->outerUnit, SIGNAL(activated(int)),
975 this, SLOT(change_adaptor()));
976 connect(marginsModule->headheightLE, SIGNAL(textChanged(QString)),
977 this, SLOT(change_adaptor()));
978 connect(marginsModule->headheightUnit, SIGNAL(activated(int)),
979 this, SLOT(change_adaptor()));
980 connect(marginsModule->headsepLE, SIGNAL(textChanged(QString)),
981 this, SLOT(change_adaptor()));
982 connect(marginsModule->headsepUnit, SIGNAL(activated(int)),
983 this, SLOT(change_adaptor()));
984 connect(marginsModule->footskipLE, SIGNAL(textChanged(QString)),
985 this, SLOT(change_adaptor()));
986 connect(marginsModule->footskipUnit, SIGNAL(activated(int)),
987 this, SLOT(change_adaptor()));
988 connect(marginsModule->columnsepLE, SIGNAL(textChanged(QString)),
989 this, SLOT(change_adaptor()));
990 connect(marginsModule->columnsepUnit, SIGNAL(activated(int)),
991 this, SLOT(change_adaptor()));
992 marginsModule->topLE->setValidator(new LengthValidator(
993 marginsModule->topLE));
994 marginsModule->bottomLE->setValidator(new LengthValidator(
995 marginsModule->bottomLE));
996 marginsModule->innerLE->setValidator(new LengthValidator(
997 marginsModule->innerLE));
998 marginsModule->outerLE->setValidator(new LengthValidator(
999 marginsModule->outerLE));
1000 marginsModule->headsepLE->setValidator(new LengthValidator(
1001 marginsModule->headsepLE));
1002 marginsModule->headheightLE->setValidator(new LengthValidator(
1003 marginsModule->headheightLE));
1004 marginsModule->footskipLE->setValidator(new LengthValidator(
1005 marginsModule->footskipLE));
1006 marginsModule->columnsepLE->setValidator(new LengthValidator(
1007 marginsModule->columnsepLE));
1009 bc().addCheckedLineEdit(marginsModule->topLE,
1010 marginsModule->topL);
1011 bc().addCheckedLineEdit(marginsModule->bottomLE,
1012 marginsModule->bottomL);
1013 bc().addCheckedLineEdit(marginsModule->innerLE,
1014 marginsModule->innerL);
1015 bc().addCheckedLineEdit(marginsModule->outerLE,
1016 marginsModule->outerL);
1017 bc().addCheckedLineEdit(marginsModule->headsepLE,
1018 marginsModule->headsepL);
1019 bc().addCheckedLineEdit(marginsModule->headheightLE,
1020 marginsModule->headheightL);
1021 bc().addCheckedLineEdit(marginsModule->footskipLE,
1022 marginsModule->footskipL);
1023 bc().addCheckedLineEdit(marginsModule->columnsepLE,
1024 marginsModule->columnsepL);
1028 langModule = new UiWidget<Ui::LanguageUi>;
1029 connect(langModule->languageCO, SIGNAL(activated(int)),
1030 this, SLOT(change_adaptor()));
1031 connect(langModule->languageCO, SIGNAL(activated(int)),
1032 this, SLOT(languageChanged(int)));
1033 connect(langModule->defaultencodingRB, SIGNAL(clicked()),
1034 this, SLOT(change_adaptor()));
1035 connect(langModule->otherencodingRB, SIGNAL(clicked()),
1036 this, SLOT(change_adaptor()));
1037 connect(langModule->encodingCO, SIGNAL(activated(int)),
1038 this, SLOT(change_adaptor()));
1039 connect(langModule->quoteStyleCO, SIGNAL(activated(int)),
1040 this, SLOT(change_adaptor()));
1041 connect(langModule->languagePackageCO, SIGNAL(activated(int)),
1042 this, SLOT(change_adaptor()));
1043 connect(langModule->languagePackageLE, SIGNAL(textChanged(QString)),
1044 this, SLOT(change_adaptor()));
1045 connect(langModule->languagePackageCO, SIGNAL(currentIndexChanged(int)),
1046 this, SLOT(languagePackageChanged(int)));
1048 langModule->languagePackageLE->setValidator(new NoNewLineValidator(
1049 langModule->languagePackageLE));
1051 QAbstractItemModel * language_model = guiApp->languageModel();
1052 // FIXME: it would be nice if sorting was enabled/disabled via a checkbox.
1053 language_model->sort(0);
1054 langModule->languageCO->setModel(language_model);
1055 langModule->languageCO->setModelColumn(0);
1057 // Always put the default encoding in the first position.
1058 langModule->encodingCO->addItem(qt_("Language Default (no inputenc)"));
1059 QStringList encodinglist;
1060 Encodings::const_iterator it = encodings.begin();
1061 Encodings::const_iterator const end = encodings.end();
1062 for (; it != end; ++it)
1064 encodinglist.append(qt_(it->guiName()));
1065 encodinglist.sort();
1066 langModule->encodingCO->addItems(encodinglist);
1068 langModule->quoteStyleCO->addItem(
1069 qt_("``text''"),InsetQuotes::EnglishQuotes);
1070 langModule->quoteStyleCO->addItem(
1071 qt_("''text''"), InsetQuotes::SwedishQuotes);
1072 langModule->quoteStyleCO->addItem
1073 (qt_(",,text``"), InsetQuotes::GermanQuotes);
1074 langModule->quoteStyleCO->addItem(
1075 qt_(",,text''"), InsetQuotes::PolishQuotes);
1076 langModule->quoteStyleCO->addItem(
1077 qt_("<<text>>"), InsetQuotes::FrenchQuotes);
1078 langModule->quoteStyleCO->addItem(
1079 qt_(">>text<<"), InsetQuotes::DanishQuotes);
1081 langModule->languagePackageCO->addItem(
1082 qt_("Default"), toqstr("default"));
1083 langModule->languagePackageCO->addItem(
1084 qt_("Automatic"), toqstr("auto"));
1085 langModule->languagePackageCO->addItem(
1086 qt_("Always Babel"), toqstr("babel"));
1087 langModule->languagePackageCO->addItem(
1088 qt_("Custom"), toqstr("custom"));
1089 langModule->languagePackageCO->addItem(
1090 qt_("None[[language package]]"), toqstr("none"));
1094 colorModule = new UiWidget<Ui::ColorUi>;
1095 connect(colorModule->fontColorPB, SIGNAL(clicked()),
1096 this, SLOT(changeFontColor()));
1097 connect(colorModule->delFontColorTB, SIGNAL(clicked()),
1098 this, SLOT(deleteFontColor()));
1099 connect(colorModule->noteFontColorPB, SIGNAL(clicked()),
1100 this, SLOT(changeNoteFontColor()));
1101 connect(colorModule->delNoteFontColorTB, SIGNAL(clicked()),
1102 this, SLOT(deleteNoteFontColor()));
1103 connect(colorModule->backgroundPB, SIGNAL(clicked()),
1104 this, SLOT(changeBackgroundColor()));
1105 connect(colorModule->delBackgroundTB, SIGNAL(clicked()),
1106 this, SLOT(deleteBackgroundColor()));
1107 connect(colorModule->boxBackgroundPB, SIGNAL(clicked()),
1108 this, SLOT(changeBoxBackgroundColor()));
1109 connect(colorModule->delBoxBackgroundTB, SIGNAL(clicked()),
1110 this, SLOT(deleteBoxBackgroundColor()));
1114 numberingModule = new UiWidget<Ui::NumberingUi>;
1115 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1116 this, SLOT(change_adaptor()));
1117 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1118 this, SLOT(change_adaptor()));
1119 connect(numberingModule->depthSL, SIGNAL(valueChanged(int)),
1120 this, SLOT(updateNumbering()));
1121 connect(numberingModule->tocSL, SIGNAL(valueChanged(int)),
1122 this, SLOT(updateNumbering()));
1123 numberingModule->tocTW->setColumnCount(3);
1124 numberingModule->tocTW->headerItem()->setText(0, qt_("Example"));
1125 numberingModule->tocTW->headerItem()->setText(1, qt_("Numbered"));
1126 numberingModule->tocTW->headerItem()->setText(2, qt_("Appears in TOC"));
1127 setSectionResizeMode(numberingModule->tocTW->header(), QHeaderView::ResizeToContents);
1130 biblioModule = new UiWidget<Ui::BiblioUi>;
1131 connect(biblioModule->citeDefaultRB, SIGNAL(toggled(bool)),
1132 this, SLOT(setNumerical(bool)));
1133 connect(biblioModule->citeJurabibRB, SIGNAL(toggled(bool)),
1134 this, SLOT(setAuthorYear(bool)));
1135 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1136 biblioModule->citationStyleL, SLOT(setEnabled(bool)));
1137 connect(biblioModule->citeNatbibRB, SIGNAL(toggled(bool)),
1138 biblioModule->citeStyleCO, SLOT(setEnabled(bool)));
1139 connect(biblioModule->citeDefaultRB, SIGNAL(clicked()),
1140 this, SLOT(biblioChanged()));
1141 connect(biblioModule->citeNatbibRB, SIGNAL(clicked()),
1142 this, SLOT(biblioChanged()));
1143 connect(biblioModule->citeStyleCO, SIGNAL(activated(int)),
1144 this, SLOT(biblioChanged()));
1145 connect(biblioModule->citeJurabibRB, SIGNAL(clicked()),
1146 this, SLOT(biblioChanged()));
1147 connect(biblioModule->bibtopicCB, SIGNAL(clicked()),
1148 this, SLOT(biblioChanged()));
1149 connect(biblioModule->bibtexCO, SIGNAL(activated(int)),
1150 this, SLOT(bibtexChanged(int)));
1151 connect(biblioModule->bibtexOptionsLE, SIGNAL(textChanged(QString)),
1152 this, SLOT(biblioChanged()));
1153 connect(biblioModule->bibtexStyleLE, SIGNAL(textChanged(QString)),
1154 this, SLOT(biblioChanged()));
1156 biblioModule->bibtexOptionsLE->setValidator(new NoNewLineValidator(
1157 biblioModule->bibtexOptionsLE));
1158 biblioModule->bibtexStyleLE->setValidator(new NoNewLineValidator(
1159 biblioModule->bibtexStyleLE));
1161 biblioModule->citeStyleCO->addItem(qt_("Author-year"));
1162 biblioModule->citeStyleCO->addItem(qt_("Numerical"));
1163 biblioModule->citeStyleCO->setCurrentIndex(0);
1165 // NOTE: we do not provide "custom" here for security reasons!
1166 biblioModule->bibtexCO->clear();
1167 biblioModule->bibtexCO->addItem(qt_("Default"), QString("default"));
1168 for (set<string>::const_iterator it = lyxrc.bibtex_alternatives.begin();
1169 it != lyxrc.bibtex_alternatives.end(); ++it) {
1170 QString const command = toqstr(*it).left(toqstr(*it).indexOf(" "));
1171 biblioModule->bibtexCO->addItem(command, command);
1176 indicesModule = new GuiIndices;
1177 connect(indicesModule, SIGNAL(changed()),
1178 this, SLOT(change_adaptor()));
1182 mathsModule = new UiWidget<Ui::MathsUi>;
1183 QStringList headers;
1184 headers << qt_("Package") << qt_("Load automatically")
1185 << qt_("Load always") << qt_("Do not load");
1186 mathsModule->packagesTW->setHorizontalHeaderLabels(headers);
1187 setSectionResizeMode(mathsModule->packagesTW->horizontalHeader(), QHeaderView::Stretch);
1188 map<string, string> const & packages = BufferParams::auto_packages();
1189 mathsModule->packagesTW->setRowCount(packages.size());
1191 for (map<string, string>::const_iterator it = packages.begin();
1192 it != packages.end(); ++it) {
1193 docstring const package = from_ascii(it->first);
1194 QString autoTooltip = qt_(it->second);
1195 QString alwaysTooltip;
1196 if (package == "amsmath")
1198 qt_("The AMS LaTeX packages are always used");
1200 alwaysTooltip = toqstr(bformat(
1201 _("The LaTeX package %1$s is always used"),
1203 QString neverTooltip;
1204 if (package == "amsmath")
1206 qt_("The AMS LaTeX packages are never used");
1208 neverTooltip = toqstr(bformat(
1209 _("The LaTeX package %1$s is never used"),
1211 QRadioButton * autoRB = new QRadioButton(mathsModule);
1212 QRadioButton * alwaysRB = new QRadioButton(mathsModule);
1213 QRadioButton * neverRB = new QRadioButton(mathsModule);
1214 QButtonGroup * packageGroup = new QButtonGroup(mathsModule);
1215 packageGroup->addButton(autoRB);
1216 packageGroup->addButton(alwaysRB);
1217 packageGroup->addButton(neverRB);
1218 autoRB->setToolTip(autoTooltip);
1219 alwaysRB->setToolTip(alwaysTooltip);
1220 neverRB->setToolTip(neverTooltip);
1221 QTableWidgetItem * pack = new QTableWidgetItem(toqstr(package));
1222 mathsModule->packagesTW->setItem(i, 0, pack);
1223 mathsModule->packagesTW->setCellWidget(i, 1, autoRB);
1224 mathsModule->packagesTW->setCellWidget(i, 2, alwaysRB);
1225 mathsModule->packagesTW->setCellWidget(i, 3, neverRB);
1227 connect(autoRB, SIGNAL(clicked()),
1228 this, SLOT(change_adaptor()));
1229 connect(alwaysRB, SIGNAL(clicked()),
1230 this, SLOT(change_adaptor()));
1231 connect(neverRB, SIGNAL(clicked()),
1232 this, SLOT(change_adaptor()));
1235 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1236 this, SLOT(allPackagesAuto()));
1237 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1238 this, SLOT(allPackagesAlways()));
1239 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1240 this, SLOT(allPackagesNot()));
1241 connect(mathsModule->allPackagesAutoPB, SIGNAL(clicked()),
1242 this, SLOT(change_adaptor()));
1243 connect(mathsModule->allPackagesAlwaysPB, SIGNAL(clicked()),
1244 this, SLOT(change_adaptor()));
1245 connect(mathsModule->allPackagesNotPB, SIGNAL(clicked()),
1246 this, SLOT(change_adaptor()));
1250 latexModule = new UiWidget<Ui::LaTeXUi>;
1251 connect(latexModule->optionsLE, SIGNAL(textChanged(QString)),
1252 this, SLOT(change_adaptor()));
1253 connect(latexModule->defaultOptionsCB, SIGNAL(clicked()),
1254 this, SLOT(change_adaptor()));
1255 connect(latexModule->psdriverCO, SIGNAL(activated(int)),
1256 this, SLOT(change_adaptor()));
1257 connect(latexModule->classCO, SIGNAL(activated(int)),
1258 this, SLOT(classChanged_adaptor()));
1259 connect(latexModule->classCO, SIGNAL(activated(int)),
1260 this, SLOT(change_adaptor()));
1261 connect(latexModule->layoutPB, SIGNAL(clicked()),
1262 this, SLOT(browseLayout()));
1263 connect(latexModule->layoutPB, SIGNAL(clicked()),
1264 this, SLOT(change_adaptor()));
1265 connect(latexModule->childDocGB, SIGNAL(clicked()),
1266 this, SLOT(change_adaptor()));
1267 connect(latexModule->childDocLE, SIGNAL(textChanged(QString)),
1268 this, SLOT(change_adaptor()));
1269 connect(latexModule->childDocPB, SIGNAL(clicked()),
1270 this, SLOT(browseMaster()));
1271 connect(latexModule->suppressDateCB, SIGNAL(clicked()),
1272 this, SLOT(change_adaptor()));
1273 connect(latexModule->refstyleCB, SIGNAL(clicked()),
1274 this, SLOT(change_adaptor()));
1276 latexModule->optionsLE->setValidator(new NoNewLineValidator(
1277 latexModule->optionsLE));
1278 latexModule->childDocLE->setValidator(new NoNewLineValidator(
1279 latexModule->childDocLE));
1281 // postscript drivers
1282 for (int n = 0; tex_graphics[n][0]; ++n) {
1283 QString enc = qt_(tex_graphics_gui[n]);
1284 latexModule->psdriverCO->addItem(enc);
1287 LayoutFileList const & bcl = LayoutFileList::get();
1288 vector<LayoutFileIndex> classList = bcl.classList();
1289 sort(classList.begin(), classList.end(), less_textclass_avail_desc());
1291 vector<LayoutFileIndex>::const_iterator cit = classList.begin();
1292 vector<LayoutFileIndex>::const_iterator cen = classList.end();
1293 for (int i = 0; cit != cen; ++cit, ++i) {
1294 LayoutFile const & tc = bcl[*cit];
1295 bool const available = tc.isTeXClassAvailable();
1296 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
1297 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
1298 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
1300 docstring const output_type = (tc.outputType() == lyx::DOCBOOK) ? _("DocBook") : _("LaTeX");
1301 tooltip += '\n' + toqstr(bformat(_("Class not found by LyX. "
1302 "Please check if you have the matching %1$s class "
1303 "and all required packages (%2$s) installed."),
1304 output_type, from_utf8(tc.prerequisites(", "))));
1306 latexModule->classCO->addItemSort(toqstr(tc.name()),
1308 toqstr(translateIfPossible(from_utf8(tc.category()))),
1310 true, true, true, available);
1315 branchesModule = new GuiBranches;
1316 connect(branchesModule, SIGNAL(changed()),
1317 this, SLOT(change_adaptor()));
1318 connect(branchesModule, SIGNAL(renameBranches(docstring const &, docstring const &)),
1319 this, SLOT(branchesRename(docstring const &, docstring const &)));
1320 connect(branchesModule, SIGNAL(okPressed()), this, SLOT(slotOK()));
1321 updateUnknownBranches();
1325 preambleModule = new PreambleModule;
1326 connect(preambleModule, SIGNAL(changed()),
1327 this, SLOT(change_adaptor()));
1329 localLayout = new LocalLayout;
1330 connect(localLayout, SIGNAL(changed()),
1331 this, SLOT(change_adaptor()));
1335 bulletsModule = new BulletsModule;
1336 connect(bulletsModule, SIGNAL(changed()),
1337 this, SLOT(change_adaptor()));
1341 modulesModule = new UiWidget<Ui::ModulesUi>;
1342 modulesModule->availableLV->header()->setVisible(false);
1343 setSectionResizeMode(modulesModule->availableLV->header(), QHeaderView::ResizeToContents);
1344 modulesModule->availableLV->header()->setStretchLastSection(false);
1346 new ModuleSelectionManager(modulesModule->availableLV,
1347 modulesModule->selectedLV,
1348 modulesModule->addPB, modulesModule->deletePB,
1349 modulesModule->upPB, modulesModule->downPB,
1350 availableModel(), selectedModel(), this);
1351 connect(selectionManager, SIGNAL(updateHook()),
1352 this, SLOT(updateModuleInfo()));
1353 connect(selectionManager, SIGNAL(selectionChanged()),
1354 this, SLOT(modulesChanged()));
1358 pdfSupportModule = new UiWidget<Ui::PDFSupportUi>;
1359 connect(pdfSupportModule->use_hyperrefGB, SIGNAL(toggled(bool)),
1360 this, SLOT(change_adaptor()));
1361 connect(pdfSupportModule->titleLE, SIGNAL(textChanged(QString)),
1362 this, SLOT(change_adaptor()));
1363 connect(pdfSupportModule->authorLE, SIGNAL(textChanged(QString)),
1364 this, SLOT(change_adaptor()));
1365 connect(pdfSupportModule->subjectLE, SIGNAL(textChanged(QString)),
1366 this, SLOT(change_adaptor()));
1367 connect(pdfSupportModule->keywordsLE, SIGNAL(textChanged(QString)),
1368 this, SLOT(change_adaptor()));
1369 connect(pdfSupportModule->bookmarksGB, SIGNAL(toggled(bool)),
1370 this, SLOT(change_adaptor()));
1371 connect(pdfSupportModule->bookmarksnumberedCB, SIGNAL(toggled(bool)),
1372 this, SLOT(change_adaptor()));
1373 connect(pdfSupportModule->bookmarksopenGB, SIGNAL(toggled(bool)),
1374 this, SLOT(change_adaptor()));
1375 connect(pdfSupportModule->bookmarksopenlevelSB, SIGNAL(valueChanged(int)),
1376 this, SLOT(change_adaptor()));
1377 connect(pdfSupportModule->breaklinksCB, SIGNAL(toggled(bool)),
1378 this, SLOT(change_adaptor()));
1379 connect(pdfSupportModule->pdfborderCB, SIGNAL(toggled(bool)),
1380 this, SLOT(change_adaptor()));
1381 connect(pdfSupportModule->colorlinksCB, SIGNAL(toggled(bool)),
1382 this, SLOT(change_adaptor()));
1383 connect(pdfSupportModule->backrefCO, SIGNAL(activated(int)),
1384 this, SLOT(change_adaptor()));
1385 connect(pdfSupportModule->pdfusetitleCB, SIGNAL(toggled(bool)),
1386 this, SLOT(change_adaptor()));
1387 connect(pdfSupportModule->fullscreenCB, SIGNAL(toggled(bool)),
1388 this, SLOT(change_adaptor()));
1389 connect(pdfSupportModule->optionsLE, SIGNAL(textChanged(QString)),
1390 this, SLOT(change_adaptor()));
1392 pdfSupportModule->titleLE->setValidator(new NoNewLineValidator(
1393 pdfSupportModule->titleLE));
1394 pdfSupportModule->authorLE->setValidator(new NoNewLineValidator(
1395 pdfSupportModule->authorLE));
1396 pdfSupportModule->subjectLE->setValidator(new NoNewLineValidator(
1397 pdfSupportModule->subjectLE));
1398 pdfSupportModule->keywordsLE->setValidator(new NoNewLineValidator(
1399 pdfSupportModule->keywordsLE));
1400 pdfSupportModule->optionsLE->setValidator(new NoNewLineValidator(
1401 pdfSupportModule->optionsLE));
1403 for (int i = 0; backref_opts[i][0]; ++i)
1404 pdfSupportModule->backrefCO->addItem(qt_(backref_opts_gui[i]));
1408 floatModule = new FloatPlacement;
1409 connect(floatModule, SIGNAL(changed()),
1410 this, SLOT(change_adaptor()));
1414 listingsModule = new UiWidget<Ui::ListingsSettingsUi>;
1415 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1416 this, SLOT(change_adaptor()));
1417 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1418 this, SLOT(change_adaptor()));
1419 connect(listingsModule->bypassCB, SIGNAL(clicked()),
1420 this, SLOT(setListingsMessage()));
1421 connect(listingsModule->listingsED, SIGNAL(textChanged()),
1422 this, SLOT(setListingsMessage()));
1423 listingsModule->listingsTB->setPlainText(
1424 qt_("Input listings parameters below. Enter ? for a list of parameters."));
1428 docPS->addPanel(latexModule, N_("Document Class"));
1429 docPS->addPanel(masterChildModule, N_("Child Documents"));
1430 docPS->addPanel(modulesModule, N_("Modules"));
1431 docPS->addPanel(localLayout, N_("Local Layout"));
1432 docPS->addPanel(fontModule, N_("Fonts"));
1433 docPS->addPanel(textLayoutModule, N_("Text Layout"));
1434 docPS->addPanel(pageLayoutModule, N_("Page Layout"));
1435 docPS->addPanel(marginsModule, N_("Page Margins"));
1436 docPS->addPanel(langModule, N_("Language"));
1437 docPS->addPanel(colorModule, N_("Colors"));
1438 docPS->addPanel(numberingModule, N_("Numbering & TOC"));
1439 docPS->addPanel(biblioModule, N_("Bibliography"));
1440 docPS->addPanel(indicesModule, N_("Indexes"));
1441 docPS->addPanel(pdfSupportModule, N_("PDF Properties"));
1442 docPS->addPanel(mathsModule, N_("Math Options"));
1443 docPS->addPanel(floatModule, N_("Float Placement"));
1444 docPS->addPanel(listingsModule, N_("Listings[[inset]]"));
1445 docPS->addPanel(bulletsModule, N_("Bullets"));
1446 docPS->addPanel(branchesModule, N_("Branches"));
1447 docPS->addPanel(outputModule, N_("Format"));
1448 docPS->addPanel(preambleModule, N_("LaTeX Preamble"));
1449 docPS->setCurrentPanel("Document Class");
1450 // FIXME: hack to work around resizing bug in Qt >= 4.2
1451 // bug verified with Qt 4.2.{0-3} (JSpitzm)
1452 #if QT_VERSION >= 0x040200
1453 docPS->updateGeometry();
1458 void GuiDocument::saveDefaultClicked()
1464 void GuiDocument::useDefaultsClicked()
1470 void GuiDocument::change_adaptor()
1472 nonModuleChanged_ = true;
1477 void GuiDocument::includeonlyClicked(QTreeWidgetItem * item, int)
1482 string child = fromqstr(item->text(0));
1486 if (std::find(includeonlys_.begin(),
1487 includeonlys_.end(), child) != includeonlys_.end())
1488 includeonlys_.remove(child);
1490 includeonlys_.push_back(child);
1492 updateIncludeonlys();
1497 QString GuiDocument::validateListingsParameters()
1499 if (listingsModule->bypassCB->isChecked())
1501 string params = fromqstr(listingsModule->listingsED->toPlainText());
1502 return toqstr(InsetListingsParams(params).validate());
1506 void GuiDocument::setListingsMessage()
1509 static bool isOK = true;
1510 QString msg = validateListingsParameters();
1511 if (msg.isEmpty()) {
1515 // listingsTB->setTextColor("black");
1516 listingsModule->listingsTB->setPlainText(
1517 qt_("Input listings parameters below. "
1518 "Enter ? for a list of parameters."));
1521 // listingsTB->setTextColor("red");
1522 listingsModule->listingsTB->setPlainText(msg);
1527 void GuiDocument::setLSpacing(int item)
1529 textLayoutModule->lspacingLE->setEnabled(item == 3);
1533 void GuiDocument::setIndent(int item)
1535 bool const enable = (item == 1);
1536 textLayoutModule->indentLE->setEnabled(enable);
1537 textLayoutModule->indentLengthCO->setEnabled(enable);
1538 textLayoutModule->skipLE->setEnabled(false);
1539 textLayoutModule->skipLengthCO->setEnabled(false);
1544 void GuiDocument::enableIndent(bool indent)
1546 textLayoutModule->skipLE->setEnabled(!indent);
1547 textLayoutModule->skipLengthCO->setEnabled(!indent);
1549 setIndent(textLayoutModule->indentCO->currentIndex());
1553 void GuiDocument::setSkip(int item)
1555 bool const enable = (item == 3);
1556 textLayoutModule->skipLE->setEnabled(enable);
1557 textLayoutModule->skipLengthCO->setEnabled(enable);
1562 void GuiDocument::enableSkip(bool skip)
1564 textLayoutModule->indentLE->setEnabled(!skip);
1565 textLayoutModule->indentLengthCO->setEnabled(!skip);
1567 setSkip(textLayoutModule->skipCO->currentIndex());
1571 void GuiDocument::setMargins()
1573 bool const extern_geometry =
1574 documentClass().provides("geometry");
1575 marginsModule->marginCB->setEnabled(!extern_geometry);
1576 if (extern_geometry) {
1577 marginsModule->marginCB->setChecked(false);
1578 setCustomMargins(true);
1580 marginsModule->marginCB->setChecked(!bp_.use_geometry);
1581 setCustomMargins(!bp_.use_geometry);
1586 void GuiDocument::papersizeChanged(int paper_size)
1588 setCustomPapersize(paper_size == 1);
1592 void GuiDocument::setCustomPapersize(bool custom)
1594 pageLayoutModule->paperwidthL->setEnabled(custom);
1595 pageLayoutModule->paperwidthLE->setEnabled(custom);
1596 pageLayoutModule->paperwidthUnitCO->setEnabled(custom);
1597 pageLayoutModule->paperheightL->setEnabled(custom);
1598 pageLayoutModule->paperheightLE->setEnabled(custom);
1599 pageLayoutModule->paperheightLE->setFocus();
1600 pageLayoutModule->paperheightUnitCO->setEnabled(custom);
1604 void GuiDocument::setColSep()
1606 setCustomMargins(marginsModule->marginCB->checkState() == Qt::Checked);
1610 void GuiDocument::setCustomMargins(bool custom)
1612 marginsModule->topL->setEnabled(!custom);
1613 marginsModule->topLE->setEnabled(!custom);
1614 marginsModule->topUnit->setEnabled(!custom);
1616 marginsModule->bottomL->setEnabled(!custom);
1617 marginsModule->bottomLE->setEnabled(!custom);
1618 marginsModule->bottomUnit->setEnabled(!custom);
1620 marginsModule->innerL->setEnabled(!custom);
1621 marginsModule->innerLE->setEnabled(!custom);
1622 marginsModule->innerUnit->setEnabled(!custom);
1624 marginsModule->outerL->setEnabled(!custom);
1625 marginsModule->outerLE->setEnabled(!custom);
1626 marginsModule->outerUnit->setEnabled(!custom);
1628 marginsModule->headheightL->setEnabled(!custom);
1629 marginsModule->headheightLE->setEnabled(!custom);
1630 marginsModule->headheightUnit->setEnabled(!custom);
1632 marginsModule->headsepL->setEnabled(!custom);
1633 marginsModule->headsepLE->setEnabled(!custom);
1634 marginsModule->headsepUnit->setEnabled(!custom);
1636 marginsModule->footskipL->setEnabled(!custom);
1637 marginsModule->footskipLE->setEnabled(!custom);
1638 marginsModule->footskipUnit->setEnabled(!custom);
1640 bool const enableColSep = !custom &&
1641 textLayoutModule->twoColumnCB->checkState() == Qt::Checked;
1642 marginsModule->columnsepL->setEnabled(enableColSep);
1643 marginsModule->columnsepLE->setEnabled(enableColSep);
1644 marginsModule->columnsepUnit->setEnabled(enableColSep);
1648 void GuiDocument::changeBackgroundColor()
1650 QColor const & newColor = QColorDialog::getColor(
1651 rgb2qcolor(set_backgroundcolor), asQWidget());
1652 if (!newColor.isValid())
1654 // set the button color and text
1655 colorModule->backgroundPB->setStyleSheet(
1656 colorButtonStyleSheet(newColor));
1657 colorModule->backgroundPB->setText(qt_("&Change..."));
1659 set_backgroundcolor = rgbFromHexName(fromqstr(newColor.name()));
1660 is_backgroundcolor = true;
1665 void GuiDocument::deleteBackgroundColor()
1667 // set the button color back to default by setting an empty StyleSheet
1668 colorModule->backgroundPB->setStyleSheet(QLatin1String(""));
1669 // change button text
1670 colorModule->backgroundPB->setText(qt_("&Default..."));
1671 // save default color (white)
1672 set_backgroundcolor = rgbFromHexName("#ffffff");
1673 is_backgroundcolor = false;
1678 void GuiDocument::changeFontColor()
1680 QColor const & newColor = QColorDialog::getColor(
1681 rgb2qcolor(set_fontcolor), asQWidget());
1682 if (!newColor.isValid())
1684 // set the button color and text
1685 colorModule->fontColorPB->setStyleSheet(
1686 colorButtonStyleSheet(newColor));
1687 colorModule->fontColorPB->setText(qt_("&Change..."));
1689 set_fontcolor = rgbFromHexName(fromqstr(newColor.name()));
1690 is_fontcolor = true;
1695 void GuiDocument::deleteFontColor()
1697 // set the button color back to default by setting an empty StyleSheet
1698 colorModule->fontColorPB->setStyleSheet(QLatin1String(""));
1699 // change button text
1700 colorModule->fontColorPB->setText(qt_("&Default..."));
1701 // save default color (black)
1702 set_fontcolor = rgbFromHexName("#000000");
1703 is_fontcolor = false;
1708 void GuiDocument::changeNoteFontColor()
1710 QColor const & newColor = QColorDialog::getColor(
1711 rgb2qcolor(set_notefontcolor), asQWidget());
1712 if (!newColor.isValid())
1714 // set the button color
1715 colorModule->noteFontColorPB->setStyleSheet(
1716 colorButtonStyleSheet(newColor));
1718 set_notefontcolor = rgbFromHexName(fromqstr(newColor.name()));
1723 void GuiDocument::deleteNoteFontColor()
1725 // set the button color back to pref
1726 theApp()->getRgbColor(Color_greyedouttext, set_notefontcolor);
1727 colorModule->noteFontColorPB->setStyleSheet(
1728 colorButtonStyleSheet(rgb2qcolor(set_notefontcolor)));
1733 void GuiDocument::changeBoxBackgroundColor()
1735 QColor const & newColor = QColorDialog::getColor(
1736 rgb2qcolor(set_boxbgcolor), asQWidget());
1737 if (!newColor.isValid())
1739 // set the button color
1740 colorModule->boxBackgroundPB->setStyleSheet(
1741 colorButtonStyleSheet(newColor));
1743 set_boxbgcolor = rgbFromHexName(fromqstr(newColor.name()));
1748 void GuiDocument::deleteBoxBackgroundColor()
1750 // set the button color back to pref
1751 theApp()->getRgbColor(Color_shadedbg, set_boxbgcolor);
1752 colorModule->boxBackgroundPB->setStyleSheet(
1753 colorButtonStyleSheet(rgb2qcolor(set_boxbgcolor)));
1758 void GuiDocument::languageChanged(int i)
1760 // some languages only work with polyglossia
1761 Language const * lang = lyx::languages.getLanguage(
1762 fromqstr(langModule->languageCO->itemData(i).toString()));
1763 if (lang->babel().empty() && !lang->polyglossia().empty()) {
1764 // If we force to switch fontspec on, store
1765 // current state (#8717)
1766 if (fontModule->osFontsCB->isEnabled())
1767 forced_fontspec_activation =
1768 !fontModule->osFontsCB->isChecked();
1769 fontModule->osFontsCB->setChecked(true);
1770 fontModule->osFontsCB->setEnabled(false);
1773 fontModule->osFontsCB->setEnabled(true);
1774 // If we have forced to switch fontspec on,
1775 // restore previous state (#8717)
1776 if (forced_fontspec_activation)
1777 fontModule->osFontsCB->setChecked(false);
1778 forced_fontspec_activation = false;
1781 // set appropriate quotation mark style
1782 if (!lang->quoteStyle().empty()) {
1783 langModule->quoteStyleCO->setCurrentIndex(
1784 bp_.getQuoteStyle(lang->quoteStyle()));
1789 void GuiDocument::osFontsChanged(bool nontexfonts)
1791 bool const tex_fonts = !nontexfonts;
1792 // store current fonts
1793 QString const font_roman = fontModule->fontsRomanCO->itemData(
1794 fontModule->fontsRomanCO->currentIndex()).toString();
1795 QString const font_sans = fontModule->fontsSansCO->itemData(
1796 fontModule->fontsSansCO->currentIndex()).toString();
1797 QString const font_typewriter = fontModule->fontsTypewriterCO->itemData(
1798 fontModule->fontsTypewriterCO->currentIndex()).toString();
1799 QString const font_math = fontModule->fontsMathCO->itemData(
1800 fontModule->fontsMathCO->currentIndex()).toString();
1801 int const font_sf_scale = fontModule->scaleSansSB->value();
1802 int const font_tt_scale = fontModule->scaleTypewriterSB->value();
1805 // store default format
1806 QString const dformat = outputModule->defaultFormatCO->itemData(
1807 outputModule->defaultFormatCO->currentIndex()).toString();
1808 updateDefaultFormat();
1809 // try to restore default format
1810 int index = outputModule->defaultFormatCO->findData(dformat);
1811 // set to default if format is not found
1814 outputModule->defaultFormatCO->setCurrentIndex(index);
1816 // try to restore fonts which were selected two toggles ago
1817 index = fontModule->fontsRomanCO->findData(fontModule->font_roman);
1819 fontModule->fontsRomanCO->setCurrentIndex(index);
1820 index = fontModule->fontsSansCO->findData(fontModule->font_sans);
1822 fontModule->fontsSansCO->setCurrentIndex(index);
1823 index = fontModule->fontsTypewriterCO->findData(fontModule->font_typewriter);
1825 fontModule->fontsTypewriterCO->setCurrentIndex(index);
1826 index = fontModule->fontsMathCO->findData(fontModule->font_math);
1828 fontModule->fontsMathCO->setCurrentIndex(index);
1829 // save fonts for next next toggle
1830 fontModule->font_roman = font_roman;
1831 fontModule->font_sans = font_sans;
1832 fontModule->font_typewriter = font_typewriter;
1833 fontModule->font_math = font_math;
1834 fontModule->font_sf_scale = font_sf_scale;
1835 fontModule->font_tt_scale = font_tt_scale;
1837 langModule->encodingCO->setEnabled(tex_fonts &&
1838 !langModule->defaultencodingRB->isChecked());
1839 langModule->defaultencodingRB->setEnabled(tex_fonts);
1840 langModule->otherencodingRB->setEnabled(tex_fonts);
1842 fontModule->fontsDefaultCO->setEnabled(tex_fonts);
1843 fontModule->fontsDefaultLA->setEnabled(tex_fonts);
1844 fontModule->cjkFontLE->setEnabled(tex_fonts);
1845 fontModule->cjkFontLA->setEnabled(tex_fonts);
1847 updateFontOptions();
1849 fontModule->fontencLA->setEnabled(tex_fonts);
1850 fontModule->fontencCO->setEnabled(tex_fonts);
1852 fontModule->fontencLE->setEnabled(false);
1854 fontencChanged(fontModule->fontencCO->currentIndex());
1858 void GuiDocument::mathFontChanged(int)
1860 updateFontOptions();
1864 void GuiDocument::fontOsfToggled(bool state)
1866 if (fontModule->osFontsCB->isChecked())
1868 QString font = fontModule->fontsRomanCO->itemData(
1869 fontModule->fontsRomanCO->currentIndex()).toString();
1870 if (hasMonolithicExpertSet(font))
1871 fontModule->fontScCB->setChecked(state);
1875 void GuiDocument::fontScToggled(bool state)
1877 if (fontModule->osFontsCB->isChecked())
1879 QString font = fontModule->fontsRomanCO->itemData(
1880 fontModule->fontsRomanCO->currentIndex()).toString();
1881 if (hasMonolithicExpertSet(font))
1882 fontModule->fontOsfCB->setChecked(state);
1886 void GuiDocument::updateFontOptions()
1888 bool const tex_fonts = !fontModule->osFontsCB->isChecked();
1891 font = fontModule->fontsSansCO->itemData(
1892 fontModule->fontsSansCO->currentIndex()).toString();
1893 bool scaleable = providesScale(font);
1894 fontModule->scaleSansSB->setEnabled(scaleable);
1895 fontModule->scaleSansLA->setEnabled(scaleable);
1897 font = fontModule->fontsTypewriterCO->itemData(
1898 fontModule->fontsTypewriterCO->currentIndex()).toString();
1899 scaleable = providesScale(font);
1900 fontModule->scaleTypewriterSB->setEnabled(scaleable);
1901 fontModule->scaleTypewriterLA->setEnabled(scaleable);
1903 font = fontModule->fontsRomanCO->itemData(
1904 fontModule->fontsRomanCO->currentIndex()).toString();
1905 fontModule->fontScCB->setEnabled(providesSC(font));
1906 fontModule->fontOsfCB->setEnabled(providesOSF(font));
1907 updateMathFonts(font);
1911 void GuiDocument::updateFontsize(string const & items, string const & sel)
1913 fontModule->fontsizeCO->clear();
1914 fontModule->fontsizeCO->addItem(qt_("Default"));
1916 for (int n = 0; !token(items,'|',n).empty(); ++n)
1917 fontModule->fontsizeCO->
1918 addItem(toqstr(token(items,'|',n)));
1920 for (int n = 0; n < fontModule->fontsizeCO->count(); ++n) {
1921 if (fromqstr(fontModule->fontsizeCO->itemText(n)) == sel) {
1922 fontModule->fontsizeCO->setCurrentIndex(n);
1929 bool GuiDocument::ot1() const
1931 QString const fontenc =
1932 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
1933 return (fontenc == "default"
1934 || (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
1935 || (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
1939 bool GuiDocument::completeFontset() const
1941 return (fontModule->fontsSansCO->itemData(
1942 fontModule->fontsSansCO->currentIndex()).toString() == "default"
1943 && fontModule->fontsSansCO->itemData(
1944 fontModule->fontsTypewriterCO->currentIndex()).toString() == "default");
1948 bool GuiDocument::noMathFont() const
1950 return (fontModule->fontsMathCO->itemData(
1951 fontModule->fontsMathCO->currentIndex()).toString() == "default");
1955 void GuiDocument::updateTexFonts()
1957 LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
1959 LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
1960 LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
1961 for (; it != end; ++it) {
1962 LaTeXFont lf = it->second;
1963 if (lf.name().empty()) {
1964 LYXERR0("Error: Unnamed font: " << it->first);
1967 docstring const family = lf.family();
1968 docstring guiname = translateIfPossible(lf.guiname());
1969 if (!lf.available(ot1(), noMathFont()))
1970 guiname += _(" (not installed)");
1972 rmfonts_.insert(toqstr(guiname), toqstr(it->first));
1973 else if (family == "sf")
1974 sffonts_.insert(toqstr(guiname), toqstr(it->first));
1975 else if (family == "tt")
1976 ttfonts_.insert(toqstr(guiname), toqstr(it->first));
1977 else if (family == "math")
1978 mathfonts_.insert(toqstr(guiname), toqstr(it->first));
1983 void GuiDocument::updateFontlist()
1985 fontModule->fontsRomanCO->clear();
1986 fontModule->fontsSansCO->clear();
1987 fontModule->fontsTypewriterCO->clear();
1988 fontModule->fontsMathCO->clear();
1990 // With fontspec (XeTeX, LuaTeX), we have access to all system fonts, but not the LaTeX fonts
1991 if (fontModule->osFontsCB->isChecked()) {
1992 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
1993 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
1994 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
1995 QString unimath = qt_("Non-TeX Fonts Default");
1996 if (!LaTeXFeatures::isAvailable("unicode-math"))
1997 unimath += qt_(" (not available)");
1998 fontModule->fontsMathCO->addItem(qt_("Class Default (TeX Fonts)"), QString("auto"));
1999 fontModule->fontsMathCO->addItem(unimath, QString("default"));
2001 QFontDatabase fontdb;
2002 QStringList families(fontdb.families());
2003 for (QStringList::Iterator it = families.begin(); it != families.end(); ++it) {
2004 fontModule->fontsRomanCO->addItem(*it, *it);
2005 fontModule->fontsSansCO->addItem(*it, *it);
2006 fontModule->fontsTypewriterCO->addItem(*it, *it);
2011 if (rmfonts_.empty())
2014 fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
2015 QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
2016 while (rmi != rmfonts_.constEnd()) {
2017 fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
2021 fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
2022 QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
2023 while (sfi != sffonts_.constEnd()) {
2024 fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
2028 fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
2029 QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
2030 while (tti != ttfonts_.constEnd()) {
2031 fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
2035 fontModule->fontsMathCO->addItem(qt_("Automatic"), QString("auto"));
2036 fontModule->fontsMathCO->addItem(qt_("Class Default"), QString("default"));
2037 QMap<QString, QString>::const_iterator mmi = mathfonts_.constBegin();
2038 while (mmi != mathfonts_.constEnd()) {
2039 fontModule->fontsMathCO->addItem(mmi.key(), mmi.value());
2045 void GuiDocument::fontencChanged(int item)
2047 fontModule->fontencLE->setEnabled(
2048 fontModule->fontencCO->itemData(item).toString() == "custom");
2049 // The availability of TeX fonts depends on the font encoding
2051 updateFontOptions();
2055 void GuiDocument::updateMathFonts(QString const & rm)
2057 if (fontModule->osFontsCB->isChecked())
2059 QString const math =
2060 fontModule->fontsMathCO->itemData(fontModule->fontsMathCO->currentIndex()).toString();
2061 int const i = fontModule->fontsMathCO->findData("default");
2062 if (providesNoMath(rm) && i == -1)
2063 fontModule->fontsMathCO->insertItem(1, qt_("Class Default"), QString("default"));
2064 else if (!providesNoMath(rm) && i != -1) {
2065 int const c = fontModule->fontsMathCO->currentIndex();
2066 fontModule->fontsMathCO->removeItem(i);
2068 fontModule->fontsMathCO->setCurrentIndex(0);
2073 void GuiDocument::romanChanged(int item)
2075 if (fontModule->osFontsCB->isChecked())
2077 QString const font =
2078 fontModule->fontsRomanCO->itemData(item).toString();
2079 fontModule->fontScCB->setEnabled(providesSC(font));
2080 fontModule->fontOsfCB->setEnabled(providesOSF(font));
2081 updateMathFonts(font);
2085 void GuiDocument::sansChanged(int item)
2087 if (fontModule->osFontsCB->isChecked())
2089 QString const font =
2090 fontModule->fontsSansCO->itemData(item).toString();
2091 bool scaleable = providesScale(font);
2092 fontModule->scaleSansSB->setEnabled(scaleable);
2093 fontModule->scaleSansLA->setEnabled(scaleable);
2097 void GuiDocument::ttChanged(int item)
2099 if (fontModule->osFontsCB->isChecked())
2101 QString const font =
2102 fontModule->fontsTypewriterCO->itemData(item).toString();
2103 bool scaleable = providesScale(font);
2104 fontModule->scaleTypewriterSB->setEnabled(scaleable);
2105 fontModule->scaleTypewriterLA->setEnabled(scaleable);
2109 void GuiDocument::updatePagestyle(string const & items, string const & sel)
2112 pageLayoutModule->pagestyleCO->clear();
2113 pageLayoutModule->pagestyleCO->addItem(qt_("Default"));
2115 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2116 string style = token(items, '|', n);
2117 QString style_gui = qt_(style);
2118 pagestyles.push_back(pair<string, QString>(style, style_gui));
2119 pageLayoutModule->pagestyleCO->addItem(style_gui);
2122 if (sel == "default") {
2123 pageLayoutModule->pagestyleCO->setCurrentIndex(0);
2129 for (size_t i = 0; i < pagestyles.size(); ++i)
2130 if (pagestyles[i].first == sel)
2131 nn = pageLayoutModule->pagestyleCO->findText(pagestyles[i].second);
2134 pageLayoutModule->pagestyleCO->setCurrentIndex(nn);
2138 void GuiDocument::browseLayout()
2140 QString const label1 = qt_("Layouts|#o#O");
2141 QString const dir1 = toqstr(lyxrc.document_path);
2142 QStringList const filter(qt_("LyX Layout (*.layout)"));
2143 QString file = browseRelToParent(QString(), bufferFilePath(),
2144 qt_("Local layout file"), filter, false,
2147 if (!file.endsWith(".layout"))
2150 FileName layoutFile = support::makeAbsPath(fromqstr(file),
2151 fromqstr(bufferFilePath()));
2153 int const ret = Alert::prompt(_("Local layout file"),
2154 _("The layout file you have selected is a local layout\n"
2155 "file, not one in the system or user directory.\n"
2156 "Your document will not work with this layout if you\n"
2157 "move the layout file to a different directory."),
2158 1, 1, _("&Set Layout"), _("&Cancel"));
2162 // load the layout file
2163 LayoutFileList & bcl = LayoutFileList::get();
2164 string classname = layoutFile.onlyFileName();
2165 // this will update an existing layout if that layout has been loaded before.
2166 LayoutFileIndex name = support::onlyFileName(bcl.addLocalLayout(
2167 classname.substr(0, classname.size() - 7),
2168 layoutFile.onlyPath().absFileName()));
2171 Alert::error(_("Error"),
2172 _("Unable to read local layout file."));
2176 const_cast<Buffer &>(buffer()).setLayoutPos(layoutFile.onlyPath().absFileName());
2178 // do not trigger classChanged if there is no change.
2179 if (latexModule->classCO->currentText() == toqstr(name))
2183 bool const avail = latexModule->classCO->set(toqstr(name));
2185 LayoutFile const & tc = bcl[name];
2186 docstring const guiname = translateIfPossible(from_utf8(tc.description()));
2187 // tooltip sensu "KOMA-Script Article [Class 'scrartcl']"
2188 QString tooltip = toqstr(bformat(_("%1$s [Class '%2$s']"), guiname, from_utf8(tc.latexname())));
2189 tooltip += '\n' + qt_("This is a local layout file.");
2190 latexModule->classCO->addItemSort(toqstr(tc.name()), toqstr(guiname),
2191 toqstr(translateIfPossible(from_utf8(tc.category()))),
2193 true, true, true, true);
2194 latexModule->classCO->set(toqstr(name));
2201 void GuiDocument::browseMaster()
2203 QString const title = qt_("Select master document");
2204 QString const dir1 = toqstr(lyxrc.document_path);
2205 QString const old = latexModule->childDocLE->text();
2206 QString const docpath = toqstr(support::onlyPath(buffer().absFileName()));
2207 QStringList const filter(qt_("LyX Files (*.lyx)"));
2208 QString file = browseRelToSub(old, docpath, title, filter, false,
2209 qt_("Documents|#o#O"), toqstr(lyxrc.document_path));
2211 if (!file.isEmpty())
2212 latexModule->childDocLE->setText(file);
2216 void GuiDocument::classChanged_adaptor()
2218 const_cast<Buffer &>(buffer()).setLayoutPos(string());
2223 void GuiDocument::classChanged()
2225 int idx = latexModule->classCO->currentIndex();
2228 string const classname = fromqstr(latexModule->classCO->getData(idx));
2230 if (applyPB->isEnabled()) {
2231 int const ret = Alert::prompt(_("Unapplied changes"),
2232 _("Some changes in the dialog were not yet applied.\n"
2233 "If you do not apply now, they will be lost after this action."),
2234 1, 1, _("&Apply"), _("&Dismiss"));
2239 // We load the TextClass as soon as it is selected. This is
2240 // necessary so that other options in the dialog can be updated
2241 // according to the new class. Note, however, that, if you use
2242 // the scroll wheel when sitting on the combo box, we'll load a
2243 // lot of TextClass objects very quickly....
2244 if (!bp_.setBaseClass(classname)) {
2245 Alert::error(_("Error"), _("Unable to set document class."));
2248 if (lyxrc.auto_reset_options)
2249 bp_.useClassDefaults();
2251 // With the introduction of modules came a distinction between the base
2252 // class and the document class. The former corresponds to the main layout
2253 // file; the latter is that plus the modules (or the document-specific layout,
2254 // or whatever else there could be). Our parameters come from the document
2255 // class. So when we set the base class, we also need to recreate the document
2256 // class. Otherwise, we still have the old one.
2257 bp_.makeDocumentClass();
2262 void GuiDocument::languagePackageChanged(int i)
2264 langModule->languagePackageLE->setEnabled(
2265 langModule->languagePackageCO->itemData(i).toString() == "custom");
2269 void GuiDocument::biblioChanged()
2271 biblioChanged_ = true;
2276 void GuiDocument::bibtexChanged(int n)
2278 biblioModule->bibtexOptionsLE->setEnabled(
2279 biblioModule->bibtexCO->itemData(n).toString() != "default");
2284 void GuiDocument::setAuthorYear(bool authoryear)
2287 biblioModule->citeStyleCO->setCurrentIndex(0);
2292 void GuiDocument::setNumerical(bool numerical)
2295 biblioModule->citeStyleCO->setCurrentIndex(1);
2300 void GuiDocument::updateEngineType(string const & items, CiteEngineType const & sel)
2302 engine_types_.clear();
2306 for (int n = 0; !token(items, '|', n).empty(); ++n) {
2308 string style = token(items, '|', n);
2309 engine_types_.push_back(style);
2313 case ENGINE_TYPE_AUTHORYEAR:
2314 biblioModule->citeStyleCO->setCurrentIndex(0);
2316 case ENGINE_TYPE_NUMERICAL:
2317 case ENGINE_TYPE_DEFAULT:
2318 biblioModule->citeStyleCO->setCurrentIndex(1);
2322 biblioModule->citationStyleL->setEnabled(nn > 1);
2323 biblioModule->citeStyleCO->setEnabled(nn > 1);
2328 // If the textclass allows only one of authoryear or numerical,
2329 // we have no choice but to force that engine type.
2330 if (engine_types_[0] == "authoryear")
2331 biblioModule->citeStyleCO->setCurrentIndex(0);
2333 biblioModule->citeStyleCO->setCurrentIndex(1);
2339 // both of these should take a vector<docstring>
2341 // This is an insanely complicated attempt to make this sort of thing
2342 // work with RTL languages.
2343 docstring formatStrVec(vector<string> const & v, docstring const & s)
2345 //this mess formats the list as "v[0], v[1], ..., [s] v[n]"
2349 return translateIfPossible(from_utf8(v[0]));
2350 if (v.size() == 2) {
2351 docstring retval = _("%1$s and %2$s");
2352 retval = subst(retval, _("and"), s);
2353 return bformat(retval, translateIfPossible(from_utf8(v[0])),
2354 translateIfPossible(from_utf8(v[1])));
2356 // The idea here is to format all but the last two items...
2357 int const vSize = v.size();
2358 docstring t2 = _("%1$s, %2$s");
2359 docstring retval = translateIfPossible(from_utf8(v[0]));
2360 for (int i = 1; i < vSize - 2; ++i)
2361 retval = bformat(t2, retval, translateIfPossible(from_utf8(v[i])));
2362 //...and then to plug them, and the last two, into this schema
2363 docstring t = _("%1$s, %2$s, and %3$s");
2364 t = subst(t, _("and"), s);
2365 return bformat(t, retval, translateIfPossible(from_utf8(v[vSize - 2])),
2366 translateIfPossible(from_utf8(v[vSize - 1])));
2369 vector<string> idsToNames(vector<string> const & idList)
2371 vector<string> retval;
2372 vector<string>::const_iterator it = idList.begin();
2373 vector<string>::const_iterator end = idList.end();
2374 for (; it != end; ++it) {
2375 LyXModule const * const mod = theModuleList[*it];
2377 retval.push_back(to_utf8(bformat(_("%1$s (unavailable)"),
2378 translateIfPossible(from_utf8(*it)))));
2380 retval.push_back(mod->getName());
2384 } // end anonymous namespace
2387 void GuiDocument::modulesToParams(BufferParams & bp)
2389 // update list of loaded modules
2390 bp.clearLayoutModules();
2391 int const srows = modules_sel_model_.rowCount();
2392 for (int i = 0; i < srows; ++i)
2393 bp.addLayoutModule(modules_sel_model_.getIDString(i));
2395 // update the list of removed modules
2396 bp.clearRemovedModules();
2397 LayoutModuleList const & reqmods = bp.baseClass()->defaultModules();
2398 list<string>::const_iterator rit = reqmods.begin();
2399 list<string>::const_iterator ren = reqmods.end();
2401 // check each of the default modules
2402 for (; rit != ren; ++rit) {
2403 list<string>::const_iterator mit = bp.getModules().begin();
2404 list<string>::const_iterator men = bp.getModules().end();
2406 for (; mit != men; ++mit) {
2413 // the module isn't present so must have been removed by the user
2414 bp.addRemovedModule(*rit);
2419 void GuiDocument::modulesChanged()
2421 modulesToParams(bp_);
2423 if (applyPB->isEnabled() && nonModuleChanged_) {
2424 int const ret = Alert::prompt(_("Unapplied changes"),
2425 _("Some changes in the dialog were not yet applied.\n"
2426 "If you do not apply now, they will be lost after this action."),
2427 1, 1, _("&Apply"), _("&Dismiss"));
2432 bp_.makeDocumentClass();
2438 void GuiDocument::updateModuleInfo()
2440 selectionManager->update();
2442 //Module description
2443 bool const focus_on_selected = selectionManager->selectedFocused();
2444 QAbstractItemView * lv;
2445 if (focus_on_selected)
2446 lv = modulesModule->selectedLV;
2448 lv = modulesModule->availableLV;
2449 if (lv->selectionModel()->selectedIndexes().isEmpty()) {
2450 modulesModule->infoML->document()->clear();
2453 QModelIndex const & idx = lv->selectionModel()->currentIndex();
2454 GuiIdListModel const & id_model =
2455 focus_on_selected ? modules_sel_model_ : modules_av_model_;
2456 string const modName = id_model.getIDString(idx.row());
2457 docstring desc = getModuleDescription(modName);
2459 LayoutModuleList const & provmods = bp_.baseClass()->providedModules();
2460 if (std::find(provmods.begin(), provmods.end(), modName) != provmods.end()) {
2463 desc += _("Module provided by document class.");
2466 docstring cat = getModuleCategory(modName);
2470 desc += bformat(_("Category: %1$s."), cat);
2473 vector<string> pkglist = getPackageList(modName);
2474 docstring pkgdesc = formatStrVec(pkglist, _("and"));
2475 if (!pkgdesc.empty()) {
2478 desc += bformat(_("Package(s) required: %1$s."), pkgdesc);
2481 pkglist = getRequiredList(modName);
2482 if (!pkglist.empty()) {
2483 vector<string> const reqdescs = idsToNames(pkglist);
2484 pkgdesc = formatStrVec(reqdescs, _("or"));
2487 desc += bformat(_("Modules required: %1$s."), pkgdesc);
2490 pkglist = getExcludedList(modName);
2491 if (!pkglist.empty()) {
2492 vector<string> const reqdescs = idsToNames(pkglist);
2493 pkgdesc = formatStrVec(reqdescs, _( "and"));
2496 desc += bformat(_("Modules excluded: %1$s."), pkgdesc);
2499 if (!isModuleAvailable(modName)) {
2502 desc += _("WARNING: Some required packages are unavailable!");
2505 modulesModule->infoML->document()->setPlainText(toqstr(desc));
2509 void GuiDocument::updateNumbering()
2511 DocumentClass const & tclass = documentClass();
2513 numberingModule->tocTW->setUpdatesEnabled(false);
2514 numberingModule->tocTW->clear();
2516 int const depth = numberingModule->depthSL->value();
2517 int const toc = numberingModule->tocSL->value();
2518 QString const no = qt_("No");
2519 QString const yes = qt_("Yes");
2520 QTreeWidgetItem * item = 0;
2522 DocumentClass::const_iterator lit = tclass.begin();
2523 DocumentClass::const_iterator len = tclass.end();
2524 for (; lit != len; ++lit) {
2525 int const toclevel = lit->toclevel;
2526 if (toclevel != Layout::NOT_IN_TOC && !lit->counter.empty()) {
2527 item = new QTreeWidgetItem(numberingModule->tocTW);
2528 item->setText(0, toqstr(translateIfPossible(lit->name())));
2529 item->setText(1, (toclevel <= depth) ? yes : no);
2530 item->setText(2, (toclevel <= toc) ? yes : no);
2534 numberingModule->tocTW->setUpdatesEnabled(true);
2535 numberingModule->tocTW->update();
2539 void GuiDocument::updateDefaultFormat()
2543 // make a copy in order to consider unapplied changes
2544 BufferParams param_copy = buffer().params();
2545 param_copy.useNonTeXFonts = fontModule->osFontsCB->isChecked();
2546 int const idx = latexModule->classCO->currentIndex();
2548 string const classname = fromqstr(latexModule->classCO->getData(idx));
2549 param_copy.setBaseClass(classname);
2550 param_copy.makeDocumentClass(true);
2552 outputModule->defaultFormatCO->blockSignals(true);
2553 outputModule->defaultFormatCO->clear();
2554 outputModule->defaultFormatCO->addItem(qt_("Default"),
2555 QVariant(QString("default")));
2556 typedef vector<Format const *> Formats;
2557 Formats formats = param_copy.exportableFormats(true);
2558 sort(formats.begin(), formats.end(), Format::formatSorter);
2559 Formats::const_iterator cit = formats.begin();
2560 Formats::const_iterator end = formats.end();
2561 for (; cit != end; ++cit)
2562 outputModule->defaultFormatCO->addItem(qt_((*cit)->prettyname()),
2563 QVariant(toqstr((*cit)->name())));
2564 outputModule->defaultFormatCO->blockSignals(false);
2568 bool GuiDocument::isChildIncluded(string const & child)
2570 if (includeonlys_.empty())
2572 return (std::find(includeonlys_.begin(),
2573 includeonlys_.end(), child) != includeonlys_.end());
2577 void GuiDocument::applyView()
2580 preambleModule->apply(bp_);
2581 localLayout->apply(bp_);
2584 bp_.suppress_date = latexModule->suppressDateCB->isChecked();
2585 bp_.use_refstyle = latexModule->refstyleCB->isChecked();
2588 if (biblioModule->citeNatbibRB->isChecked())
2589 bp_.setCiteEngine("natbib");
2590 else if (biblioModule->citeJurabibRB->isChecked())
2591 bp_.setCiteEngine("jurabib");
2592 if (biblioModule->citeDefaultRB->isChecked()) {
2593 bp_.setCiteEngine("basic");
2594 bp_.setCiteEngineType(ENGINE_TYPE_DEFAULT);
2597 if (biblioModule->citeStyleCO->currentIndex())
2598 bp_.setCiteEngineType(ENGINE_TYPE_NUMERICAL);
2600 bp_.setCiteEngineType(ENGINE_TYPE_AUTHORYEAR);
2603 biblioModule->bibtopicCB->isChecked();
2605 bp_.biblio_style = fromqstr(biblioModule->bibtexStyleLE->text());
2607 string const bibtex_command =
2608 fromqstr(biblioModule->bibtexCO->itemData(
2609 biblioModule->bibtexCO->currentIndex()).toString());
2610 string const bibtex_options =
2611 fromqstr(biblioModule->bibtexOptionsLE->text());
2612 if (bibtex_command == "default" || bibtex_options.empty())
2613 bp_.bibtex_command = bibtex_command;
2615 bp_.bibtex_command = bibtex_command + " " + bibtex_options;
2617 if (biblioChanged_) {
2618 buffer().invalidateBibinfoCache();
2619 buffer().removeBiblioTempFiles();
2623 indicesModule->apply(bp_);
2625 // language & quotes
2626 if (langModule->defaultencodingRB->isChecked()) {
2627 bp_.inputenc = "auto";
2629 int i = langModule->encodingCO->currentIndex();
2631 bp_.inputenc = "default";
2633 QString const enc_gui =
2634 langModule->encodingCO->currentText();
2635 Encodings::const_iterator it = encodings.begin();
2636 Encodings::const_iterator const end = encodings.end();
2638 for (; it != end; ++it) {
2639 if (qt_(it->guiName()) == enc_gui &&
2641 bp_.inputenc = it->name();
2647 // should not happen
2648 lyxerr << "GuiDocument::apply: Unknown encoding! Resetting to default" << endl;
2649 bp_.inputenc = "default";
2654 bp_.quotes_language = (InsetQuotes::QuoteLanguage) langModule->quoteStyleCO->itemData(
2655 langModule->quoteStyleCO->currentIndex()).toInt();
2657 QString const langname = langModule->languageCO->itemData(
2658 langModule->languageCO->currentIndex()).toString();
2659 Language const * newlang = lyx::languages.getLanguage(fromqstr(langname));
2660 Cursor & cur = const_cast<BufferView *>(bufferview())->cursor();
2661 // If current cursor language was the document language, then update it too.
2662 if (cur.current_font.language() == bp_.language) {
2663 cur.current_font.setLanguage(newlang);
2664 cur.real_current_font.setLanguage(newlang);
2666 bp_.language = newlang;
2668 QString const pack = langModule->languagePackageCO->itemData(
2669 langModule->languagePackageCO->currentIndex()).toString();
2670 if (pack == "custom")
2672 fromqstr(langModule->languagePackageLE->text());
2674 bp_.lang_package = fromqstr(pack);
2677 bp_.backgroundcolor = set_backgroundcolor;
2678 bp_.isbackgroundcolor = is_backgroundcolor;
2679 bp_.fontcolor = set_fontcolor;
2680 bp_.isfontcolor = is_fontcolor;
2681 bp_.notefontcolor = set_notefontcolor;
2682 bp_.boxbgcolor = set_boxbgcolor;
2685 if (bp_.documentClass().hasTocLevels()) {
2686 bp_.tocdepth = numberingModule->tocSL->value();
2687 bp_.secnumdepth = numberingModule->depthSL->value();
2691 bp_.user_defined_bullet(0) = bulletsModule->bullet(0);
2692 bp_.user_defined_bullet(1) = bulletsModule->bullet(1);
2693 bp_.user_defined_bullet(2) = bulletsModule->bullet(2);
2694 bp_.user_defined_bullet(3) = bulletsModule->bullet(3);
2697 bp_.graphics_driver =
2698 tex_graphics[latexModule->psdriverCO->currentIndex()];
2701 int idx = latexModule->classCO->currentIndex();
2703 string const classname = fromqstr(latexModule->classCO->getData(idx));
2704 bp_.setBaseClass(classname);
2708 modulesToParams(bp_);
2711 map<string, string> const & packages = BufferParams::auto_packages();
2712 for (map<string, string>::const_iterator it = packages.begin();
2713 it != packages.end(); ++it) {
2714 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
2717 int row = mathsModule->packagesTW->row(item);
2718 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
2719 if (rb->isChecked()) {
2720 bp_.use_package(it->first, BufferParams::package_auto);
2723 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
2724 if (rb->isChecked()) {
2725 bp_.use_package(it->first, BufferParams::package_on);
2728 rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
2729 if (rb->isChecked())
2730 bp_.use_package(it->first, BufferParams::package_off);
2734 if (pageLayoutModule->pagestyleCO->currentIndex() == 0)
2735 bp_.pagestyle = "default";
2737 QString style_gui = pageLayoutModule->pagestyleCO->currentText();
2738 for (size_t i = 0; i != pagestyles.size(); ++i)
2739 if (pagestyles[i].second == style_gui)
2740 bp_.pagestyle = pagestyles[i].first;
2744 switch (textLayoutModule->lspacingCO->currentIndex()) {
2746 bp_.spacing().set(Spacing::Single);
2749 bp_.spacing().set(Spacing::Onehalf);
2752 bp_.spacing().set(Spacing::Double);
2755 string s = widgetToDoubleStr(textLayoutModule->lspacingLE);
2757 bp_.spacing().set(Spacing::Single);
2759 bp_.spacing().set(Spacing::Other, s);
2764 if (textLayoutModule->twoColumnCB->isChecked())
2769 bp_.justification = textLayoutModule->justCB->isChecked();
2771 if (textLayoutModule->indentRB->isChecked()) {
2772 // if paragraphs are separated by an indentation
2773 bp_.paragraph_separation = BufferParams::ParagraphIndentSeparation;
2774 switch (textLayoutModule->indentCO->currentIndex()) {
2776 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2779 HSpace indent = HSpace(
2780 widgetsToLength(textLayoutModule->indentLE,
2781 textLayoutModule->indentLengthCO)
2783 bp_.setIndentation(indent);
2787 // this should never happen
2788 bp_.setIndentation(HSpace(HSpace::DEFAULT));
2792 // if paragraphs are separated by a skip
2793 bp_.paragraph_separation = BufferParams::ParagraphSkipSeparation;
2794 switch (textLayoutModule->skipCO->currentIndex()) {
2796 bp_.setDefSkip(VSpace(VSpace::SMALLSKIP));
2799 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2802 bp_.setDefSkip(VSpace(VSpace::BIGSKIP));
2807 widgetsToLength(textLayoutModule->skipLE,
2808 textLayoutModule->skipLengthCO)
2814 // this should never happen
2815 bp_.setDefSkip(VSpace(VSpace::MEDSKIP));
2821 fromqstr(latexModule->optionsLE->text());
2823 bp_.use_default_options =
2824 latexModule->defaultOptionsCB->isChecked();
2826 if (latexModule->childDocGB->isChecked())
2828 fromqstr(latexModule->childDocLE->text());
2830 bp_.master = string();
2833 bp_.clearIncludedChildren();
2834 if (masterChildModule->includeonlyRB->isChecked()) {
2835 list<string>::const_iterator it = includeonlys_.begin();
2836 for (; it != includeonlys_.end() ; ++it) {
2837 bp_.addIncludedChildren(*it);
2840 bp_.maintain_unincluded_children =
2841 masterChildModule->maintainAuxCB->isChecked();
2844 bp_.float_placement = floatModule->get();
2847 // text should have passed validation
2848 bp_.listings_params =
2849 InsetListingsParams(fromqstr(listingsModule->listingsED->toPlainText())).params();
2852 bp_.default_output_format = fromqstr(outputModule->defaultFormatCO->itemData(
2853 outputModule->defaultFormatCO->currentIndex()).toString());
2855 bool const nontexfonts = fontModule->osFontsCB->isChecked();
2856 bp_.useNonTeXFonts = nontexfonts;
2858 bp_.output_sync = outputModule->outputsyncCB->isChecked();
2860 bp_.output_sync_macro = fromqstr(outputModule->synccustomCB->currentText());
2862 int mathfmt = outputModule->mathoutCB->currentIndex();
2865 BufferParams::MathOutput const mo =
2866 static_cast<BufferParams::MathOutput>(mathfmt);
2867 bp_.html_math_output = mo;
2868 bp_.html_be_strict = outputModule->strictCB->isChecked();
2869 bp_.html_css_as_file = outputModule->cssCB->isChecked();
2870 bp_.html_math_img_scale = outputModule->mathimgSB->value();
2871 bp_.display_pixel_ratio = theGuiApp()->pixelRatio();
2873 bp_.save_transient_properties =
2874 outputModule->saveTransientPropertiesCB->isChecked();
2877 bp_.fonts_roman[nontexfonts] =
2878 fromqstr(fontModule->fontsRomanCO->
2879 itemData(fontModule->fontsRomanCO->currentIndex()).toString());
2880 bp_.fonts_roman[!nontexfonts] = fromqstr(fontModule->font_roman);
2882 bp_.fonts_sans[nontexfonts] =
2883 fromqstr(fontModule->fontsSansCO->
2884 itemData(fontModule->fontsSansCO->currentIndex()).toString());
2885 bp_.fonts_sans[!nontexfonts] = fromqstr(fontModule->font_sans);
2887 bp_.fonts_typewriter[nontexfonts] =
2888 fromqstr(fontModule->fontsTypewriterCO->
2889 itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
2890 bp_.fonts_typewriter[!nontexfonts] = fromqstr(fontModule->font_typewriter);
2892 bp_.fonts_math[nontexfonts] =
2893 fromqstr(fontModule->fontsMathCO->
2894 itemData(fontModule->fontsMathCO->currentIndex()).toString());
2895 bp_.fonts_math[!nontexfonts] = fromqstr(fontModule->font_math);
2897 QString const fontenc =
2898 fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
2899 if (fontenc == "custom")
2900 bp_.fontenc = fromqstr(fontModule->fontencLE->text());
2902 bp_.fontenc = fromqstr(fontenc);
2905 fromqstr(fontModule->cjkFontLE->text());
2907 bp_.use_microtype = fontModule->microtypeCB->isChecked();
2909 bp_.fonts_sans_scale[nontexfonts] = fontModule->scaleSansSB->value();
2910 bp_.fonts_sans_scale[!nontexfonts] = fontModule->font_sf_scale;
2912 bp_.fonts_typewriter_scale[nontexfonts] = fontModule->scaleTypewriterSB->value();
2913 bp_.fonts_typewriter_scale[!nontexfonts] = fontModule->font_tt_scale;
2915 bp_.fonts_expert_sc = fontModule->fontScCB->isChecked();
2917 bp_.fonts_old_figures = fontModule->fontOsfCB->isChecked();
2920 bp_.fonts_default_family = "default";
2922 bp_.fonts_default_family = GuiDocument::fontfamilies[
2923 fontModule->fontsDefaultCO->currentIndex()];
2925 if (fontModule->fontsizeCO->currentIndex() == 0)
2926 bp_.fontsize = "default";
2929 fromqstr(fontModule->fontsizeCO->currentText());
2932 bp_.papersize = PAPER_SIZE(
2933 pageLayoutModule->papersizeCO->currentIndex());
2935 bp_.paperwidth = widgetsToLength(pageLayoutModule->paperwidthLE,
2936 pageLayoutModule->paperwidthUnitCO);
2938 bp_.paperheight = widgetsToLength(pageLayoutModule->paperheightLE,
2939 pageLayoutModule->paperheightUnitCO);
2941 if (pageLayoutModule->facingPagesCB->isChecked())
2942 bp_.sides = TwoSides;
2944 bp_.sides = OneSide;
2946 if (pageLayoutModule->landscapeRB->isChecked())
2947 bp_.orientation = ORIENTATION_LANDSCAPE;
2949 bp_.orientation = ORIENTATION_PORTRAIT;
2952 bp_.use_geometry = !marginsModule->marginCB->isChecked();
2954 Ui::MarginsUi const * m = marginsModule;
2956 bp_.leftmargin = widgetsToLength(m->innerLE, m->innerUnit);
2957 bp_.topmargin = widgetsToLength(m->topLE, m->topUnit);
2958 bp_.rightmargin = widgetsToLength(m->outerLE, m->outerUnit);
2959 bp_.bottommargin = widgetsToLength(m->bottomLE, m->bottomUnit);
2960 bp_.headheight = widgetsToLength(m->headheightLE, m->headheightUnit);
2961 bp_.headsep = widgetsToLength(m->headsepLE, m->headsepUnit);
2962 bp_.footskip = widgetsToLength(m->footskipLE, m->footskipUnit);
2963 bp_.columnsep = widgetsToLength(m->columnsepLE, m->columnsepUnit);
2966 branchesModule->apply(bp_);
2969 PDFOptions & pdf = bp_.pdfoptions();
2970 pdf.use_hyperref = pdfSupportModule->use_hyperrefGB->isChecked();
2971 pdf.title = fromqstr(pdfSupportModule->titleLE->text());
2972 pdf.author = fromqstr(pdfSupportModule->authorLE->text());
2973 pdf.subject = fromqstr(pdfSupportModule->subjectLE->text());
2974 pdf.keywords = fromqstr(pdfSupportModule->keywordsLE->text());
2976 pdf.bookmarks = pdfSupportModule->bookmarksGB->isChecked();
2977 pdf.bookmarksnumbered = pdfSupportModule->bookmarksnumberedCB->isChecked();
2978 pdf.bookmarksopen = pdfSupportModule->bookmarksopenGB->isChecked();
2979 pdf.bookmarksopenlevel = pdfSupportModule->bookmarksopenlevelSB->value();
2981 pdf.breaklinks = pdfSupportModule->breaklinksCB->isChecked();
2982 pdf.pdfborder = pdfSupportModule->pdfborderCB->isChecked();
2983 pdf.pdfusetitle = pdfSupportModule->pdfusetitleCB->isChecked();
2984 pdf.colorlinks = pdfSupportModule->colorlinksCB->isChecked();
2986 backref_opts[pdfSupportModule->backrefCO->currentIndex()];
2987 if (pdfSupportModule->fullscreenCB->isChecked())
2988 pdf.pagemode = pdf.pagemode_fullscreen;
2990 pdf.pagemode.clear();
2991 pdf.quoted_options = pdf.quoted_options_check(
2992 fromqstr(pdfSupportModule->optionsLE->text()));
2995 nonModuleChanged_ = false;
2999 void GuiDocument::paramsToDialog()
3001 // set the default unit
3002 Length::UNIT const default_unit = Length::defaultUnit();
3005 preambleModule->update(bp_, id());
3006 localLayout->update(bp_, id());
3009 latexModule->suppressDateCB->setChecked(bp_.suppress_date);
3010 latexModule->refstyleCB->setChecked(bp_.use_refstyle);
3013 string const cite_engine = bp_.citeEngine().list().front();
3015 biblioModule->citeDefaultRB->setChecked(
3016 cite_engine == "basic");
3018 biblioModule->citeJurabibRB->setChecked(
3019 cite_engine == "jurabib");
3021 biblioModule->citeNatbibRB->setChecked(
3022 cite_engine == "natbib");
3024 biblioModule->citeStyleCO->setCurrentIndex(
3025 bp_.citeEngineType() & ENGINE_TYPE_NUMERICAL);
3027 updateEngineType(documentClass().opt_enginetype(),
3028 bp_.citeEngineType());
3030 biblioModule->bibtopicCB->setChecked(
3033 biblioModule->bibtexStyleLE->setText(toqstr(bp_.biblio_style));
3037 split(bp_.bibtex_command, command, ' ');
3039 int const bpos = biblioModule->bibtexCO->findData(toqstr(command));
3041 biblioModule->bibtexCO->setCurrentIndex(bpos);
3042 biblioModule->bibtexOptionsLE->setText(toqstr(options).trimmed());
3044 // We reset to default if we do not know the specified compiler
3045 // This is for security reasons
3046 biblioModule->bibtexCO->setCurrentIndex(
3047 biblioModule->bibtexCO->findData(toqstr("default")));
3048 biblioModule->bibtexOptionsLE->clear();
3050 biblioModule->bibtexOptionsLE->setEnabled(
3051 biblioModule->bibtexCO->currentIndex() != 0);
3053 biblioChanged_ = false;
3056 // We may be called when there is no Buffer, e.g., when
3057 // the last view has just been closed.
3058 bool const isReadOnly = isBufferAvailable() ? buffer().isReadonly() : false;
3059 indicesModule->update(bp_, isReadOnly);
3061 // language & quotes
3062 int const pos = langModule->languageCO->findData(toqstr(
3063 bp_.language->lang()));
3064 langModule->languageCO->setCurrentIndex(pos);
3066 langModule->quoteStyleCO->setCurrentIndex(
3067 bp_.quotes_language);
3069 bool default_enc = true;
3070 if (bp_.inputenc != "auto") {
3071 default_enc = false;
3072 if (bp_.inputenc == "default") {
3073 langModule->encodingCO->setCurrentIndex(0);
3076 Encodings::const_iterator it = encodings.begin();
3077 Encodings::const_iterator const end = encodings.end();
3078 for (; it != end; ++it) {
3079 if (it->name() == bp_.inputenc &&
3081 enc_gui = it->guiName();
3085 int const i = langModule->encodingCO->findText(
3088 langModule->encodingCO->setCurrentIndex(i);
3090 // unknown encoding. Set to default.
3094 langModule->defaultencodingRB->setChecked(default_enc);
3095 langModule->otherencodingRB->setChecked(!default_enc);
3097 int const p = langModule->languagePackageCO->findData(toqstr(bp_.lang_package));
3099 langModule->languagePackageCO->setCurrentIndex(
3100 langModule->languagePackageCO->findData("custom"));
3101 langModule->languagePackageLE->setText(toqstr(bp_.lang_package));
3103 langModule->languagePackageCO->setCurrentIndex(p);
3104 langModule->languagePackageLE->clear();
3108 if (bp_.isfontcolor) {
3109 colorModule->fontColorPB->setStyleSheet(
3110 colorButtonStyleSheet(rgb2qcolor(bp_.fontcolor)));
3112 set_fontcolor = bp_.fontcolor;
3113 is_fontcolor = bp_.isfontcolor;
3115 colorModule->noteFontColorPB->setStyleSheet(
3116 colorButtonStyleSheet(rgb2qcolor(bp_.notefontcolor)));
3117 set_notefontcolor = bp_.notefontcolor;
3119 if (bp_.isbackgroundcolor) {
3120 colorModule->backgroundPB->setStyleSheet(
3121 colorButtonStyleSheet(rgb2qcolor(bp_.backgroundcolor)));
3123 set_backgroundcolor = bp_.backgroundcolor;
3124 is_backgroundcolor = bp_.isbackgroundcolor;
3126 colorModule->boxBackgroundPB->setStyleSheet(
3127 colorButtonStyleSheet(rgb2qcolor(bp_.boxbgcolor)));
3128 set_boxbgcolor = bp_.boxbgcolor;
3131 int const min_toclevel = documentClass().min_toclevel();
3132 int const max_toclevel = documentClass().max_toclevel();
3133 if (documentClass().hasTocLevels()) {
3134 numberingModule->setEnabled(true);
3135 numberingModule->depthSL->setMinimum(min_toclevel - 1);
3136 numberingModule->depthSL->setMaximum(max_toclevel);
3137 numberingModule->depthSL->setValue(bp_.secnumdepth);
3138 numberingModule->tocSL->setMaximum(min_toclevel - 1);
3139 numberingModule->tocSL->setMaximum(max_toclevel);
3140 numberingModule->tocSL->setValue(bp_.tocdepth);
3143 numberingModule->setEnabled(false);
3144 numberingModule->tocTW->clear();
3148 bulletsModule->setBullet(0, bp_.user_defined_bullet(0));
3149 bulletsModule->setBullet(1, bp_.user_defined_bullet(1));
3150 bulletsModule->setBullet(2, bp_.user_defined_bullet(2));
3151 bulletsModule->setBullet(3, bp_.user_defined_bullet(3));
3152 bulletsModule->init();
3155 int nitem = findToken(tex_graphics, bp_.graphics_driver);
3157 latexModule->psdriverCO->setCurrentIndex(nitem);
3160 map<string, string> const & packages = BufferParams::auto_packages();
3161 for (map<string, string>::const_iterator it = packages.begin();
3162 it != packages.end(); ++it) {
3163 QTableWidgetItem * item = mathsModule->packagesTW->findItems(toqstr(it->first), Qt::MatchExactly)[0];
3166 int row = mathsModule->packagesTW->row(item);
3167 switch (bp_.use_package(it->first)) {
3168 case BufferParams::package_off: {
3169 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 3);
3170 rb->setChecked(true);
3173 case BufferParams::package_on: {
3174 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 2);
3175 rb->setChecked(true);
3178 case BufferParams::package_auto: {
3179 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, 1);
3180 rb->setChecked(true);
3186 switch (bp_.spacing().getSpace()) {
3187 case Spacing::Other: nitem = 3; break;
3188 case Spacing::Double: nitem = 2; break;
3189 case Spacing::Onehalf: nitem = 1; break;
3190 case Spacing::Default: case Spacing::Single: nitem = 0; break;
3194 string const & layoutID = bp_.baseClassID();
3195 setLayoutComboByIDString(layoutID);
3197 updatePagestyle(documentClass().opt_pagestyle(),
3200 textLayoutModule->lspacingCO->setCurrentIndex(nitem);
3201 if (bp_.spacing().getSpace() == Spacing::Other) {
3202 doubleToWidget(textLayoutModule->lspacingLE,
3203 bp_.spacing().getValueAsString());
3207 if (bp_.paragraph_separation == BufferParams::ParagraphIndentSeparation) {
3208 textLayoutModule->indentRB->setChecked(true);
3209 string indentation = bp_.getIndentation().asLyXCommand();
3211 if (indentation != "default") {
3212 lengthToWidgets(textLayoutModule->indentLE,
3213 textLayoutModule->indentLengthCO,
3214 indentation, default_unit);
3217 textLayoutModule->indentCO->setCurrentIndex(indent);
3220 textLayoutModule->skipRB->setChecked(true);
3222 switch (bp_.getDefSkip().kind()) {
3223 case VSpace::SMALLSKIP:
3226 case VSpace::MEDSKIP:
3229 case VSpace::BIGSKIP:
3232 case VSpace::LENGTH:
3235 string const length = bp_.getDefSkip().asLyXCommand();
3236 lengthToWidgets(textLayoutModule->skipLE,
3237 textLayoutModule->skipLengthCO,
3238 length, default_unit);
3245 textLayoutModule->skipCO->setCurrentIndex(skip);
3249 textLayoutModule->twoColumnCB->setChecked(
3251 textLayoutModule->justCB->setChecked(bp_.justification);
3253 if (!bp_.options.empty()) {
3254 latexModule->optionsLE->setText(
3255 toqstr(bp_.options));
3257 latexModule->optionsLE->setText(QString());
3261 latexModule->defaultOptionsCB->setChecked(
3262 bp_.use_default_options);
3263 updateSelectedModules();
3264 selectionManager->updateProvidedModules(
3265 bp_.baseClass()->providedModules());
3266 selectionManager->updateExcludedModules(
3267 bp_.baseClass()->excludedModules());
3269 if (!documentClass().options().empty()) {
3270 latexModule->defaultOptionsLE->setText(
3271 toqstr(documentClass().options()));
3273 latexModule->defaultOptionsLE->setText(
3274 toqstr(_("[No options predefined]")));
3277 latexModule->defaultOptionsLE->setEnabled(
3278 bp_.use_default_options
3279 && !documentClass().options().empty());
3281 latexModule->defaultOptionsCB->setEnabled(
3282 !documentClass().options().empty());
3284 if (!bp_.master.empty()) {
3285 latexModule->childDocGB->setChecked(true);
3286 latexModule->childDocLE->setText(
3287 toqstr(bp_.master));
3289 latexModule->childDocLE->setText(QString());
3290 latexModule->childDocGB->setChecked(false);
3294 if (!bufferview() || !buffer().hasChildren()) {
3295 masterChildModule->childrenTW->clear();
3296 includeonlys_.clear();
3297 docPS->showPanel("Child Documents", false);
3298 if (docPS->isCurrentPanel("Child Documents"))
3299 docPS->setCurrentPanel("Document Class");
3301 docPS->showPanel("Child Documents", true);
3302 masterChildModule->setEnabled(true);
3303 includeonlys_ = bp_.getIncludedChildren();
3304 updateIncludeonlys();
3306 masterChildModule->maintainAuxCB->setChecked(
3307 bp_.maintain_unincluded_children);
3310 floatModule->set(bp_.float_placement);
3313 // break listings_params to multiple lines
3315 InsetListingsParams(bp_.listings_params).separatedParams();
3316 listingsModule->listingsED->setPlainText(toqstr(lstparams));
3319 // some languages only work with polyglossia/XeTeX
3320 Language const * lang = lyx::languages.getLanguage(
3321 fromqstr(langModule->languageCO->itemData(
3322 langModule->languageCO->currentIndex()).toString()));
3323 bool const need_fontspec =
3324 lang->babel().empty() && !lang->polyglossia().empty();
3325 bool const os_fonts_available =
3326 bp_.baseClass()->outputType() == lyx::LATEX
3327 && LaTeXFeatures::isAvailable("fontspec");
3328 fontModule->osFontsCB->setEnabled(os_fonts_available && !need_fontspec);
3329 fontModule->osFontsCB->setChecked(
3330 (os_fonts_available && bp_.useNonTeXFonts) || need_fontspec);
3331 updateFontsize(documentClass().opt_fontsize(),
3334 QString font = toqstr(bp_.fontsRoman());
3335 int rpos = fontModule->fontsRomanCO->findData(font);
3337 rpos = fontModule->fontsRomanCO->count();
3338 fontModule->fontsRomanCO->addItem(font + qt_(" (not installed)"), font);
3340 fontModule->fontsRomanCO->setCurrentIndex(rpos);
3341 fontModule->font_roman = toqstr(bp_.fonts_roman[!bp_.useNonTeXFonts]);
3343 font = toqstr(bp_.fontsSans());
3344 int spos = fontModule->fontsSansCO->findData(font);
3346 spos = fontModule->fontsSansCO->count();
3347 fontModule->fontsSansCO->addItem(font + qt_(" (not installed)"), font);
3349 fontModule->fontsSansCO->setCurrentIndex(spos);
3350 fontModule->font_sans = toqstr(bp_.fonts_sans[!bp_.useNonTeXFonts]);
3352 font = toqstr(bp_.fontsTypewriter());
3353 int tpos = fontModule->fontsTypewriterCO->findData(font);
3355 tpos = fontModule->fontsTypewriterCO->count();
3356 fontModule->fontsTypewriterCO->addItem(font + qt_(" (not installed)"), font);
3358 fontModule->fontsTypewriterCO->setCurrentIndex(tpos);
3359 fontModule->font_typewriter = toqstr(bp_.fonts_typewriter[!bp_.useNonTeXFonts]);
3361 font = toqstr(bp_.fontsMath());
3362 int mpos = fontModule->fontsMathCO->findData(font);
3364 mpos = fontModule->fontsMathCO->count();
3365 fontModule->fontsMathCO->addItem(font + qt_(" (not installed)"), font);
3367 fontModule->fontsMathCO->setCurrentIndex(mpos);
3368 fontModule->font_math = toqstr(bp_.fonts_math[!bp_.useNonTeXFonts]);
3370 if (bp_.useNonTeXFonts && os_fonts_available) {
3371 fontModule->fontencLA->setEnabled(false);
3372 fontModule->fontencCO->setEnabled(false);
3373 fontModule->fontencLE->setEnabled(false);
3375 fontModule->fontencLA->setEnabled(true);
3376 fontModule->fontencCO->setEnabled(true);
3377 fontModule->fontencLE->setEnabled(true);
3383 if (!bp_.fonts_cjk.empty())
3384 fontModule->cjkFontLE->setText(
3385 toqstr(bp_.fonts_cjk));
3387 fontModule->cjkFontLE->setText(QString());
3389 fontModule->microtypeCB->setChecked(bp_.use_microtype);
3391 fontModule->fontScCB->setChecked(bp_.fonts_expert_sc);
3392 fontModule->fontOsfCB->setChecked(bp_.fonts_old_figures);
3393 fontModule->scaleSansSB->setValue(bp_.fontsSansScale());
3394 fontModule->font_sf_scale = bp_.fonts_sans_scale[!bp_.useNonTeXFonts];
3395 fontModule->scaleTypewriterSB->setValue(bp_.fontsTypewriterScale());
3396 fontModule->font_tt_scale = bp_.fonts_typewriter_scale[!bp_.useNonTeXFonts];
3398 int nn = findToken(GuiDocument::fontfamilies, bp_.fonts_default_family);
3400 fontModule->fontsDefaultCO->setCurrentIndex(nn);
3402 if (bp_.fontenc == "global" || bp_.fontenc == "default") {
3403 fontModule->fontencCO->setCurrentIndex(
3404 fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
3405 fontModule->fontencLE->setEnabled(false);
3407 fontModule->fontencCO->setCurrentIndex(1);
3408 fontModule->fontencLE->setText(toqstr(bp_.fontenc));
3412 // This must be set _after_ fonts since updateDefaultFormat()
3413 // checks osFontsCB settings.
3414 // update combobox with formats
3415 updateDefaultFormat();
3416 int index = outputModule->defaultFormatCO->findData(toqstr(
3417 bp_.default_output_format));
3418 // set to default if format is not found
3421 outputModule->defaultFormatCO->setCurrentIndex(index);
3423 outputModule->outputsyncCB->setChecked(bp_.output_sync);
3424 outputModule->synccustomCB->setEditText(toqstr(bp_.output_sync_macro));
3426 outputModule->mathimgSB->setValue(bp_.html_math_img_scale);
3427 outputModule->mathoutCB->setCurrentIndex(bp_.html_math_output);
3428 outputModule->strictCB->setChecked(bp_.html_be_strict);
3429 outputModule->cssCB->setChecked(bp_.html_css_as_file);
3431 outputModule->saveTransientPropertiesCB
3432 ->setChecked(bp_.save_transient_properties);
3435 bool const extern_geometry =
3436 documentClass().provides("geometry");
3437 int const psize = bp_.papersize;
3438 pageLayoutModule->papersizeCO->setCurrentIndex(psize);
3439 setCustomPapersize(!extern_geometry && psize == 1);
3440 pageLayoutModule->papersizeCO->setEnabled(!extern_geometry);
3442 bool const landscape =
3443 bp_.orientation == ORIENTATION_LANDSCAPE;
3444 pageLayoutModule->landscapeRB->setChecked(landscape);
3445 pageLayoutModule->portraitRB->setChecked(!landscape);
3446 pageLayoutModule->landscapeRB->setEnabled(!extern_geometry);
3447 pageLayoutModule->portraitRB->setEnabled(!extern_geometry);
3449 pageLayoutModule->facingPagesCB->setChecked(
3450 bp_.sides == TwoSides);
3452 lengthToWidgets(pageLayoutModule->paperwidthLE,
3453 pageLayoutModule->paperwidthUnitCO, bp_.paperwidth, default_unit);
3454 lengthToWidgets(pageLayoutModule->paperheightLE,
3455 pageLayoutModule->paperheightUnitCO, bp_.paperheight, default_unit);
3458 Ui::MarginsUi * m = marginsModule;
3462 lengthToWidgets(m->topLE, m->topUnit,
3463 bp_.topmargin, default_unit);
3465 lengthToWidgets(m->bottomLE, m->bottomUnit,
3466 bp_.bottommargin, default_unit);
3468 lengthToWidgets(m->innerLE, m->innerUnit,
3469 bp_.leftmargin, default_unit);
3471 lengthToWidgets(m->outerLE, m->outerUnit,
3472 bp_.rightmargin, default_unit);
3474 lengthToWidgets(m->headheightLE, m->headheightUnit,
3475 bp_.headheight, default_unit);
3477 lengthToWidgets(m->headsepLE, m->headsepUnit,
3478 bp_.headsep, default_unit);
3480 lengthToWidgets(m->footskipLE, m->footskipUnit,
3481 bp_.footskip, default_unit);
3483 lengthToWidgets(m->columnsepLE, m->columnsepUnit,
3484 bp_.columnsep, default_unit);
3487 updateUnknownBranches();
3488 branchesModule->update(bp_);
3491 PDFOptions const & pdf = bp_.pdfoptions();
3492 pdfSupportModule->use_hyperrefGB->setChecked(pdf.use_hyperref);
3493 if (bp_.documentClass().provides("hyperref"))
3494 pdfSupportModule->use_hyperrefGB->setTitle(qt_("C&ustomize Hyperref Options"));
3496 pdfSupportModule->use_hyperrefGB->setTitle(qt_("&Use Hyperref Support"));
3497 pdfSupportModule->titleLE->setText(toqstr(pdf.title));
3498 pdfSupportModule->authorLE->setText(toqstr(pdf.author));
3499 pdfSupportModule->subjectLE->setText(toqstr(pdf.subject));
3500 pdfSupportModule->keywordsLE->setText(toqstr(pdf.keywords));
3502 pdfSupportModule->bookmarksGB->setChecked(pdf.bookmarks);
3503 pdfSupportModule->bookmarksnumberedCB->setChecked(pdf.bookmarksnumbered);
3504 pdfSupportModule->bookmarksopenGB->setChecked(pdf.bookmarksopen);
3506 pdfSupportModule->bookmarksopenlevelSB->setValue(pdf.bookmarksopenlevel);
3508 pdfSupportModule->breaklinksCB->setChecked(pdf.breaklinks);
3509 pdfSupportModule->pdfborderCB->setChecked(pdf.pdfborder);
3510 pdfSupportModule->pdfusetitleCB->setChecked(pdf.pdfusetitle);
3511 pdfSupportModule->colorlinksCB->setChecked(pdf.colorlinks);
3513 nn = findToken(backref_opts, pdf.backref);
3515 pdfSupportModule->backrefCO->setCurrentIndex(nn);
3517 pdfSupportModule->fullscreenCB->setChecked
3518 (pdf.pagemode == pdf.pagemode_fullscreen);
3520 pdfSupportModule->optionsLE->setText(
3521 toqstr(pdf.quoted_options));
3523 // Make sure that the bc is in the INITIAL state
3524 if (bc().policy().buttonStatus(ButtonPolicy::RESTORE))
3527 // clear changed branches cache
3528 changedBranches_.clear();
3531 nonModuleChanged_ = false;
3535 void GuiDocument::saveDocDefault()
3537 // we have to apply the params first
3543 void GuiDocument::updateAvailableModules()
3545 modules_av_model_.clear();
3546 list<modInfoStruct> modInfoList = getModuleInfo();
3547 // Sort names according to the locale
3548 modInfoList.sort([](modInfoStruct const & a, modInfoStruct const & b) {
3549 return 0 < b.name.localeAwareCompare(a.name);
3552 for (modInfoStruct const & m : modInfoList) {
3553 modules_av_model_.insertRow(i, m.name, m.id, m.description);
3559 void GuiDocument::updateSelectedModules()
3561 modules_sel_model_.clear();
3562 list<modInfoStruct> const selModList = getSelectedModules();
3564 for (modInfoStruct const & m : selModList) {
3565 modules_sel_model_.insertRow(i, m.name, m.id, m.description);
3571 void GuiDocument::updateIncludeonlys()
3573 masterChildModule->childrenTW->clear();
3574 QString const no = qt_("No");
3575 QString const yes = qt_("Yes");
3577 if (includeonlys_.empty()) {
3578 masterChildModule->includeallRB->setChecked(true);
3579 masterChildModule->childrenTW->setEnabled(false);
3580 masterChildModule->maintainAuxCB->setEnabled(false);
3582 masterChildModule->includeonlyRB->setChecked(true);
3583 masterChildModule->childrenTW->setEnabled(true);
3584 masterChildModule->maintainAuxCB->setEnabled(true);
3586 ListOfBuffers children = buffer().getChildren();
3587 ListOfBuffers::const_iterator it = children.begin();
3588 ListOfBuffers::const_iterator end = children.end();
3589 bool has_unincluded = false;
3590 bool all_unincluded = true;
3591 for (; it != end; ++it) {
3592 QTreeWidgetItem * item = new QTreeWidgetItem(masterChildModule->childrenTW);
3595 to_utf8(makeRelPath(from_utf8((*it)->fileName().absFileName()),
3596 from_utf8(buffer().filePath())));
3597 item->setText(0, toqstr(name));
3598 item->setText(1, isChildIncluded(name) ? yes : no);
3599 if (!isChildIncluded(name))
3600 has_unincluded = true;
3602 all_unincluded = false;
3604 // Both if all childs are included and if none is included
3605 // is equal to "include all" (i.e., ommit \includeonly).
3606 // Thus, reset the GUI.
3607 if (!has_unincluded || all_unincluded) {
3608 masterChildModule->includeallRB->setChecked(true);
3609 masterChildModule->childrenTW->setEnabled(false);
3610 includeonlys_.clear();
3612 // If all are included, we need to update again.
3613 if (!has_unincluded)
3614 updateIncludeonlys();
3618 void GuiDocument::updateContents()
3620 // Nothing to do here as the document settings is not cursor dependant.
3625 void GuiDocument::useClassDefaults()
3627 if (applyPB->isEnabled()) {
3628 int const ret = Alert::prompt(_("Unapplied changes"),
3629 _("Some changes in the dialog were not yet applied.\n"
3630 "If you do not apply now, they will be lost after this action."),
3631 1, 1, _("&Apply"), _("&Dismiss"));
3636 int idx = latexModule->classCO->currentIndex();
3637 string const classname = fromqstr(latexModule->classCO->getData(idx));
3638 if (!bp_.setBaseClass(classname)) {
3639 Alert::error(_("Error"), _("Unable to set document class."));
3642 bp_.useClassDefaults();
3647 void GuiDocument::setLayoutComboByIDString(string const & idString)
3649 if (!latexModule->classCO->set(toqstr(idString)))
3650 Alert::warning(_("Can't set layout!"),
3651 bformat(_("Unable to set layout for ID: %1$s"), from_utf8(idString)));
3655 bool GuiDocument::isValid()
3658 validateListingsParameters().isEmpty() &&
3659 localLayout->isValid() &&
3661 // if we're asking for skips between paragraphs
3662 !textLayoutModule->skipRB->isChecked() ||
3663 // then either we haven't chosen custom
3664 textLayoutModule->skipCO->currentIndex() != 3 ||
3665 // or else a length has been given
3666 !textLayoutModule->skipLE->text().isEmpty()
3669 // if we're asking for indentation
3670 !textLayoutModule->indentRB->isChecked() ||
3671 // then either we haven't chosen custom
3672 textLayoutModule->indentCO->currentIndex() != 1 ||
3673 // or else a length has been given
3674 !textLayoutModule->indentLE->text().isEmpty()
3679 char const * const GuiDocument::fontfamilies[5] = {
3680 "default", "rmdefault", "sfdefault", "ttdefault", ""
3684 char const * GuiDocument::fontfamilies_gui[5] = {
3685 N_("Default"), N_("Roman"), N_("Sans Serif"), N_("Typewriter"), ""
3689 bool GuiDocument::initialiseParams(string const &)
3691 BufferView const * view = bufferview();
3693 bp_ = BufferParams();
3697 bp_ = view->buffer().params();
3699 updateAvailableModules();
3700 //FIXME It'd be nice to make sure here that the selected
3701 //modules are consistent: That required modules are actually
3702 //selected, and that we don't have conflicts. If so, we could
3703 //at least pop up a warning.
3709 void GuiDocument::clearParams()
3711 bp_ = BufferParams();
3715 BufferId GuiDocument::id() const
3717 BufferView const * const view = bufferview();
3718 return view? &view->buffer() : 0;
3722 list<GuiDocument::modInfoStruct> const & GuiDocument::getModuleInfo()
3724 return moduleNames_;
3728 list<GuiDocument::modInfoStruct> const
3729 GuiDocument::makeModuleInfo(LayoutModuleList const & mods)
3731 list<modInfoStruct> mInfo;
3732 for (string const & name : mods) {
3734 LyXModule const * const mod = theModuleList[name];
3739 m.name = toqstr(name + " (") + qt_("Not Found") + toqstr(")");
3747 list<GuiDocument::modInfoStruct> const GuiDocument::getSelectedModules()
3749 return makeModuleInfo(params().getModules());
3753 list<GuiDocument::modInfoStruct> const GuiDocument::getProvidedModules()
3755 return makeModuleInfo(params().baseClass()->providedModules());
3759 DocumentClass const & GuiDocument::documentClass() const
3761 return bp_.documentClass();
3765 static void dispatch_bufferparams(Dialog const & dialog,
3766 BufferParams const & bp, FuncCode lfun, Buffer const * buf)
3769 ss << "\\begin_header\n";
3770 bp.writeFile(ss, buf);
3771 ss << "\\end_header\n";
3772 dialog.dispatch(FuncRequest(lfun, ss.str()));
3776 void GuiDocument::dispatchParams()
3778 // We need a non-const buffer object.
3779 Buffer & buf = const_cast<BufferView *>(bufferview())->buffer();
3780 // There may be several undo records; group them (bug #8998)
3781 buf.undo().beginUndoGroup();
3783 // This must come first so that a language change is correctly noticed
3786 // Apply the BufferParams. Note that this will set the base class
3787 // and then update the buffer's layout.
3788 dispatch_bufferparams(*this, params(), LFUN_BUFFER_PARAMS_APPLY, &buffer());
3790 if (!params().master.empty()) {
3791 FileName const master_file = support::makeAbsPath(params().master,
3792 support::onlyPath(buffer().absFileName()));
3793 if (isLyXFileName(master_file.absFileName())) {
3794 Buffer * master = checkAndLoadLyXFile(master_file);
3796 if (master->isChild(const_cast<Buffer *>(&buffer())))
3797 const_cast<Buffer &>(buffer()).setParent(master);
3799 Alert::warning(_("Assigned master does not include this file"),
3800 bformat(_("You must include this file in the document\n"
3801 "'%1$s' in order to use the master document\n"
3802 "feature."), from_utf8(params().master)));
3804 Alert::warning(_("Could not load master"),
3805 bformat(_("The master document '%1$s'\n"
3806 "could not be loaded."),
3807 from_utf8(params().master)));
3811 // Generate the colours requested by each new branch.
3812 BranchList & branchlist = params().branchlist();
3813 if (!branchlist.empty()) {
3814 BranchList::const_iterator it = branchlist.begin();
3815 BranchList::const_iterator const end = branchlist.end();
3816 for (; it != end; ++it) {
3817 docstring const & current_branch = it->branch();
3818 Branch const * branch = branchlist.find(current_branch);
3819 string const x11hexname = X11hexname(branch->color());
3820 // display the new color
3821 docstring const str = current_branch + ' ' + from_ascii(x11hexname);
3822 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3825 // Open insets of selected branches, close deselected ones
3826 dispatch(FuncRequest(LFUN_INSET_FORALL,
3827 "Branch inset-toggle assign"));
3829 // rename branches in the document
3830 executeBranchRenaming();
3831 // and clear changed branches cache
3832 changedBranches_.clear();
3834 // Generate the colours requested by indices.
3835 IndicesList & indiceslist = params().indiceslist();
3836 if (!indiceslist.empty()) {
3837 IndicesList::const_iterator it = indiceslist.begin();
3838 IndicesList::const_iterator const end = indiceslist.end();
3839 for (; it != end; ++it) {
3840 docstring const & current_index = it->shortcut();
3841 Index const * index = indiceslist.findShortcut(current_index);
3842 string const x11hexname = X11hexname(index->color());
3843 // display the new color
3844 docstring const str = current_index + ' ' + from_ascii(x11hexname);
3845 dispatch(FuncRequest(LFUN_SET_COLOR, str));
3849 // If we used an LFUN, we would not need these two lines:
3850 BufferView * bv = const_cast<BufferView *>(bufferview());
3851 bv->processUpdateFlags(Update::Force | Update::FitCursor);
3853 // Don't forget to close the group. Note that it is important
3854 // to check that there is no early return in the method.
3855 buf.undo().endUndoGroup();
3859 void GuiDocument::setLanguage() const
3861 Language const * const newL = bp_.language;
3862 if (buffer().params().language == newL)
3865 string const & lang_name = newL->lang();
3866 dispatch(FuncRequest(LFUN_BUFFER_LANGUAGE, lang_name));
3870 void GuiDocument::saveAsDefault() const
3872 dispatch_bufferparams(*this, params(), LFUN_BUFFER_SAVE_AS_DEFAULT, &buffer());
3876 bool GuiDocument::providesOSF(QString const & font) const
3878 if (fontModule->osFontsCB->isChecked())
3879 // FIXME: we should check if the fonts really
3880 // have OSF support. But how?
3882 return theLaTeXFonts().getLaTeXFont(
3883 qstring_to_ucs4(font)).providesOSF(ot1(),
3889 bool GuiDocument::providesSC(QString const & font) const
3891 if (fontModule->osFontsCB->isChecked())
3893 return theLaTeXFonts().getLaTeXFont(
3894 qstring_to_ucs4(font)).providesSC(ot1(),
3900 bool GuiDocument::providesScale(QString const & font) const
3902 if (fontModule->osFontsCB->isChecked())
3904 return theLaTeXFonts().getLaTeXFont(
3905 qstring_to_ucs4(font)).providesScale(ot1(),
3911 bool GuiDocument::providesNoMath(QString const & font) const
3913 if (fontModule->osFontsCB->isChecked())
3915 return theLaTeXFonts().getLaTeXFont(
3916 qstring_to_ucs4(font)).providesNoMath(ot1(),
3921 bool GuiDocument::hasMonolithicExpertSet(QString const & font) const
3923 if (fontModule->osFontsCB->isChecked())
3925 return theLaTeXFonts().getLaTeXFont(
3926 qstring_to_ucs4(font)).hasMonolithicExpertSet(ot1(),
3933 GuiDocument::modInfoStruct GuiDocument::modInfo(LyXModule const & mod)
3935 // FIXME Unicode: docstrings would be better for these parameters but this
3936 // change requires a lot of others
3939 m.name = toqstr(translateIfPossible(from_utf8(mod.getName())));
3940 QString desc = toqstr(translateIfPossible(from_utf8(mod.getDescription())));
3941 // Find the first sentence of the description
3942 QTextBoundaryFinder bf(QTextBoundaryFinder::Sentence, desc);
3943 int pos = bf.toNextBoundary();
3946 QString modulename = QString(qt_("(Module name: %1)")).arg(toqstr(m.id));
3947 // Tooltip is the desc followed by the module name
3948 m.description = QString("%1<i>%2</i>")
3949 .arg(desc.isEmpty() ? QString() : QString("<p>%1</p>").arg(desc),
3955 void GuiDocument::loadModuleInfo()
3957 moduleNames_.clear();
3958 for (LyXModule const & mod : theModuleList)
3959 if (mod.category().substr(0, 8) != "Citation")
3960 moduleNames_.push_back(modInfo(mod));
3964 void GuiDocument::updateUnknownBranches()
3968 list<docstring> used_branches;
3969 buffer().getUsedBranches(used_branches);
3970 list<docstring>::const_iterator it = used_branches.begin();
3971 QStringList unknown_branches;
3972 for (; it != used_branches.end() ; ++it) {
3973 if (!buffer().params().branchlist().find(*it))
3974 unknown_branches.append(toqstr(*it));
3976 branchesModule->setUnknownBranches(unknown_branches);
3980 void GuiDocument::branchesRename(docstring const & oldname, docstring const & newname)
3982 map<docstring, docstring>::iterator it = changedBranches_.begin();
3983 for (; it != changedBranches_.end() ; ++it) {
3984 if (it->second == oldname) {
3985 // branch has already been renamed
3986 it->second = newname;
3991 changedBranches_[oldname] = newname;
3995 void GuiDocument::executeBranchRenaming() const
3997 map<docstring, docstring>::const_iterator it = changedBranches_.begin();
3998 for (; it != changedBranches_.end() ; ++it) {
3999 docstring const arg = '"' + it->first + '"' + " " + '"' + it->second + '"';
4000 dispatch(FuncRequest(LFUN_BRANCHES_RENAME, arg));
4005 void GuiDocument::allPackagesAuto()
4011 void GuiDocument::allPackagesAlways()
4017 void GuiDocument::allPackagesNot()
4023 void GuiDocument::allPackages(int col)
4025 for (int row = 0; row < mathsModule->packagesTW->rowCount(); ++row) {
4026 QRadioButton * rb = (QRadioButton*)mathsModule->packagesTW->cellWidget(row, col);
4027 rb->setChecked(true);
4032 Dialog * createGuiDocument(GuiView & lv) { return new GuiDocument(lv); }
4035 } // namespace frontend
4038 #include "moc_GuiDocument.cpp"